Convolutional layer
A convolutional layer is a neural-network layer that applies shared learned filters to local regions of structured input to produce feature representations.
Natural Language Processing in Action, Second Edition
A convolutional layer is a neural-network layer that applies learned filters across local regions of its input to produce feature maps.
- How it is used
- Detects local word-order patterns for text classification, including identifying disaster-related posts.
- How deep it goes
- Works from sliding-window intuition through hand-set Conv1d weights, tensor shapes, and a trained classifier.
- Examples
- Uses part-of-speech pattern matching and a disaster-tweet classifier; a separate handwritten filter detects Morse-code dots.
- What you can do after
- Build it from scratch as a PyTorch Conv1d text-classifier component, aligning embedding channels and checking output shapes.
Read how Natural Language Processing in Action, Second Edition explains convolutional layer →
Math and Architectures of Deep Learning
A neural-network layer that applies convolution operations to an input, commonly used to extract local features from images.
- How it is used
- Extracts local image, curve, and video patterns as feature maps for neural networks.
- How deep it goes
- Derives sliding weighted sums, padding, matrix form, backpropagation linkage, 1D–3D cases, and PyTorch tensor interfaces.
- Examples
- Uses smoothing and edge-detection kernels, noisy text images, a moving-ball video, and LeNet on MNIST digits.
- What you can do after
- Apply it via PyTorch Conv1d, Conv2d, and Conv3d layers within trainable neural networks.
Read how Math and Architectures of Deep Learning explains convolutional layer →
Deep Learning with PyTorch, Second Edition
A PyTorch 2D convolution layer module that applies learned filters over spatial input regions.
- How it is used
- Replaces fully connected image processing with local, shared filters in a bird-versus-airplane classifier.
- How deep it goes
- Works through neighborhood weighting, learned parameters, tensor shapes, hand-set filters, and a two-layer network; leaves continuous convolution aside.
- Examples
- Uses a CIFAR-10 bird image, averaging and edge-detection kernels, tensor-shape checks, and a bird-versus-airplane network.
- What you can do after
- Apply it via PyTorch `nn.Conv2d` to assemble image-classification layers and track their channel and spatial shapes.
Read how Deep Learning with PyTorch, Second Edition explains convolutional layer →
Deep Learning with Python, Third Edition
A two-dimensional convolution layer used here with a 1×1 kernel to project a residual to a matching shape.
- How it is used
- Extracts local image features for classification and provides a configurable output depth.
- How deep it goes
- Explains patch-wise transformation and feature-map dimensions, contrasting convolution with Dense layers and max pooling.
- Examples
- Uses MNIST digit classification and dogs-versus-cats classification to show Conv2D stacks.
- What you can do after
- Apply it via Keras Conv2D to assemble an image classifier and inspect changing feature-map shapes.
Read how Deep Learning with Python, Third Edition explains convolutional layer →
Deep Learning with R, Third Edition
A convolutional layer is a neural-network layer that applies learned local filters across spatial or sequential input dimensions.
- How it is used
- Builds local visual features for image classification and per-pixel segmentation.
- How deep it goes
- Explains patch-based feature maps, output channels, padding and strides through architecture and shape examples, without a formal derivation.
- Examples
- Uses an MNIST digit classifier and an image-segmentation model with per-pixel output.
- What you can do after
- Build it from scratch: assemble and train an R/Keras convolutional classifier, then adapt downsampling for segmentation.
Read how Deep Learning with R, Third Edition explains convolutional layer →
Grokking AI Algorithms, Second Edition
A convolutional layer is a neural-network layer that applies shared filters to local regions of an input representation while preserving spatial organization.
- How it is used
- Extracts local image features while preserving spatial arrangement for image analysis and U-Net image generation.
- How deep it goes
- Works through filter scanning, dot products, feature-map shapes, padding, and NumPy loops; stops short of a complete training procedure.
- Examples
- Traces a 3×3 filter over an 8×8 image, calculates a row dot product, and produces eight feature maps.
- What you can do after
- Build a feature-map calculation from scratch with NumPy loops, padding, filters, and biases.
Read how Grokking AI Algorithms, Second Edition explains convolutional layer →
Evolutionary Deep Learning: Genetic algorithms and neural networks
A convolutional layer applies learned local filters across structured input locations to detect spatial or otherwise local patterns.
- How it is used
- Extracts image features for CNN classifiers and for autoencoder encoding and reconstruction.
- How deep it goes
- Demonstrates sliding learned filters and Keras layer construction, then encodes filter and kernel choices for evolutionary architectures.
- Examples
- Uses Fashion-MNIST CNNs, a 28×28 grayscale convolutional autoencoder, and randomly generated architecture gene sequences.
- What you can do after
- Apply it via Keras Conv2D to assemble CNN and autoencoder feature-extraction paths and vary their architecture parameters.
Optimization Algorithms: AI techniques for design, planning, and control problems
A transformation that applies shared learned weights to neighboring feature representations.
- How it is used
- Uses convolution to learn node representations from local graph structure for graph embedding and classification.
- How deep it goes
- Explains the operator’s structural intuition and demonstrates a two-layer GCN, but does not derive convolution mathematically.
- Examples
- Uses GCNConv layers, the Cora dataset, edge indices, ReLU, dropout, and a 200-epoch Adam training loop.
- What you can do after
- Builds a node-embedding model with PyTorch Geometric’s GCNConv layer and trains it on graph data.
Learn Generative AI with PyTorch
A PyTorch convolution layer that applies learned 2D filters to an input tensor to produce feature maps.
- How it is used
- Extracts spatial features from images for classification, discrimination, encoding, and generative reconstruction.
- How deep it goes
- Explains sliding-filter arithmetic, tensor shapes, parameters, learned weights, stride, padding, and multi-layer architectures.
- Examples
- Uses a hand-weighted two-by-two filter, a DCGAN discriminator, and a VAE encoder to demonstrate outputs and architecture.
- What you can do after
- Build it from scratch using PyTorch nn.Conv2d, configure tensor channels and spatial movement, and inspect resulting feature maps.
Read how Learn Generative AI with PyTorch explains convolutional layer →
Sutskever's List
A convolutional layer is a neural-network layer that applies learned local filters across an input to produce spatial feature responses.
- How it is used
- Enables automatic, hierarchical feature extraction in AlexNet’s image-classification architecture.
- How deep it goes
- Explains feature progression, parameter sharing, filter size, and stride through architectural examples, without deriving convolution mathematically.
- Examples
- Uses AlexNet’s 224 × 224 × 3 input, 11 × 11 first-layer filters, stride of 4, and two-GPU architecture diagram.
- What you can do after
- Evaluate/understand how filter size, stride, and pooling change spatial dimensions while convolutional layers build increasingly complex image features.
Machine Learning Algorithms in Depth
A convolutional layer is a neural-network layer that applies learned convolution kernels to an input representation.
- How it is used
- Uses learned local filters to extract features from images, time series, and volumetric data.
- How deep it goes
- Defines sliding kernels, dot products, feature maps, stacking, and activation placement, but does not derive gradient formulas.
- Examples
- Demonstrates 2D image convolution in LeNet for MNIST and 1D convolution in a multi-input question-similarity model.
- What you can do after
- Builds CNNs with Conv2D or Conv1D, pooling, nonlinearities, and downstream classification layers in Keras/TensorFlow.
Read how Machine Learning Algorithms in Depth explains convolutional layer →
Build a Text-to-Image Generator (from Scratch)
Conv2d is a two-dimensional convolution layer that applies learned spatial filters to image-like tensors.
- How it is used
- Extracts spatial features for image classification and denoising architectures.
- How deep it goes
- Explains filters, feature maps, and architectural roles, but stops short of deriving convolution numerically or implementing Conv2d from scratch.
- Examples
- Uses image denoising, U-Net feature extraction, and 32 × 32 image patches projected into 64 token vectors.
- What you can do after
- Evaluate/understand how learned filters produce feature maps and support downsampling, denoising, and patch-token conversion.
Read how Build a Text-to-Image Generator (from Scratch) explains convolutional layer →
Distributed Machine Learning Patterns
A convolutional layer is a neural-network layer that applies learned convolutional filters to its input.
- How it is used
- Builds image-classification CNNs by extracting feature mappings before pooling and dense classification.
- How deep it goes
- Defines layer placement and TensorFlow configuration, but stops short of convolution arithmetic or filter-internals.
- Examples
- Uses a three-layer 28 × 28 image CNN and a LeNet architecture for classifying images or video frames.
- What you can do after
- Build it from scratch with TensorFlow Sequential and Conv2D, then inspect, compile, train, and monitor the resulting CNN.
Read how Distributed Machine Learning Patterns explains convolutional layer →
Grokking Machine Learning
A convolutional layer is a neural-network layer that produces a filtered representation by applying convolutions across an input.
- How it is used
- Adapts neural-network architectures to complicated images where flattening pixels into a long vector loses information.
- How deep it goes
- Sketches a sliding-window convolution with example window sizes, but gives no formula or implementation details.
- Examples
- Uses MNIST handwritten digits and CIFAR-10 color images as image-recognition examples.
- What you can do after
- Understand how a small window moves across an image and applies convolutions to form a smaller representation.
Read how Grokking Machine Learning explains convolutional layer →
Related concepts
- convolutional neural networkused by · A convolutional neural network is a neural-network architecture that applies learned convolutional operations to extract patterns from structured data.
- feature mapproduces · A feature map is a spatially organized array of neural-network activations representing the presence or strength of learned features at different locations.
- downsamplingused by · Downsampling is the reduction of data quantity, spatial resolution, temporal resolution, or sampling rate by retaining, selecting, or aggregating fewer representative values or observations.
- convolution kerneluses · A convolution kernel is a small array or tensor of weights applied across local input regions to compute weighted responses and detect or transform patterns.
- batch sizeuses · Batch size is the number of items grouped together for processing or computation as a single batch.
- encoderused by · An encoder is a component that transforms input data into an encoded representation for subsequent processing, reconstruction, comparison, or transmission.
These guides are generated from the text of Manning books by Manning's knowledge graph and link to the sections they draw on. The full books are available on liveBook and at manning.com.