Wolfram Language & System Documentation Center

ConvolutionLayer

See Also
- DeconvolutionLayer
- PoolingLayer
- BatchNormalizationLayer
- NetChain
- NetGraph
- NetInitialize
- NetTrain
- NetExtract
- Ramp
- NetEncoder
- Net Encoders
- Image
- Image3D
- Audio
Related Guides
Tech Notes
- Neural Networks in the Wolfram Language
- See Also
  - DeconvolutionLayer
  - PoolingLayer
  - BatchNormalizationLayer
  - NetChain
  - NetGraph
  - NetInitialize
  - NetTrain
  - NetExtract
  - Ramp
  - NetEncoder
  - Net Encoders
  - Image
  - Image3D
  - Audio
- Related Guides
- Tech Notes
  - Neural Networks in the Wolfram Language

represents a trainable convolutional net layer having n output channels and using kernels of size s to compute the convolution.

ConvolutionLayer[n,{s}]

represents a layer performing one-dimensional convolutions with kernels of size s.

ConvolutionLayer[n,{h,w}]

represents a layer performing two-dimensional convolutions with kernels of size h×w.

ConvolutionLayer[n,{h,w,d}]

represents a three-dimensional convolutions with kernels of size h×w×d.

ConvolutionLayer[n,kernel,opts]

includes options for padding and other parameters.

ConvolutionLayer

ConvolutionLayer[n,s]

represents a trainable convolutional net layer having n output channels and using kernels of size s to compute the convolution.

ConvolutionLayer[n,{s}]

represents a layer performing one-dimensional convolutions with kernels of size s.

ConvolutionLayer[n,{h,w}]

represents a layer performing two-dimensional convolutions with kernels of size h×w.

ConvolutionLayer[n,{h,w,d}]

represents a three-dimensional convolutions with kernels of size h×w×d.

ConvolutionLayer[n,kernel,opts]

includes options for padding and other parameters.

Details and Options

ConvolutionLayer is a type of network layer that applies a convolution operation to the input.
ConvolutionLayer is typically used to recognize image patterns but also for spatial data analysis, computer vision, natural language processing and more.
A layer with n output channels applied to an input array with m input channels and one or more spatial dimensions effectively performs n×m distinct convolutions across the spatial dimensions to produce an output array with n channels.
ConvolutionLayer[…][input] explicitly computes the output from applying the layer to input.
ConvolutionLayer[…][{input₁,input₂,…}] explicitly computes outputs for each of the input_i.
In ConvolutionLayer[n,s], the dimensionality of the convolution layer will be inferred when the layer is connected in a NetChain, NetGraph, etc.
The following optional parameters can be included:

"Biases"	Automatic	initial vector of kernel biases
"ChannelGroups"	1	number of channel groups
"Dilation"	1	dilation factor
"Dimensionality"	Automatic	number of spatial dimensions of the convolution
Interleaving	False	the position of the channel dimension
LearningRateMultipliers	Automatic	learning rate multipliers for kernel weights and/or biases
PaddingSize	0	amount of zero padding to apply to the input
"Stride"	1	convolution step size to use
"Weights"	Automatic	initial array of kernel weights

The setting for PaddingSize can be of the following forms:

	n	pad every dimension with n zeros on the beginning and end
	{n₁,n₂,…}	pad the i dimension with n zeros on the beginning and end
	{{n₁,m₁},{n₂,m₂},…}	pad the i dimension with n_i zeros at the beginning and m_i zeros at the end
	"Same"	pad every dimension so that the output size is equal to the input size divided by the stride (rounded up)

The settings for "Dilation" and "Stride" can be of the following forms:
n use the value n for all dimensions

{…,n_i,…} use the value n_i for the i dimension
By setting "ChannelGroups"g, the m input channels and n output channels are split into g groups of m/g and n/g channels, respectively, where m and n are required to be divisible by g. Separate convolutions are performed connecting the i group of input channels with the i group of output channels, and results are concatenated in the output. Each input/output group pair is connected by n/g×m/g convolutions, so setting "ChannelGroups"g effectively reduces the number of distinct convolutions from n×m to n×m/g.
The setting "Biases"None specifies that no biases should be used.
With the setting InterleavingFalse, the channel dimension is taken to be the first dimension of the input and output arrays.
With the setting InterleavingTrue, the channel dimension is taken to be the last dimension of the input and output arrays.
If weights and biases have been added, ConvolutionLayer[…][input] explicitly computes the output from applying the layer.
ConvolutionLayer[…][{input₁,input₂,…}] explicitly computes outputs for each of the input_i.
NetExtract can be used to extract weights and biases from a ConvolutionLayer object.
ConvolutionLayer is typically used inside NetChain, NetGraph, etc.
ConvolutionLayer exposes the following ports for use in NetGraph etc.:
"Input" an array of rank 2, 3 or 4

"Output" an array of rank 2, 3 or 4
ConvolutionLayer can operate on arrays that contain "Varying" dimensions.
When it cannot be inferred from other layers in a larger net, the option "Input"{d₁,…,d_n} can be used to fix the input dimensions of ConvolutionLayer.
Given an input array of dimensions d₁×…×d_i×…, the output array will be of dimensions ×…××…, where the channel dimension =n and the sizes d_i are transformed according to , where / are the padding sizes at the beginning/end of the axis, is the kernel size, is the stride size, and is the dilation factor for each dimension.
Options[ConvolutionLayer] gives the list of default options to construct the layer. Options[ConvolutionLayer[…]] gives the list of default options to evaluate the layer on some data.
Information[ConvolutionLayer[…]] gives a report about the layer.
Information[ConvolutionLayer[…],prop] gives the value of the property prop of ConvolutionLayer[…]. Possible properties are the same as for NetGraph.

Examples

open all close all

Basic Examples (2)

Create a one-dimensional ConvolutionLayer with two output channels and a kernel size of 4:

Wolfram Language code: ConvolutionLayer[2, {4}]

Create an initialized three-dimensional ConvolutionLayer:

Wolfram Language code: conv = NetInitialize@ConvolutionLayer[1, {2, 3, 4}, "Input" -> {1, 10, 10, 10}]

Apply the layer to an input matrix:

Wolfram Language code: conv[RandomReal[1, {1, 10, 10, 10}]]//Short

Scope (13)

Arguments (3)

Create a ConvolutionLayer with three output channels and a 2×2 kernel size:

Wolfram Language code: ConvolutionLayer[3, {2, 2}]

Create a ConvolutionLayer with three output channels and a 2×2×2 kernel size:

Wolfram Language code: ConvolutionLayer[3, {2, 2, 2}]

Create a ConvolutionLayer with five output channels, seven input channels and a 2×2 kernel size:

Wolfram Language code: ConvolutionLayer[5, 2, "Input" -> {7, Automatic, Automatic}]

Initialize the layer:

Wolfram Language code: conv = NetInitialize@ConvolutionLayer[5, 2, "Input" -> {7, Automatic, Automatic}]

Apply the layer to an input of 3×3 input size:

Wolfram Language code: conv[RandomReal[1, {7, 3, 3}]]//Dimensions

Apply the layer to an input of 6×6 input size:

Wolfram Language code: conv[RandomReal[1, {7, 6, 6}]]//Dimensions

Ports (3)

Create an initialized two-dimensional ConvolutionLayer:

Wolfram Language code: conv = NetInitialize@ConvolutionLayer[1, 2, "Input" -> {1, 4, 4}]

Apply the layer to an input array:

Wolfram Language code: conv[RandomInteger[1, {1, 4, 4}]]

The output is also a rank-3 array:

Wolfram Language code: Dimensions[%]

Create an initialized three-dimensional ConvolutionLayer with kernel size 2:

Wolfram Language code: conv = NetInitialize@ConvolutionLayer[1, 2, "Input" -> {1, 3, 3}]

Apply the layer to an input array:

Wolfram Language code: conv[{{{1, 1, 0}, {0, 0, 1}, {1, 1, 0}}}]

Create an initialized two-dimensional ConvolutionLayer that takes an RGB image and returns an RGB image:

Wolfram Language code:

conv = NetInitialize@ConvolutionLayer[3, 10, "Dilation" -> 3, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

ConvolutionLayer automatically threads over batches of inputs:

Wolfram Language code: conv[{[image], [image]}]

Parameters (7)

"Biases" (3)

Create a two-dimensional ConvolutionLayer without biases:

Wolfram Language code: conv = ConvolutionLayer[2, {4, 4}, "Biases" -> None, "Input" -> {1, 40, 40}]

Create a one-dimensional ConvolutionLayer with an identity kernel that applies a bias to the only channel:

Wolfram Language code: conv = ConvolutionLayer["Weights" -> {{{1}}}, "Biases" -> {0.5}]

Apply the layer to an input:

Wolfram Language code: conv[{{1, 2, 3, 4, 5}}]

Create a two-dimensional ConvolutionLayer with an identity kernel that applies a bias to each channel:

Wolfram Language code:

kernel = ArrayReshape[IdentityMatrix[3], {3, 3, 1, 1}];
conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> {0.5, -0.5, 0.}, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

"Weights" (4)

Create a one-dimensional ConvolutionLayer with a kernel that averages pairs from the input array:

Wolfram Language code: conv = ConvolutionLayer["Weights" -> {{{0.5, 0.5}}}, "Biases" -> None]

Apply the layer to an input:

Wolfram Language code: conv[{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}] // Normal

Create a two-dimensional ConvolutionLayer with three input channels and one output channel that applies a Gaussian blur:

Wolfram Language code:

kernel = Table[GaussianMatrix[5], 1, 3];
conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

Create a two-dimensional ConvolutionLayer composed of per-channel Gaussian kernels. First create the kernels:

Wolfram Language code:

zero = ConstantArray[0, {19, 19}];
kernel = Table[If[i == j, GaussianMatrix[{9, 6 - 3i}], zero], {i, 0, 2}, {j, 0, 2}];

Visualize the kernels:

Wolfram Language code: Map[ArrayPlot[#, ImageSize -> 30]&, kernel, {2}]//GraphicsGrid

Initialize a net using the kernels:

Wolfram Language code:

conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

Create a two-dimensional ConvolutionLayer with a random kernel:

Wolfram Language code:

kernel = RandomVariate[NormalDistribution[], {3, 3, 5, 5}];
conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

Options (12)

"ChannelGroups" (2)

Create a two-dimensional ConvolutionLayer with three channel groups:

Wolfram Language code: conv = NetInitialize@ConvolutionLayer[6, {2, 2}, "ChannelGroups" -> 3, "Input" -> {9, 30, 30}]

Using channel groups reduces the number of convolution weights by a factor equal to the group number. Check the dimensions of the weights:

Wolfram Language code: Dimensions@NetExtract[conv, "Weights"]

Compare with the weight dimensions of an analogous layer with one channel group:

Wolfram Language code: conv2 = NetInitialize@ConvolutionLayer[6, {2, 2}, "Input" -> {9, 30, 30}]

Wolfram Language code: Dimensions@NetExtract[conv2, "Weights"]

Create a random two-dimensional ConvolutionLayer with a channel groups of 3:

Wolfram Language code:

conv = NetInitialize@ConvolutionLayer[3, {4, 4}, "ChannelGroups" -> 3, "Input" -> NetEncoder[ "Image"], "Output" -> NetDecoder["Image"]]

Check the dimensions of the "Weights" parameter:

Wolfram Language code: Dimensions@NetExtract[conv, "Weights"]

Apply the convolution layer to an image:

Wolfram Language code: conv[[image]]//ImageAdjust

"Dilation" (2)

A dilation factor of size n on a given dimension effectively applies the kernel to elements from the input arrays that are distance n apart.

Create a one-dimensional ConvolutionLayer with a dilation factor of 2:

Wolfram Language code: conv = ConvolutionLayer["Weights" -> {{{0.5, 0.5}}}, "Biases" -> None, "Dilation" -> 2]

Apply the layer to an input:

Wolfram Language code: conv[{{0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0}}] // Normal

Create a random two-dimensional ConvolutionLayer with a dilation factor of 5:

Wolfram Language code:

conv = NetInitialize@ConvolutionLayer[3, {3, 3}, "Dilation" -> 5, "Input" -> NetEncoder[ "Image"], "Output" -> NetDecoder["Image"]]

Apply the dilated convolution layer to an image:

Wolfram Language code: conv[[image]]

Interleaving (1)

Create a ConvolutionLayer with InterleavingFalse and one input channel:

Wolfram Language code: ConvolutionLayer[1, 5, "Input" -> {1, 25, 25}, Interleaving -> False]

Create a ConvolutionLayer with InterleavingTrue and one input channel:

Wolfram Language code: ConvolutionLayer[1, 5, "Input" -> {25, 25, 1}, Interleaving -> True]

PaddingSize (4)

Create a one-dimensional ConvolutionLayer that averages neighboring elements and pads with 4 zeros on each side:

Wolfram Language code: conv = ConvolutionLayer["Weights" -> {{{0.5, 0.5}}}, "Biases" -> None, PaddingSize -> 4]

Apply the layer to an input:

Wolfram Language code: conv[{{1, 2, 3, 4, 5}}] // Normal

Create a random two-dimensional ConvolutionLayer that pads the first dimension with 10 zeros on each side and the second dimension with 25 zeros on each side:

Wolfram Language code:

conv = NetInitialize[ConvolutionLayer[3, {3, 3}, PaddingSize -> {10, 25}, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]], RandomSeeding -> Automatic]

Wolfram Language code: conv[[image]]

Create a random two-dimensional ConvolutionLayer that pads the first dimension with 10 zeros at the beginning and 20 zeros at the end:

Wolfram Language code:

conv = NetInitialize[ConvolutionLayer[3, {3, 3}, PaddingSize -> {{10, 20}, {0, 0}}, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]], RandomSeeding -> Automatic]

Wolfram Language code: conv[[image]]

Use padding to make the output dimensions equivalent to the input dimensions:

Wolfram Language code: conv = ConvolutionLayer[1, 5, "Input" -> {1, 25, 25}, PaddingSize -> 2 ]

This allows for deep networks to be defined with an arbitrary number of convolutions without the height and width of the input tending to 1.

"Stride" (3)

A stride of size n on a given dimension effectively controls the step size with which the kernel is moved across the input array to produce the output array.

Create a one-dimensional ConvolutionLayer with a kernel that takes the average of neighboring pairs:

Wolfram Language code:

kernel = {{{0.5, 0.5}}};
conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None]

Apply the layer to an input:

Wolfram Language code: conv[{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}] // Normal

Using a stride of 2 applies the kernel to non-overlapping pairs:

Wolfram Language code:

conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None, "Stride" -> 2];
conv[{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}] // Normal

Using a stride of 4 applies the kernel to every other pair:

Wolfram Language code:

conv = ConvolutionLayer["Weights" -> kernel, "Biases" -> None, "Stride" -> 4];
conv[{{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}}] // Normal

Create a random two-dimensional ConvolutionLayer with an asymmetric stride:

Wolfram Language code:

conv = ConvolutionLayer["Weights" -> RandomReal[0.1, {3, 3, 4, 4}], "Biases" -> None, "Stride" -> {3, 1}, "Input" -> NetEncoder["Image"], "Output" -> NetDecoder["Image"]]

Apply the layer to an image:

Wolfram Language code: conv[[image]]

Use a larger stride to reduce the dimension of the output:

Wolfram Language code: conv1 = ConvolutionLayer[30, 7, "Input" -> {3, 500, 500}, "Stride" -> 1 ]

Wolfram Language code: conv2 = ConvolutionLayer[30, 7, "Input" -> {3, 500, 500}, "Stride" -> 7 ]

A larger stride can also reduce computation time:

Wolfram Language code:

data = RandomReal[1, {3, 500, 500}];
conv1 = NetInitialize@conv1;
conv2 = NetInitialize@conv2;
conv1[data];//AbsoluteTiming
conv2[data];//AbsoluteTiming

Properties & Relations (2)

The following function computes the size of the non-channel dimensions, given the input size and parameters:

Wolfram Language code:

outputSize[inputSize_List, kernSize_, stride_, pad_, dilate_] := Floor[(inputSize + 2 * pad - (dilate * (kernSize - 1) + 1)) / stride] + 1

The output size of an input of size {256,252}, a kernel size of {2,3}, a stride of 2, a dilation factor of {3,4}, and a padding size of {1,2}:

Wolfram Language code: outputSize[{256, 252}, {2, 3}, 2, {1, 2}, {3, 4}]

ConvolutionLayer can be used to compute two-dimensional convolutions:

Wolfram Language code:

kernel = {{10, 1}, {1, 3}};
data = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
ConvolutionLayer[1, "Weights" -> {{kernel}}, "Biases" -> {0}][{data}]//First // Normal

This is equivalent to ListConvolve after reversing the kernel:

Wolfram Language code: ListConvolve[Reverse[kernel, {1, 2}], data]

Possible Issues (5)

ConvolutionLayer cannot be initialized until all its input and output dimensions are known:

Wolfram Language code: NetInitialize@ConvolutionLayer[3, {2, 2}]

Wolfram Language code: NetInitialize@ConvolutionLayer[3, 2, "Input" -> {5, 23, 25}]

ConvolutionLayer cannot accept symbolic inputs:

Wolfram Language code:

conv = NetInitialize@ConvolutionLayer[1, {1, 1}, "Input" -> {1, 1, 1}];
conv[{{{1}}}]

Wolfram Language code: conv[{{{x}}}]

The kernel size cannot be larger than the input dimensions:

Wolfram Language code: ConvolutionLayer[3, {15, 15}, "Input" -> {3, 10, 10}]

"ChannelGroups" has to be a factor of the input channels:

Wolfram Language code: ConvolutionLayer[6, 2, "ChannelGroups" -> 3, "Input" -> {3, Automatic, Automatic}]

Wolfram Language code: ConvolutionLayer[6, 2, "ChannelGroups" -> 4, "Input" -> {3, Automatic, Automatic}]

ConvolutionLayer cannot be applied to a batch of inputs with varying input sizes:

Wolfram Language code:

conv = NetInitialize@ConvolutionLayer[3, {2, 2}, "Input" -> {2, Automatic, Automatic}];
conv[RandomReal[1, {2, 2, 3, 3}]]

Wolfram Language code: conv@{RandomReal[1, {2, 3, 3}], RandomReal[1, {2, 4, 4}]}

Top

More Learning

Tech Support

Data Science, Finance & Business

Engineering

Science & Technology

Technology for Education

Education Initiatives

Get Started

Grow Your Skills

Work with Us

Educational Programs for Adults

Educational Programs for Youth

Read

ConvolutionLayer

Details and Options

Examples

Basic Examples (2)

Scope (13)

Arguments (3)

Ports (3)

Parameters (7)

"Biases" (3)

"Weights" (4)

Options (12)

"ChannelGroups" (2)

"Dilation" (2)

Interleaving (1)

PaddingSize (4)

"Stride" (3)

Properties & Relations (2)

Possible Issues (5)

Text

CMS

APA

BibTeX

BibLaTeX

ConvolutionLayer

Details and Options

Examples

Basic Examples (2)

Scope (13)

Arguments (3)

Ports (3)

Parameters (7)

"Biases" (3)

"Weights" (4)

Options (12)

"ChannelGroups" (2)

"Dilation" (2)

Interleaving (1)

PaddingSize (4)

"Stride" (3)

Properties & Relations (2)

Possible Issues (5)

See Also

Tech Notes

Related Guides

History

Text

CMS

APA

BibTeX

BibLaTeX