# CompactClassificationNeuralNetwork

Compact neural network model for classification

## Description

`CompactClassificationNeuralNetwork`

is a compact version of a
`ClassificationNeuralNetwork`

model object. The compact model does not include the
data used for training the classifier. Therefore, you cannot perform some tasks, such as
cross-validation, using the compact model. Use a compact model for tasks such as predicting
the labels of new data.

## Creation

Create a `CompactClassificationNeuralNetwork`

object from a full `ClassificationNeuralNetwork`

model object by using `compact`

.

## Properties

### Neural Network Properties

`LayerSizes`

— Sizes of fully connected layers

positive integer vector

This property is read-only.

Sizes of the fully connected layers in the neural network model, returned as a
positive integer vector. The *i*th element of
`LayerSizes`

is the number of outputs in the
*i*th fully connected layer of the neural network model.

`LayerSizes`

does not include the size of the final fully
connected layer. This layer always has *K* outputs, where
*K* is the number of classes in the response variable.

**Data Types: **`single`

| `double`

`LayerWeights`

— Learned layer weights

cell array

This property is read-only.

Learned layer weights for the fully connected layers, returned as a cell array.
The *i*th entry in the cell array corresponds to the layer weights
for the *i*th fully connected layer. For example,
`Mdl.LayerWeights{1}`

returns the weights for the first fully
connected layer of the model `Mdl`

.

`LayerWeights`

includes the weights for the final fully
connected layer.

**Data Types: **`cell`

`LayerBiases`

— Learned layer biases

cell array

This property is read-only.

Learned layer biases for the fully connected layers, returned as a cell array. The
*i*th entry in the cell array corresponds to the layer biases for
the *i*th fully connected layer. For example,
`Mdl.LayerBiases{1}`

returns the biases for the first fully
connected layer of the model `Mdl`

.

`LayerBiases`

includes the biases for the final fully connected
layer.

**Data Types: **`cell`

`Activations`

— Activation functions for fully connected layers

`'relu'`

| `'tanh'`

| `'sigmoid'`

| `'none'`

| cell array of character vectors

This property is read-only.

Activation functions for the fully connected layers of the neural network model, returned as a character vector or cell array of character vectors with values from this table.

Value | Description |
---|---|

`'relu'` | Rectified linear unit (ReLU) function — Performs a threshold operation on each element of the input, where any value less than zero is set to zero, that is, $$f\left(x\right)=\{\begin{array}{cc}x,& x\ge 0\\ 0,& x<0\end{array}$$ |

`'tanh'` | Hyperbolic tangent (tanh) function — Applies the |

`'sigmoid'` | Sigmoid function — Performs the following operation on each input element: $$f(x)=\frac{1}{1+{e}^{-x}}$$ |

`'none'` | Identity function — Returns each input element without performing any transformation, that is, |

If

`Activations`

contains only one activation function, then it is the activation function for every fully connected layer of the neural network model, excluding the final fully connected layer. The activation function for the final fully connected layer is always softmax (`OutputLayerActivation`

).If

`Activations`

is an array of activation functions, then the*i*th element is the activation function for the*i*th layer of the neural network model.

**Data Types: **`char`

| `cell`

`OutputLayerActivation`

— Activation function for final fully connected layer

`'softmax'`

This property is read-only.

Activation function for the final fully connected layer, returned as
`'softmax'`

. The function takes each input
*x _{i}* and returns the following, where

*K*is the number of classes in the response variable:

$$f({x}_{i})=\frac{\mathrm{exp}({x}_{i})}{{\displaystyle \sum _{j=1}^{K}\mathrm{exp}({x}_{j})}}.$$

The results correspond to the predicted classification scores (or posterior probabilities).

### Data Properties

`PredictorNames`

— Predictor variable names

cell array of character vectors

This property is read-only.

Predictor variable names, returned as a cell array of character vectors. The order
of the elements of `PredictorNames`

corresponds to the order in which
the predictor names appear in the training data.

**Data Types: **`cell`

`CategoricalPredictors`

— Categorical predictor indices

vector of positive integers | `[]`

This property is read-only.

Categorical predictor indices, returned as a
vector of positive integers. Assuming that the predictor data contains observations in
rows, `CategoricalPredictors`

contains index values corresponding to
the columns of the predictor data that contain categorical predictors. If none of the
predictors are categorical, then this property is empty
(`[]`

).

**Data Types: **`double`

`ExpandedPredictorNames`

— Expanded predictor names

cell array of character vectors

This property is read-only.

Expanded predictor names, returned as a cell array of character vectors. If the
model uses encoding for categorical variables, then
`ExpandedPredictorNames`

includes the names that describe the
expanded variables. Otherwise, `ExpandedPredictorNames`

is the same
as `PredictorNames`

.

**Data Types: **`cell`

`ClassNames`

— Unique class names

numeric vector | categorical vector | logical vector | character array | cell array of character vectors

This property is read-only.

Unique class names used in training, returned as a numeric vector, categorical
vector, logical vector, character array, or cell array of character vectors.
`ClassNames`

has the same data type as the class labels in the
response variable used to train the model. (The software treats string arrays as cell arrays of character vectors.)
`ClassNames`

also determines the class order.

**Data Types: **`single`

| `double`

| `categorical`

| `logical`

| `char`

| `cell`

`ResponseName`

— Response variable name

character vector

This property is read-only.

Response variable name, returned as a character vector.

**Data Types: **`char`

### Other Classification Properties

`Cost`

— Misclassification cost

numeric square matrix

This property is read-only.

Misclassification cost, returned as a numeric square matrix, where
`Cost(i,j)`

is the cost of classifying a point into class
`j`

if its true class is `i`

. The cost matrix
always has this form: `Cost(i,j) = 1`

if `i ~= j`

,
and `Cost(i,j) = 0`

if `i = j`

. The rows correspond
to the true class and the columns correspond to the predicted class. The order of the
rows and columns of `Cost`

corresponds to the order of the classes
in `ClassNames`

.

**Data Types: **`double`

`Prior`

— Prior probabilities

numeric vector

This property is read-only.

Prior probabilities for each class, returned as a numeric vector. The order of the
elements of `Prior`

corresponds to the elements of
`ClassNames`

.

**Data Types: **`double`

`ScoreTransform`

— Score transformation

character vector | function handle

Score transformation, specified as a character vector or function handle. `ScoreTransform`

represents a built-in transformation function or a function handle for transforming predicted classification scores.

To change the score transformation function to * function*, for example, use dot notation.

For a built-in function, enter a character vector.

Mdl.ScoreTransform = '

*function*';This table describes the available built-in functions.

Value Description `'doublelogit'`

1/(1 + *e*^{–2x})`'invlogit'`

log( *x*/ (1 –*x*))`'ismax'`

Sets the score for the class with the largest score to 1, and sets the scores for all other classes to 0 `'logit'`

1/(1 + *e*^{–x})`'none'`

or`'identity'`

*x*(no transformation)`'sign'`

–1 for *x*< 0

0 for*x*= 0

1 for*x*> 0`'symmetric'`

2 *x*– 1`'symmetricismax'`

Sets the score for the class with the largest score to 1, and sets the scores for all other classes to –1 `'symmetriclogit'`

2/(1 + *e*^{–x}) – 1For a MATLAB

^{®}function or a function that you define, enter its function handle.Mdl.ScoreTransform = @

*function*;must accept a matrix (the original scores) and return a matrix of the same size (the transformed scores).`function`

**Data Types: **`char`

| `function_handle`

## Object Functions

### Interpret Prediction

`lime` | Local interpretable model-agnostic explanations (LIME) |

`partialDependence` | Compute partial dependence |

`plotPartialDependence` | Create partial dependence plot (PDP) and individual conditional expectation (ICE) plots |

`shapley` | Shapley values |

### Assess Predictive Performance on New Observations

### Compare Accuracies

`compareHoldout` | Compare accuracies of two classification models using new data |

`testckfold` | Compare accuracies of two classification models by repeated cross-validation |

## Examples

### Reduce Size of Neural Network Classifier

Reduce the size of a full neural network classifier by removing the training data from the model. You can use a compact model to improve memory efficiency.

Load the `patients`

data set. Create a table from the data set. Each row corresponds to one patient, and each column corresponds to a diagnostic variable. Use the `Smoker`

variable as the response variable, and the rest of the variables as predictors.

```
load patients
tbl = table(Diastolic,Systolic,Gender,Height,Weight,Age,Smoker);
```

Train a neural network classifier using the data. Specify the `Smoker`

column of `tbl`

as the response variable. Specify to standardize the numeric predictors.

Mdl = fitcnet(tbl,"Smoker","Standardize",true)

Mdl = ClassificationNeuralNetwork PredictorNames: {'Diastolic' 'Systolic' 'Gender' 'Height' 'Weight' 'Age'} ResponseName: 'Smoker' CategoricalPredictors: 3 ClassNames: [0 1] ScoreTransform: 'none' NumObservations: 100 LayerSizes: 10 Activations: 'relu' OutputLayerActivation: 'softmax' Solver: 'LBFGS' ConvergenceInfo: [1×1 struct] TrainingHistory: [36×7 table] Properties, Methods

`Mdl`

is a full `ClassificationNeuralNetwork`

model object.

Reduce the size of the model by using `compact`

.

compactMdl = compact(Mdl)

compactMdl = CompactClassificationNeuralNetwork LayerSizes: 10 Activations: 'relu' OutputLayerActivation: 'softmax' Properties, Methods

`compactMdl`

is a `CompactClassificationNeuralNetwork`

model object. `compactMdl`

contains fewer properties than the full model `Mdl`

.

Display the amount of memory used by each neural network model.

whos("Mdl","compactMdl")

Name Size Bytes Class Attributes Mdl 1x1 18836 ClassificationNeuralNetwork compactMdl 1x1 6663 classreg.learning.classif.CompactClassificationNeuralNetwork

The full model is larger than the compact model.

## See Also

`fitcnet`

| `predict`

| `loss`

| `margin`

| `edge`

| `ClassificationPartitionedModel`

| `ClassificationNeuralNetwork`

| `compact`

**Introduced in R2021a**

## Apri esempio

Si dispone di una versione modificata di questo esempio. Desideri aprire questo esempio con le tue modifiche?

## Comando MATLAB

Hai fatto clic su un collegamento che corrisponde a questo comando MATLAB:

Esegui il comando inserendolo nella finestra di comando MATLAB. I browser web non supportano i comandi MATLAB.

# Select a Web Site

Choose a web site to get translated content where available and see local events and offers. Based on your location, we recommend that you select: .

You can also select a web site from the following list:

## How to Get Best Site Performance

Select the China site (in Chinese or English) for best site performance. Other MathWorks country sites are not optimized for visits from your location.

### Americas

- América Latina (Español)
- Canada (English)
- United States (English)

### Europe

- Belgium (English)
- Denmark (English)
- Deutschland (Deutsch)
- España (Español)
- Finland (English)
- France (Français)
- Ireland (English)
- Italia (Italiano)
- Luxembourg (English)

- Netherlands (English)
- Norway (English)
- Österreich (Deutsch)
- Portugal (English)
- Sweden (English)
- Switzerland
- United Kingdom (English)