compressNetworkUsingProjection

Compress neural network using projection

Since R2022b

collapse all in page

Syntax

netProjected = compressNetworkUsingProjection(net,mbq)

netProjected = compressNetworkUsingProjection(net,X1,...,XN)

netProjected = compressNetworkUsingProjection(net,npca)

[netProjected, info] = compressNetworkUsingProjection(___)

[netProjected, info] = compressNetworkUsingProjection(___,Name=Value)

Description

Add-On Required: This feature requires the Deep Learning Toolbox Model Compression Library add-on.

The compressNetworkUsingProjection function reduces the number of learnable parameters of layers by performing principal component analysis (PCA) of the neuron activations using a data set representative of the training data and then projects the learnable parameters into the subspace that maintains the highest variance in neuron activations. In some cases, this operation is equivalent to replacing layers with networks containing two or more layers with fewer learnable parameters.

Depending on the network, projection configuration, and code generation libraries used (including library-free code generation), forward passes of a projected deep neural network can be faster when you deploy the network to embedded hardware.

If you prune or quantize your network, then use compression using projection after pruning and before quantization.

netProjected = compressNetworkUsingProjection(net,mbq) compresses the dlnetwork object net by replacing layers with projected layers. The function compresses layers by performing principal component analysis (PCA) of the neuron activations using the data in the minibatchqueue object mbq and projects learnable parameters into the subspace that maintains the highest variance in neuron activations.

example

netProjected = compressNetworkUsingProjection(net,X1,...,XN) compresses the network using the data in X1,...,XN, where N is the number of network inputs.

netProjected = compressNetworkUsingProjection(net,npca) compresses the network using the neuronPCA object npca. The PCA step can be computationally intensive. If you expect to compress the same network multiple times (for example, when exploring different levels of compression), then you can perform the PCA step up front using a neuronPCA object.

[netProjected, info] = compressNetworkUsingProjection(___) also returns the structure info that contains information about the projected layers, the reduction of learnable parameters, and the explained variance achieved during compression.

[netProjected, info] = compressNetworkUsingProjection(___,Name=Value) specifies additional options using one or more name-value arguments.

Examples

collapse all

Compress Network Using Projection

This example uses:

Open Live Script

Load the pretrained network in dlnetJapaneseVowels and the training data in JapaneseVowelsTrainData.

load dlnetJapaneseVowels
load JapaneseVowelsTrainData

Compress the network. Specify the mini-batch size for the principal component analysis as 16. Specify the input data format as "CTB".

[netProjected,info] = compressNetworkUsingProjection(net,XTrain,MiniBatchSize=16,InputDataFormats="CTB");

Compressed network has 85.4% fewer learnable parameters.
Projection compressed 2 layers: "lstm","fc"

View the network layers.

netProjected.Layers

ans = 
  4×1 Layer array with layers:

     1   'sequenceinput'   Sequence Input    Sequence input with 12 channels
     2   'lstm'            Projected Layer   Projected LSTM with 100 hidden units
     3   'fc'              Projected Layer   Projected fully connected layer with output size 9
     4   'softmax'         Softmax           Softmax

View the projected LSTM layer.

netProjected.Layers(2)

ans = 
  ProjectedLayer with properties:

                   Name: 'lstm'
          OriginalClass: 'nnet.cnn.layer.LSTMLayer'
    LearnablesReduction: 0.8610
              InputSize: 12
             OutputSize: 100

   Hyperparameters
     InputProjectorSize: 7
    OutputProjectorSize: 6

   Learnable Parameters
                Network: [1×1 dlnetwork]

   State Parameters
                Network: [1×1 dlnetwork]

   Network Learnable Parameters
     Network/lstm/InputWeights      400×7 dlarray
     Network/lstm/RecurrentWeights  400×6 dlarray
     Network/lstm/Bias              400×1 dlarray
     Network/lstm/InputProjector    12×7  dlarray
     Network/lstm/OutputProjector   100×6 dlarray

   Network State Parameters
     Network/lstm/HiddenState  100×1 dlarray
     Network/lstm/CellState    100×1 dlarray

  Show all properties

Input Arguments

collapse all

`net` — Neural network
initialized `dlnetwork` object

Neural network, specified as an initialized dlnetwork object.

`mbq` — Mini-batch queue
`minibatchqueue` object

Mini-batch queue that outputs data for each input of the network, specified as a minibatchqueue object.

The PCA step typically works best when using the full training set. However, any dataset that is representative of the training data distribution suffices. The input data must contain two or more observations and sequences must contain two or more time steps.

Note

Padding sequences is not recommended as this can negatively impact the analysis. Instead, truncate mini-batches of data to have the same length or use mini-batches of size 1.

`X1,...,XN` — Input data
formatted `dlarray` | unformatted `dlarray` (since R2026a) | numeric array (since R2026a) | categorical array (since R2026a) | datastore (since R2026a) | cell array of numeric arrays (since R2026a) | table (since R2026a)

Input data, specified as a formatted or unformatted dlarray object, numeric array, categorical array, datastore, cell array of numeric arrays, or table.

Since R2026a, the compressNetworkUsingProjection function supports the same input data types as the trainnet function. You can reuse the training data, or a subset of the training data, for compression.

For more information about dlarray formats, see the fmt input argument of dlarray.

Note

Padding sequences is not recommended as this can negatively impact the analysis. Instead, truncate mini-batches of data to have the same length or use mini-batches of size 1.

`npca` — Neuron principal component analysis
`neuronPCA` object

Neuron principal component analysis, specified as a neuronPCA object.

Name-Value Arguments

expand all

Specify optional pairs of arguments as Name1=Value1,...,NameN=ValueN, where Name is the argument name and Value is the corresponding value. Name-value arguments must appear after other arguments, but the order of the pairs does not matter.

Example: netProjected = compressNetworkUsingProjection(net,mbq,VerbosityLevel="off") compresses the network using projection and disables the command line display.

Compression

expand all

`LayerNames` — Names of layers to compress
string array | cell array of character vectors | character vector

Names of layers to compress, specified as a string array, cell array of character vectors, or a character vector containing a single layer name.

The software, by default, compresses all the layers in the network that support projection.

In rare cases, layers can increase in size due to projection. For example, this can happen when:

A layer is small.
The ExplainedVarianceGoal argument is too large.
The layer does not contain much redundant information.

If you do not specify the LayerNames name-value argument, then the software does not project layers that would increase in size. To ensure that a supported layer is projected, specify the name of that layer using the LayerNames name-value argument.

The compressNetworkUsingProjection and neuronPCA functions support these layers:

Note

Layers that share learnable parameters with other layers through weight tying do not support compression using projection.

Since R2026a, compressNetworkUsingProjection and neuronPCA support compressing layers contained inside a networkLayer object.

If you specify LayerNames to be the name of a network layer, then the software compresses every supported layer inside the network layer.

To compress a specific nested layer inside a network layer, specify the name of the network layer and the name of the nested layer separated by a forward slash "/". For example, the path to a layer named "nestedLayerName" in a network layer named "networkLayerName" is "networkLayerName/nestedLayerName". If there are multiple levels of nested layers, then specify the path using the form "networkLayerName1/.../networkLayerNameN/nestedLayerName".

Data Types: string | cell

`ExplainedVarianceGoal` — Target proportion of neuron activation variance explained by principal components
`0.95` (default) | nonnegative scalar less than or equal to 1

Target proportion of neuron activation variance explained by the remaining principal components of each projected layer, specified as a value between 0 (maximum compression) and 1 (project layers with minimal compression).

If you specify the ExplainedVarianceGoal option, then you must not specify the LearnablesReductionGoal option.

`LearnablesReductionGoal` — Target proportion of total number of network learnables to remove
nonnegative scalar less than or equal to 1

Target proportion of total number of network learnables to remove, specified as a nonnegative scalar less than or equal to 1.

If you specify the LearnablesReductionGoal option, then you must not specify the ExplainedVarianceGoal option. If you do not specify the LearnablesReductionGoal option, then the function compresses the network using the ExplainedVarianceGoal option.

If LearnablesReductionGoal is greater than the maximum possible reduction in learnables, then the function removes the maximum possible proportion of learnables. Use the neuronPCA function to determine the possible range of reduction in learnables.

If LearnablesReductionGoal is smaller than the maximum possible reduction in learnables, then the function removes at least the proportion of learnables specified by LearnablesReductionGoal. If removing a greater proportion of learnables does not reduce the explained variance, then the function automatically removes a higher proportion of learnables. For example, if you specify a learnables reduction goal of 0.2, and if the explained variance is the same for learnables reductions between 0.2 and 0.5, then the function removes 50% of learnables.

`VerbosityLevel` — Verbosity level
`"summary"` (default) | `"steps"` | `"iterations"` | `"off"`

Verbosity level, specified as one of these values:

"summary" — Display a summary of the compression algorithm.
"steps" — Display information about the steps of the compression algorithm.
"iterations" — Display information about the iterations of the compression algorithm.
"off" — Do not display information.

`UnpackProjectedLayers` — Flag to unpack projected layers
`0` (`false`) (default) | `1` (`true`)

Since R2023b

Flag to unpack projected layers, specified as one of these values:

0 (false) — Do not unpack projected layers. The function replaces projectable layers with ProjectedLayer objects.
1 (true) — Unpack projected layers. The function replaces projectable layers with the network that is equivalent to the projection.

Principal Component Analysis

expand all

`MiniBatchSize` — Size of mini-batches
`"auto"` (default) | positive integer

Since R2026a

Size of mini-batches to use for principal component analysis, specified as a positive integer. Larger mini-batch sizes require more memory, but can lead to faster analysis.

If you specify the input data as a mini-batch queue and MiniBatchSize is set to "auto", then the software uses the MiniBatchSize property of the mini-batch queue.

If you do not specify the input data as a mini-batch queue and MiniBatchSize is set to "auto", then the software uses mini-batch size 128.

If you specify MiniBatchSize as an integer, then the software uses the specified value as the mini-batch size, even if the input data is specified as a mini-batch queue with a different mini-batch size.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

`ExecutionEnvironment` — Hardware resource
`"auto"` (default) | `"gpu"` | `"cpu"`

Since R2026a

Hardware resource to use for principal component analysis, specified as one of these values:

"auto" — Use a GPU if one is available. Otherwise, use the CPU. If net is a quantized network with the TargetLibrary property set to "none", use the CPU even if a GPU is available.
"gpu" — Use the GPU. Using a GPU requires a Parallel Computing Toolbox™ license and a supported GPU device. For information about supported devices, see GPU Computing Requirements (Parallel Computing Toolbox). If Parallel Computing Toolbox or a suitable GPU is not available, then the software returns an error.
"cpu" — Use the CPU.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

`SequenceLength` — Option to pad or truncate sequences
`"longest"` (default) | `"shortest"` | positive integer

Since R2026a

Option to pad or truncate input sequences to use for principal component analysis, specified as one of these values:

"longest" — Pad sequences in each mini-batch to have the same length as the longest sequence. This option does not discard any data, though padding can introduce noise to the neural network.
"shortest" — Truncate sequences in each mini-batch to have the same length as the shortest sequence. This option ensures that no padding is added, at the cost of discarding data.

To learn more about the effect of padding and truncating sequences, see Sequence Padding and Truncation.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

`SequencePaddingDirection` — Direction of padding or truncation
`"right"` (default) | `"left"`

Since R2026a

Direction of padding or truncation to use for principal component analysis, specified as one of these options:

"right" — Pad or truncate sequences on the right. The sequences start at the same time step and the software truncates or adds padding to the end of each sequence.
"left" — Pad or truncate sequences on the left. The software truncates or adds padding to the start of each sequence so that the sequences end at the same time step.

Recurrent layers process sequence data one time step at a time, so when the recurrent layer OutputMode property is "last", any padding in the final time steps can negatively influence the layer output. To pad or truncate sequence data on the left, set the SequencePaddingDirection name-value argument to "left".

For sequence-to-sequence neural networks (when the OutputMode property is "sequence" for each recurrent layer), any padding in the first time steps can negatively influence the predictions for the earlier time steps. To pad or truncate sequence data on the right, set the SequencePaddingDirection name-value argument to "right".

To learn more about the effects of padding and truncating sequences, see Sequence Padding and Truncation.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

`SequencePaddingValue` — Value for padding input sequences
`0` (default) | scalar

Since R2026a

Value for padding the input sequences to use for principal component analysis, specified as a scalar.

Do not pad sequences with NaN, because doing so can propagate errors through the neural network.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

`InputDataFormats` — Description of input data dimensions
`"auto"` (default) | string array | cell array of character vectors | character vector

Since R2026a

Description of the input data dimensions to use for principal component analysis, specified as a string array, character vector, or cell array of character vectors.

If InputDataFormats is "auto", then the software uses the formats expected by the network input. Otherwise, the software uses the specified formats for the corresponding network input.

A data format is a string of characters, where each character describes the type of the corresponding data dimension.

The characters are:

"S" — Spatial
"C" — Channel
"B" — Batch
"T" — Time
"U" — Unspecified

For example, consider an array that represents a batch of sequences where the first, second, and third dimensions correspond to channels, observations, and time steps, respectively. You can describe the data as having the format "CBT" (channel, batch, time).

You can specify multiple dimensions labeled "S" or "U". You can use the labels "C", "B", and "T" once each, at most. The software ignores singleton trailing "U" dimensions after the second dimension.

For a neural network with multiple inputs net, specify an array of input data formats, where InputDataFormats(i) corresponds to the input net.InputNames(i).

For more information, see Deep Learning Data Formats.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

Data Types: char | string | cell

`CategoricalInputEncoding` — Encoding of categorical inputs
`"integer"` (default) | `"one-hot"`

Since R2026a

Encoding of categorical inputs to use for principal component analysis, specified as one of these values:

"integer" — Convert categorical inputs to their integer value. In this case, the network must have one input channel for each of the categorical inputs.
"one-hot" — Convert categorical inputs to one-hot encoded vectors. In this case, the network must have numCategories channels for each of the categorical inputs, where numCategories is the number of categories of the corresponding categorical input.

Note

If you specify the input data as a neuronPCA object, then this argument has no effect.

Output Arguments

collapse all

`netProjected` — Projected network
`dlnetwork` object

Projected network, returned as a dlnetwork object.

After you compress the network using projection, you can fine-tune the network to help regain predictive accuracy lost by the compression process. For an example, see Compress Neural Network Using Projection.

`info` — Projection information
structure

Projection information, returned as a structure with these fields:

LearnablesReduction — Proportion of total number of network learnables removed
ExplainedVariance — Proportion of neuron activation variance explained by principal components
LayerNames (since R2023b) — Names of projected layers

Tips

Code generation does not support ProjectedLayer objects. To replace ProjectedLayer objects in a neural network with the equivalent neural network that represents the projection, use the unpackProjectedLayers function or set the UnpackProjectedLayers option of the compressNetworkUsingProjection function to 1 (true).
To determine the maximum possible compression, open your network in Deep Network Designer, then click Analyze for Compression.

Algorithms

collapse all

Projected Layer

To compress a deep learning network, you can use projected layers. A projected layer is a type of deep learning layer that enables compression by reducing the number of stored learnable parameters. The layer introduces learnable projector matrices Q, replaces multiplications of the form $W x$ , where W is a learnable matrix, with the multiplication $W Q Q^{⊤} x$ , and stores Q and $W' = W Q$ instead of storing W. Projecting x into a lower dimensional space using Q typically requires less memory to store the learnable parameters and can have similarly strong prediction accuracy.

For some types of layers, you can represent a projected layer as a neural network containing two or more layers with fewer learnable parameters. For example, you can represent a projected convolution layer as three convolution layers that perform the input projection, convolution, and the output projection operations independently. When you compress a network using the compressNetworkUsingProjection function, the software replaces layers that support projection with ProjectedLayer objects that contain the equivalent neural network. To replace ProjectedLayer objects in a neural network with the equivalent neural network that represents the projection, use the unpackProjectedLayers function or set the UnpackProjectedLayers option of the compressNetworkUsingProjection function to 1 (true).

In rare cases, layers can increase in size due to projection. For example, this can happen when:

A layer is small. Adding projector matrices increases the number of learnable parameters. Usually, the decrease in number of learnable parameters of the original layer is large enough that the total number of learnable parameters decreases. However, when the original layer is already small, then the decrease in learnable parameters may not be sufficient and the overall number of learnable parameters can increase.
The ExplainedVarianceGoal argument is too large, or if the layer does not contain much redundant information. In this case, the projector matrices are added, but not truncated enough to decrease the total number of learnable parameters.

The compressNetworkUsingProjection and neuronPCA functions support these layers:

Note

Layers that share learnable parameters with other layers through weight tying do not support compression using projection.

Since R2026a, compressNetworkUsingProjection and neuronPCA support compressing layers contained inside a networkLayer object.

The compressNetworkUsingProjection function replaces projectable layers with ProjectedLayer objects. A ProjectedLayer object contains information about the projection operation and contains the neural network that represents the projection.

The neural network that represents the projection depends on the type of layer:

Original Layer	Network
`convolution1dLayer` (since R2024b)	Network containing two or three `convolution1dLayer` objects
`convolution2dLayer`	Network containing two or three `convolution2dLayer` objects
`fullyConnectedLayer`	Network containing two `fullyConnectedLayer` objects
`lstmLayer`	Network containing a single `lstmProjectedLayer` object
`gruLayer`	Network containing a single `gruProjectedLayer` object

References

[1] "Compressing Neural Networks Using Network Projection." Accessed July 20, 2023. https://www.mathworks.com/company/technical-articles/compressing-neural-networks-using-network-projection.html.

Extended Capabilities

expand all

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

The compressNetworkUsingProjection function supports GPU array input with these usage notes and limitations:

This function runs on the GPU if any of these conditions are met:
- Any of the values of the network learnable parameters inside net.Learnables.Value are dlarray objects with underlying data of type gpuArray
- The input argument mbq outputs dlarray objects with underlying data of type gpuArray
- The input arguments X1,...,XN are dlarray objects with underlying data of type gpuArray

For more information, see Run MATLAB Functions on a GPU (Parallel Computing Toolbox).

Version History

Introduced in R2022b

expand all

R2026a: `compressNetworkUsingProjection` supports projecting network layers

The compressNetworkUsingProjection function now supports projecting layers contained inside of networkLayer objects.

The software replaces each projectable layer inside a network layer with a ProjectedLayer object.

R2026a: No negative learnables reduction by default

In rare cases, projection can increase the number of learnable parameters in a layer. By default, the compressNetworkUsingProjection function no longer projects layers that would increase in size due to projection. To ensure that a supported layer is projected, specify the name of that layer using the LayerNames name-value argument.

R2026a: Projection API supports additional input data types

The neuronPCA and compressNetworkUsingProjection functions now support the same input data types as the trainnet function.

Before R2026a, the input data could be a minibatchqueue object or one or multiple formatted dlarray objects.

Since R2026a, the input data can also be specified as one of these options.

One or multiple unformatted dlarray objects
One or multiple numeric arrays
One or multiple categorical arrays
Datastore
Cell array of numeric arrays
Table

Additionally, both neuronPCA and compressNetworkUsingProjection now support these name-value arguments:

MiniBatchSize — Mini-batch size.
ExecutionEnvironment — Hardware resource for compressing the neural network.
SequenceLength — Option to pad or truncate input sequences.
SequencePaddingDirection — Direction of padding or truncation.
SequencePaddingValue — Value for padding the input sequences.
InputDataFormats — Description of the input data dimensions.
CategoricalInputEncoding — Encoding of categorical inputs.

R2024b: `compressNetworkUsingProjection` supports projecting 1-D convolution layers

The compressNetworkUsingProjection function now supports projecting convolution1dLayer objects.

R2023b: `compressNetworkUsingProjection` supports projecting convolution, fully connected, and GRU layers

The compressNetworkUsingProjection function now supports projecting these layers:

R2023b: Projection information output contains projected layer names

The output info structure now has the field LayerNames that contains the names of the projected layers.

R2023b: `compressNetworkUsingProjection` replaces LSTM layers with `ProjectedLayer` objects

Starting in R2023b, the compressNetworkUsingProjection function replaces LSTM layers with ProjectedLayer objects with a network that contains a single lstmProjectedLayer object. In previous versions, the function replaces LSTM layers with lstmProjectedLayer objects directly.

To reproduce the previous behavior, replace the ProjectedLayer objects with their networks using the unpackProjectedLayers function or set the UnpackProjectedLayers option of the compressNetworkUsingProjection function to 1 (true).

compressNetworkUsingProjection

Syntax

Description

Examples

Compress Network Using Projection

Input Arguments

net — Neural network initialized dlnetwork object

mbq — Mini-batch queue minibatchqueue object

X1,...,XN — Input data formatted dlarray | unformatted dlarray (since R2026a) | numeric array (since R2026a) | categorical array (since R2026a) | datastore (since R2026a) | cell array of numeric arrays (since R2026a) | table (since R2026a)

npca — Neuron principal component analysis neuronPCA object

Name-Value Arguments

Compression

LayerNames — Names of layers to compress string array | cell array of character vectors | character vector

ExplainedVarianceGoal — Target proportion of neuron activation variance explained by principal components 0.95 (default) | nonnegative scalar less than or equal to 1

LearnablesReductionGoal — Target proportion of total number of network learnables to remove nonnegative scalar less than or equal to 1

VerbosityLevel — Verbosity level "summary" (default) | "steps" | "iterations" | "off"

UnpackProjectedLayers — Flag to unpack projected layers 0 (false) (default) | 1 (true)

Principal Component Analysis

MiniBatchSize — Size of mini-batches "auto" (default) | positive integer

ExecutionEnvironment — Hardware resource "auto" (default) | "gpu" | "cpu"

SequenceLength — Option to pad or truncate sequences "longest" (default) | "shortest" | positive integer

SequencePaddingDirection — Direction of padding or truncation "right" (default) | "left"

SequencePaddingValue — Value for padding input sequences 0 (default) | scalar

InputDataFormats — Description of input data dimensions "auto" (default) | string array | cell array of character vectors | character vector

CategoricalInputEncoding — Encoding of categorical inputs "integer" (default) | "one-hot"

Output Arguments

netProjected — Projected network dlnetwork object

info — Projection information structure

Tips

Algorithms

Projected Layer

References

Extended Capabilities

GPU Arrays Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

Version History

R2026a: compressNetworkUsingProjection supports projecting network layers

R2026a: No negative learnables reduction by default

R2026a: Projection API supports additional input data types

R2024b: compressNetworkUsingProjection supports projecting 1-D convolution layers

R2023b: compressNetworkUsingProjection supports projecting convolution, fully connected, and GRU layers

R2023b: Projection information output contains projected layer names

R2023b: compressNetworkUsingProjection replaces LSTM layers with ProjectedLayer objects

See Also

Topics

`net` — Neural network
initialized `dlnetwork` object

`mbq` — Mini-batch queue
`minibatchqueue` object

`X1,...,XN` — Input data
formatted `dlarray` | unformatted `dlarray` (since R2026a) | numeric array (since R2026a) | categorical array (since R2026a) | datastore (since R2026a) | cell array of numeric arrays (since R2026a) | table (since R2026a)

`npca` — Neuron principal component analysis
`neuronPCA` object

`LayerNames` — Names of layers to compress
string array | cell array of character vectors | character vector

`ExplainedVarianceGoal` — Target proportion of neuron activation variance explained by principal components
`0.95` (default) | nonnegative scalar less than or equal to 1

`LearnablesReductionGoal` — Target proportion of total number of network learnables to remove
nonnegative scalar less than or equal to 1

`VerbosityLevel` — Verbosity level
`"summary"` (default) | `"steps"` | `"iterations"` | `"off"`

`UnpackProjectedLayers` — Flag to unpack projected layers
`0` (`false`) (default) | `1` (`true`)

`MiniBatchSize` — Size of mini-batches
`"auto"` (default) | positive integer

`ExecutionEnvironment` — Hardware resource
`"auto"` (default) | `"gpu"` | `"cpu"`

`SequenceLength` — Option to pad or truncate sequences
`"longest"` (default) | `"shortest"` | positive integer

`SequencePaddingDirection` — Direction of padding or truncation
`"right"` (default) | `"left"`

`SequencePaddingValue` — Value for padding input sequences
`0` (default) | scalar

`InputDataFormats` — Description of input data dimensions
`"auto"` (default) | string array | cell array of character vectors | character vector

`CategoricalInputEncoding` — Encoding of categorical inputs
`"integer"` (default) | `"one-hot"`

`netProjected` — Projected network
`dlnetwork` object

`info` — Projection information
structure

GPU Arrays
Accelerate code by running on a graphics processing unit (GPU) using Parallel Computing Toolbox™.

R2026a: `compressNetworkUsingProjection` supports projecting network layers

R2024b: `compressNetworkUsingProjection` supports projecting 1-D convolution layers

R2023b: `compressNetworkUsingProjection` supports projecting convolution, fully connected, and GRU layers

R2023b: `compressNetworkUsingProjection` replaces LSTM layers with `ProjectedLayer` objects