torch.nn.MaxPool2d
new MaxPool2d(kernel_size: number | [number, number], options?: MaxPool2dOptions)
- readonly
kernel_size(number | [number, number]) - readonly
stride(number | [number, number]) - readonly
padding(number | [number, number]) - readonly
return_indices(boolean)
2D max pooling: reduces spatial dimensions by taking maximum over sliding window.
Applies max pooling over 2D spatial data (images): scans a kernel over height and width, returning the maximum value within each kernel window. Reduces spatial dimensionality while preserving strongest activations. Essential for:
- Image feature extraction (pooling after convolution layers)
- Downsampling feature maps (reducing spatial resolution while preserving peaks)
- Shift/translation invariance (networks robust to small spatial shifts)
- Computational efficiency (reducing spatial dimensions for deeper layers)
- Feature extraction in CNNs (standard between conv blocks)
Max pooling selects the strongest activations in each spatial window, providing translation invariance and shift robustness. Unlike average pooling which smooths, max pooling keeps peaks sharp and preserves important features while discarding less prominent activations.
When to use MaxPool2d:
- CNNs for image classification/detection (peaks matter more than average)
- Reducing feature map spatial dimensions between conv layers
- Networks needing shift invariance
- Standard architectures (ResNet, VGG, etc. use MaxPool2d)
- When preserving maximum activations is important
Trade-offs:
- vs AvgPool2d: MaxPool2d preserves peaks; AvgPool2d smooths (averages)
- vs adaptive pooling: MaxPool2d fixed stride/kernel; adaptive auto-adjusts output size
- Output size: Controlled by kernel_size and stride explicitly
- Information loss: Only max per window kept; other spatial information lost
- Gradient flow: Gradient only flows to max element in each window
Pooling mechanics: For a 2D image [B, C, H, W] (batch, channels, height, width):
- For each channel independently:
- Slide kernel_size × kernel_size window over spatial dimensions
- Step by stride in both H and W directions (default: kernel_size for non-overlapping)
- Keep maximum value in each window
- Output: [B, C, H_out, W_out] where:
- H_out = floor((H + 2*padding_h - kernel_h) / stride_h) + 1
- W_out = floor((W + 2*padding_w - kernel_w) / stride_w) + 1
- Default stride: stride=kernel_size gives non-overlapping pooling
- Stride kernel: Creates overlapping windows (smoother downsampling)
- Square kernels common: [3,3] or [2,2] most typical in standard CNNs
- Gradient: Only max element per window gets gradient; others get zero
- Indices: Useful for unpooling to reconstruct approximate original spatial layout
- Deterministic: Given same input, always selects same indices (no randomness)
- Padding: Zero-padding added before pooling; affects output size calculation
- Channel independence: Each channel pooled independently (max preserves feature structure)
- Architecture pattern: Conv2d → MaxPool2d → Conv2d is the standard CNN building block
- Gradient sparsity: Many neurons have zero gradient (not max in window)
- Information loss: Non-max values discarded; 2D spatial information compression irreversible
- Output size: Calculate using formula to predict output dimensions
- Peak preservation: Can amplify noise if noise is peak in window
- Boundary effects: Padding policy affects corner/edge handling
Examples
// Standard 2x2 pooling for image classification
const pool = new torch.nn.MaxPool2d(2); // kernel=2x2, stride=2 (non-overlapping)
const x = torch.randn([32, 64, 224, 224]); // [batch, channels, height, width]
const y = pool.forward(x); // [batch, 64, 112, 112] - spatial dims halved// Overlapping pooling with different height/width kernels
const pool = new torch.nn.MaxPool2d([3, 3], 1, 1); // kernel=3x3, stride=1, padding=1 (overlapping)
const x = torch.randn([32, 128, 56, 56]);
const y = pool.forward(x); // [32, 128, 56, 56] - spatial dims unchanged// ResNet-style pooling sequence
const conv1 = new torch.nn.Conv2d(3, 64, 7, { stride: 2, padding: 3 });
const pool = new torch.nn.MaxPool2d(3, 2, 1); // kernel=3x3, stride=2, padding=1
const x = torch.randn([32, 3, 224, 224]);
let y = conv1.forward(x); // [32, 64, 112, 112]
y = pool.forward(y); // [32, 64, 56, 56] - standard ResNet stem// With indices for unpooling (deconvolution networks)
const pool = new torch.nn.MaxPool2d(2, 2, 0, true); // return_indices=true
const x = torch.randn([8, 128, 32, 32]);
const [y, indices] = pool.forward(x) as [torch.Tensor, torch.Tensor];
// indices tells where max came from, used for MaxUnpool2d reconstruction// Asymmetric kernel and stride (common in VGG networks)
const pool = new torch.nn.MaxPool2d([3, 3], [2, 2], 1);
const x = torch.randn([16, 256, 28, 28]);
const y = pool.forward(x); // Typical VGG pooling pattern