# convolution1dLayer

1-D convolutional layer

## Description

A 1-D convolutional layer applies sliding convolutional filters to 1-D input. The layer convolves the input by moving the filters along the input and computing the dot product of the weights and the input, then adding a bias term.

The dimension that the layer convolves over depends on the layer input:

• For time series and vector sequence input (data with three dimensions corresponding to the channels, observations, and time steps), the layer convolves over the time dimension.

• For 1-D image input (data with three dimensions corresponding to the spatial pixels, channels, and observations), the layer convolves over the spatial dimension.

• For 1-D image sequence input (data with four dimensions corresponding to the spatial pixels, channels, observations, and time steps), the layer convolves over the spatial dimension.

## Creation

### Syntax

``layer = convolution1dLayer(filterSize,numFilters)``
``layer = convolution1dLayer(filterSize,numFilters,Name=Value)``

### Description

example

````layer = convolution1dLayer(filterSize,numFilters)` creates a 1-D convolutional layer and sets the `FilterSize` and `NumFilters` properties.```
````layer = convolution1dLayer(filterSize,numFilters,Name=Value)` also sets the optional `Stride`, `DilationFactor`, `NumChannels`, Parameters and Initialization, Learning Rate and Regularization, and `Name` properties using one or more name-value arguments. To specify input padding, use the `Padding` name-value argument. For example, `convolution1dLayer(11,96,Padding=1)` creates a 1-D convolutional layer with 96 filters of size 11, and specifies padding of size 1 on the left and right of the layer input.```

### Input Arguments

expand all

Name-Value Arguments

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: `convolution1dLayer(11,96,Padding=1)` creates a 1-D convolutional layer with 96 filters of size 11, and specifies padding of size 1 on the left and right of the layer input.

Padding to apply to the input, specified as one of the following:

• `"same"` — Apply padding such that the output size is `ceil(inputSize/stride)`, where `inputSize` is the length of the input. When `Stride` is `1`, the output is the same size as the input.

• `"causal"` — Apply left padding to the input, equal to `(FilterSize - 1) .* DilationFactor`. When `Stride` is `1`, the output is the same size as the input.

• Nonnegative integer `sz` — Add padding of size `sz` to both ends of the input.

• Vector `[l r]` of nonnegative integers — Add padding of size `l` to the left and `r` to the right of the input.

Example: `Padding=[2 1]` adds padding of size 2 to the left and size 1 to the right of the input.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `string`

## Properties

expand all

### Convolution

Width of the filters, specified as a positive integer.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Number of filters, specified as a positive integer. This number corresponds to the number of neurons in the layer that connect to the same region in the input. This parameter determines the number of channels (feature maps) in the layer output.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Step size for traversing the input, specified as a positive integer.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Factor for dilated convolution (also known as atrous convolution), specified as a positive integer.

Use dilated convolutions to increase the receptive field (the area of the input that the layer can see) of the layer without increasing the number of parameters or computation.

The layer expands the filters by inserting zeros between each filter element. The dilation factor determines the step size for sampling the input, or equivalently, the upsampling factor of the filter. It corresponds to an effective filter size of `(FilterSize – 1) .* DilationFactor + 1`. For example, a 1-by-3 filter with a dilation factor of `2` is equivalent to a 1-by-5 filter with zeros between the elements.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Size of padding to apply to each side of the input, specified as a vector ```[l r]``` of two nonnegative integers, where `l` is the padding applied to the left and `r` is the padding applied to the right.

When you create a layer, use the `Padding` name-value argument to specify the padding size.

Data Types: `double`

Method to determine padding size, specified as one of the following:

• `'manual'` – Pad using the integer or vector specified by `Padding`.

• `'same'` – Apply padding such that the output size is `ceil(inputSize/Stride)`, where `inputSize` is the length of the input. When `Stride` is `1`, the output is the same as the input.

• `'causal'` – Apply causal padding. Pad the left of the input with padding size ```(FilterSize - 1) .* DilationFactor```.

To specify the layer padding, use the `Padding` name-value argument.

Data Types: `char`

Value to pad data, specified as one of the following:

`PaddingValue`DescriptionExample
ScalarPad with the specified scalar value.
`$\left[\begin{array}{ccc}3& 1& 4\end{array}\right]\to \left[\begin{array}{ccccccc}0& 0& 3& 1& 4& 0& 0\end{array}\right]$`
`'symmetric-include-edge'`Pad using mirrored values of the input, including the edge values.
`$\left[\begin{array}{ccc}3& 1& 3\end{array}\right]\to \left[\begin{array}{ccccccc}1& 3& 3& 1& 4& 4& 1\end{array}\right]$`
`'symmetric-exclude-edge'`Pad using mirrored values of the input, excluding the edge values.
`$\left[\begin{array}{ccc}3& 1& 4\end{array}\right]\to \left[\begin{array}{ccccccc}4& 1& 3& 1& 4& 1& 3\end{array}\right]$`
`'replicate'`Pad using repeated border elements of the input.
`$\left[\begin{array}{ccc}3& 1& 3\end{array}\right]\to \left[\begin{array}{ccccccc}3& 3& 3& 1& 4& 4& 4\end{array}\right]$`

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `string`

Number of input channels, specified as one of the following:

• `'auto'` — Automatically determine the number of input channels at training time.

• Positive integer — Configure the layer for the specified number of input channels. `NumChannels` and the number of channels in the layer input data must match. For example, if the input is an RGB image, then `NumChannels` must be 3. If the input is the output of a convolutional layer with 16 filters, then `NumChannels` must be 16.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64` | `char` | `string`

### Parameters and Initialization

Function to initialize the weights, specified as one of the following:

• `'glorot'` — Initialize the weights with the Glorot initializer [1] (also known as the Xavier initializer). The Glorot initializer independently samples from a uniform distribution with a mean of zero and a variance of ```2/(numIn + numOut)```, where ```numIn = FilterSize*NumChannels``` and ```numOut = FilterSize*NumFilters```.

• `'he'` – Initialize the weights with the He initializer [2]. The He initializer samples from a normal distribution with a mean of zero and a variance of `2/numIn`, where ```numIn = FilterSize*NumChannels```.

• `'narrow-normal'` — Initialize the weights by independently sampling from a normal distribution with a mean of zero and a standard deviation of 0.01.

• `'zeros'` — Initialize the weights with zeros.

• `'ones'` — Initialize the weights with ones.

• Function handle — Initialize the weights with a custom function. If you specify a function handle, then the function must be of the form `weights = func(sz)`, where `sz` is the size of the weights. For an example, see Specify Custom Weight Initialization Function.

The layer only initializes the weights when the `Weights` property is empty.

Data Types: `char` | `string` | `function_handle`

Function to initialize the bias, specified as one of the following:

• `'zeros'` — Initialize the bias with zeros.

• `'ones'` — Initialize the bias with ones.

• `'narrow-normal'` — Initialize the bias by independently sampling from a normal distribution with a mean of zero and a standard deviation of 0.01.

• Function handle — Initialize the bias with a custom function. If you specify a function handle, then the function must be of the form `bias = func(sz)`, where `sz` is the size of the bias.

The layer only initializes the bias when the `Bias` property is empty.

Data Types: `char` | `string` | `function_handle`

Layer weights for the transposed convolution operation, specified as a `FilterSize`-by-`NumChannels`-by-`numFilters` numeric array or `[]`.

The layer weights are learnable parameters. You can specify the initial value for the weights directly using the `Weights` property of the layer. When you train a network, if the `Weights` property of the layer is nonempty, then `trainNetwork` uses the `Weights` property as the initial value. If the `Weights` property is empty, then `trainNetwork` uses the initializer specified by the `WeightsInitializer` property of the layer.

Data Types: `single` | `double`

Layer biases for the transposed convolutional operation, specified as a 1-by-`NumFilters` numeric array or `[]`.

The layer biases are learnable parameters. When you train a network, if `Bias` is nonempty, then `trainNetwork` uses the `Bias` property as the initial value. If `Bias` is empty, then `trainNetwork` uses the initializer specified by `BiasInitializer`.

Data Types: `single` | `double`

### Learning Rate and Regularization

Learning rate factor for the weights, specified as a nonnegative scalar.

The software multiplies this factor by the global learning rate to determine the learning rate for the weights in this layer. For example, if `WeightLearnRateFactor` is `2`, then the learning rate for the weights in this layer is twice the current global learning rate. The software determines the global learning rate based on the settings you specify using the `trainingOptions` function.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

Learning rate factor for the biases, specified as a nonnegative scalar.

The software multiplies this factor by the global learning rate to determine the learning rate for the biases in this layer. For example, if `BiasLearnRateFactor` is `2`, then the learning rate for the biases in the layer is twice the current global learning rate. The software determines the global learning rate based on the settings you specify using the `trainingOptions` function.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

L2 regularization factor for the weights, specified as a nonnegative scalar.

The software multiplies this factor by the global L2 regularization factor to determine the L2 regularization for the weights in this layer. For example, if `WeightL2Factor` is `2`, then the L2 regularization for the weights in this layer is twice the global L2 regularization factor. You can specify the global L2 regularization factor using the `trainingOptions` function.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

L2 regularization factor for the biases, specified as a nonnegative scalar.

The software multiplies this factor by the global L2 regularization factor to determine the L2 regularization for the biases in this layer. For example, if `BiasL2Factor` is `2`, then the L2 regularization for the biases in this layer is twice the global L2 regularization factor. The software determines the global L2 regularization factor based on the settings you specify using the `trainingOptions` function.

Data Types: `single` | `double` | `int8` | `int16` | `int32` | `int64` | `uint8` | `uint16` | `uint32` | `uint64`

### Layer

Layer name, specified as a character vector or a string scalar. For `Layer` array input, the `trainNetwork`, `assembleNetwork`, `layerGraph`, and `dlnetwork` functions automatically assign names to layers with the name `''`.

Data Types: `char` | `string`

Number of inputs of the layer. This layer accepts a single input only.

Data Types: `double`

Input names of the layer. This layer accepts a single input only.

Data Types: `cell`

Number of outputs of the layer. This layer has a single output only.

Data Types: `double`

Output names of the layer. This layer has a single output only.

Data Types: `cell`

## Examples

collapse all

Create a 1-D convolutional layer with 96 filters of width of 11.

`layer = convolution1dLayer(11,96)`
```layer = Convolution1DLayer with properties: Name: '' Hyperparameters FilterSize: 11 NumChannels: 'auto' NumFilters: 96 Stride: 1 DilationFactor: 1 PaddingMode: 'manual' PaddingSize: [0 0] PaddingValue: 0 Learnable Parameters Weights: [] Bias: [] Show all properties ```

Include a 1-D convolutional layer in a `Layer` array.

```layers = [ sequenceInputLayer(3,MinLength=12) convolution1dLayer(11,96) reluLayer globalMaxPooling1dLayer fullyConnectedLayer(10) softmaxLayer classificationLayer]```
```layers = 7x1 Layer array with layers: 1 '' Sequence Input Sequence input with 3 dimensions 2 '' 1-D Convolution 96 11 convolutions with stride 1 and padding [0 0] 3 '' ReLU ReLU 4 '' 1-D Global Max Pooling 1-D global max pooling 5 '' Fully Connected 10 fully connected layer 6 '' Softmax softmax 7 '' Classification Output crossentropyex ```

expand all

## References

[1] Glorot, Xavier, and Yoshua Bengio. "Understanding the Difficulty of Training Deep Feedforward Neural Networks." In Proceedings of the Thirteenth International Conference on Artificial Intelligence and Statistics, 249–356. Sardinia, Italy: AISTATS, 2010.

[2] He, Kaiming, Xiangyu Zhang, Shaoqing Ren, and Jian Sun. "Delving Deep into Rectifiers: Surpassing Human-Level Performance on ImageNet Classification." In Proceedings of the 2015 IEEE International Conference on Computer Vision, 1026–1034. Washington, DC: IEEE Computer Vision Society, 2015.

## Version History

Introduced in R2021b