from d2l import torch as d2l
import torch
from torch import nn6.5 Pooling
In many cases our ultimate task asks some global question about the image, e.g., does it contain a cat? Consequently, the units of our final layer should be sensitive to the entire input. By gradually aggregating information, yielding coarser and coarser maps, we accomplish this goal of ultimately learning a global representation, while keeping all of the advantages of convolutional layers at the intermediate layers of processing. The deeper we go in the network, the larger the receptive field (relative to the input) to which each hidden node is sensitive. Reducing spatial resolution accelerates this process, since the convolution kernels cover a larger effective area.
Moreover, when detecting lower-level features, such as edges (as discussed in Section 6.2), we often want our representations to be somewhat invariant to translation. For instance, if we take the image X with a sharp delineation between black and white and shift the whole image by one pixel to the right, i.e., Z[i, j] = X[i, j - 1], then the output for the new image Z might be vastly different. The edge will have shifted by one pixel. In reality, objects hardly ever occur exactly at the same place. In fact, even with a tripod and a stationary object, vibration of the camera due to the movement of the shutter might shift everything by a pixel or so (high-end cameras are loaded with special features to address this problem).
This section introduces pooling layers, which serve the dual purposes of mitigating the sensitivity of convolutional layers to location and of spatially downsampling representations.
from d2l import tensorflow as d2l
import tensorflow as tffrom d2l import jax as d2l
from flax import nnx
import jax
from jax import numpy as jnpfrom d2l import mxnet as d2l
from mxnet import np, npx
from mxnet.gluon import nn
npx.set_np()6.5.1 Maximum Pooling and Average Pooling
Like convolutional layers, pooling operators consist of a fixed-shape window that is slid over all regions in the input according to its stride, computing a single output for each location traversed by the fixed-shape window (sometimes known as the pooling window). However, unlike the cross-correlation computation of the inputs and kernels in the convolutional layer, the pooling layer contains no parameters (there is no kernel). Instead, pooling operators are deterministic, typically calculating either the maximum or the average value of the elements in the pooling window. These operations are called maximum pooling (max-pooling for short) and average pooling, respectively.
Average pooling is essentially as old as CNNs. The idea is akin to downsampling an image. Rather than just taking the value of every second (or third) pixel for the lower resolution image, we can average over adjacent pixels to obtain an image with better signal-to-noise ratio since we are combining the information from multiple adjacent pixels. Max-pooling was introduced in Riesenhuber and Poggio (1999) in the context of cognitive neuroscience to describe how information might be aggregated hierarchically for the purpose of object recognition; there already was an earlier version in speech recognition (Yamaguchi et al. 1990). Historically, max-pooling was often preferred inside convolutional bodies, while average pooling became the standard choice for global classifier heads. Neither dominates in every setting.
In both cases, as with the cross-correlation operator, we can think of the pooling window as starting from the upper-left of the input tensor and sliding across it from left to right and top to bottom. At each location that the pooling window hits, it computes the maximum or average value of the input subtensor in the window, depending on whether max or average pooling is employed.
The output tensor in Figure 6.5.1 has a height of 2 and a width of 2. The four elements are derived from the maximum value in each pooling window:
\[ \max(0, 1, 3, 4)=4,\\ \max(1, 2, 4, 5)=5,\\ \max(3, 4, 6, 7)=7,\\ \max(4, 5, 7, 8)=8.\\ \]
More generally, we can define a \(p \times q\) pooling layer by aggregating over a region of said size. Returning to the problem of edge detection, we use the output of the convolutional layer as input for \(2\times 2\) max-pooling. Denote the edge-detector output by X and the pooling output by Y. If a single response of value 1 moves anywhere within the same \(2\times2\) pooling window while the other responses remain no larger, then Y[i, j] remains 1. Thus max-pooling can make a representation insensitive to some small movements that stay within a window. Crossing a window boundary can still change the pooled output abruptly, so this is local tolerance rather than exact translation invariance.
In the code below, we implement the forward propagation of the pooling layer in the pool2d function. This function is similar to the corr2d function in Section 6.2. However, no kernel is needed, computing the output as either the maximum or the average of each region in the input.
def pool2d(X, pool_size, mode='max'):
p_h, p_w = pool_size
Y = d2l.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j] = X[i: i + p_h, j: j + p_w].max()
elif mode == 'avg':
Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
return Ydef pool2d(X, pool_size, mode='max'):
p_h, p_w = pool_size
Y = tf.Variable(tf.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w +1)))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j].assign(tf.reduce_max(X[i: i + p_h, j: j + p_w]))
elif mode =='avg':
Y[i, j].assign(tf.reduce_mean(X[i: i + p_h, j: j + p_w]))
return Ydef pool2d(X, pool_size, mode='max'):
p_h, p_w = pool_size
Y = jnp.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y = Y.at[i, j].set(X[i: i + p_h, j: j + p_w].max())
elif mode == 'avg':
Y = Y.at[i, j].set(X[i: i + p_h, j: j + p_w].mean())
return Ydef pool2d(X, pool_size, mode='max'):
p_h, p_w = pool_size
Y = d2l.zeros((X.shape[0] - p_h + 1, X.shape[1] - p_w + 1))
for i in range(Y.shape[0]):
for j in range(Y.shape[1]):
if mode == 'max':
Y[i, j] = X[i: i + p_h, j: j + p_w].max()
elif mode == 'avg':
Y[i, j] = X[i: i + p_h, j: j + p_w].mean()
return YWe can construct the input tensor X in Figure 6.5.1 to validate the output of the two-dimensional max-pooling layer.
X = d2l.tensor([[0.0, 1.0, 2.0], [3.0, 4.0, 5.0], [6.0, 7.0, 8.0]])
pool2d(X, (2, 2))tensor([[4., 5.],
[7., 8.]])<tf.Variable 'Variable:0' shape=(2, 2) dtype=float32, numpy=
array([[4., 5.],
[7., 8.]], dtype=float32)>Array([[4., 5.],
[7., 8.]], dtype=float32)array([[4., 5.],
[7., 8.]])Also, we can experiment with the average pooling layer.
pool2d(X, (2, 2), 'avg')tensor([[2., 3.],
[5., 6.]])<tf.Variable 'Variable:0' shape=(2, 2) dtype=float32, numpy=
array([[2., 3.],
[5., 6.]], dtype=float32)>Array([[2., 3.],
[5., 6.]], dtype=float32)array([[2., 3.],
[5., 6.]])6.5.2 Padding and Stride
As with convolutional layers, pooling layers change the output shape. And as before, we can adjust the operation to achieve a desired output shape by padding the input and adjusting the stride. We can demonstrate the use of padding and strides in pooling layers via the built-in two-dimensional max-pooling layer from the deep learning framework. We first construct an input tensor X whose shape has four dimensions, where the number of examples (batch size) and number of channels are both 1.
Note that unlike other frameworks, TensorFlow prefers and is optimized for channels-last input.
X = d2l.reshape(d2l.arange(16, dtype=d2l.float32), (1, 1, 4, 4))
Xtensor([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]]]])X = d2l.reshape(d2l.arange(16, dtype=d2l.float32), (1, 4, 4, 1))
X<tf.Tensor: shape=(1, 4, 4, 1), dtype=float32, numpy=
array([[[[ 0.],
[ 1.],
[ 2.],
[ 3.]],
[[ 4.],
[ 5.],
[ 6.],
[ 7.]],
[[ 8.],
[ 9.],
[10.],
[11.]],
[[12.],
[13.],
[14.],
[15.]]]], dtype=float32)>X = d2l.reshape(d2l.arange(16, dtype=d2l.float32), (1, 4, 4, 1))
XArray([[[[ 0.],
[ 1.],
[ 2.],
[ 3.]],
[[ 4.],
[ 5.],
[ 6.],
[ 7.]],
[[ 8.],
[ 9.],
[10.],
[11.]],
[[12.],
[13.],
[14.],
[15.]]]], dtype=float32)X = d2l.reshape(d2l.arange(16, dtype=d2l.float32), (1, 1, 4, 4))
Xarray([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]]]])Since pooling aggregates information from an area, deep learning frameworks default to matching pooling window sizes and stride. For instance, if we use a pooling window of shape (3, 3) we get a stride shape of (3, 3) by default.
pool2d = nn.MaxPool2d(3)
# Pooling has no model parameters, hence it needs no initialization
pool2d(X)tensor([[[[10.]]]])pool2d = tf.keras.layers.MaxPool2D(pool_size=[3, 3])
# Pooling has no model parameters, hence it needs no initialization
pool2d(X)<tf.Tensor: shape=(1, 1, 1, 1), dtype=float32, numpy=array([[[[10.]]]], dtype=float32)># Pooling has no model parameters, hence it needs no initialization
nnx.max_pool(X, window_shape=(3, 3), strides=(3, 3))Array([[[[10.]]]], dtype=float32)pool2d = nn.MaxPool2D(3)
# Pooling has no model parameters, hence it needs no initialization
pool2d(X)array([[[[10.]]]])Needless to say, the stride and padding can be manually specified to override framework defaults if required.
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(X)tensor([[[[ 5., 7.],
[13., 15.]]]])paddings = tf.constant([[0, 0], [1,0], [1,0], [0,0]])
X_padded = tf.pad(X, paddings, "CONSTANT")
pool2d = tf.keras.layers.MaxPool2D(pool_size=[3, 3], padding='valid',
strides=2)
pool2d(X_padded)<tf.Tensor: shape=(1, 2, 2, 1), dtype=float32, numpy=
array([[[[ 5.],
[ 7.]],
[[13.],
[15.]]]], dtype=float32)>X_padded = jnp.pad(X, ((0, 0), (1, 0), (1, 0), (0, 0)), mode='constant')
nnx.max_pool(X_padded, window_shape=(3, 3), padding='VALID', strides=(2, 2))Array([[[[ 5.],
[ 7.]],
[[13.],
[15.]]]], dtype=float32)pool2d = nn.MaxPool2D(3, padding=1, strides=2)
pool2d(X)array([[[[ 5., 7.],
[13., 15.]]]])Of course, we can specify an arbitrary rectangular pooling window with arbitrary height and width respectively, as the example below shows.
pool2d = nn.MaxPool2d((2, 3), stride=(2, 3), padding=(0, 1))
pool2d(X)tensor([[[[ 5., 7.],
[13., 15.]]]])paddings = tf.constant([[0, 0], [0, 0], [1, 1], [0, 0]])
X_padded = tf.pad(X, paddings, "CONSTANT")
pool2d = tf.keras.layers.MaxPool2D(pool_size=[2, 3], padding='valid',
strides=(2, 3))
pool2d(X_padded)<tf.Tensor: shape=(1, 2, 2, 1), dtype=float32, numpy=
array([[[[ 5.],
[ 7.]],
[[13.],
[15.]]]], dtype=float32)>
X_padded = jnp.pad(X, ((0, 0), (0, 0), (1, 1), (0, 0)), mode='constant')
nnx.max_pool(X_padded, window_shape=(2, 3), strides=(2, 3), padding='VALID')Array([[[[ 5.],
[ 7.]],
[[13.],
[15.]]]], dtype=float32)pool2d = nn.MaxPool2D((2, 3), padding=(0, 1), strides=(2, 3))
pool2d(X)array([[[[ 5., 7.],
[13., 15.]]]])6.5.3 Multiple Channels
When processing multi-channel input data, the pooling layer pools each input channel separately, rather than summing the inputs up over channels as in a convolutional layer. This means that the number of output channels for the pooling layer is the same as the number of input channels. Below, we will concatenate tensors X and X + 1 on the channel dimension to construct an input with two channels.
Note that this will require a concatenation along the last dimension for TensorFlow due to the channels-last syntax.
X = d2l.concat((X, X + 1), 1)
Xtensor([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]],
[[ 1., 2., 3., 4.],
[ 5., 6., 7., 8.],
[ 9., 10., 11., 12.],
[13., 14., 15., 16.]]]])# Concatenate along `dim=3` due to channels-last syntax
X = d2l.concat([X, X + 1], 3)
X<tf.Tensor: shape=(1, 4, 4, 2), dtype=float32, numpy=
array([[[[ 0., 1.],
[ 1., 2.],
[ 2., 3.],
[ 3., 4.]],
[[ 4., 5.],
[ 5., 6.],
[ 6., 7.],
[ 7., 8.]],
[[ 8., 9.],
[ 9., 10.],
[10., 11.],
[11., 12.]],
[[12., 13.],
[13., 14.],
[14., 15.],
[15., 16.]]]], dtype=float32)># Concatenate along `dim=3` due to channels-last syntax
X = d2l.concat([X, X + 1], 3)
XArray([[[[ 0., 1.],
[ 1., 2.],
[ 2., 3.],
[ 3., 4.]],
[[ 4., 5.],
[ 5., 6.],
[ 6., 7.],
[ 7., 8.]],
[[ 8., 9.],
[ 9., 10.],
[10., 11.],
[11., 12.]],
[[12., 13.],
[13., 14.],
[14., 15.],
[15., 16.]]]], dtype=float32)X = d2l.concat((X, X + 1), 1)
Xarray([[[[ 0., 1., 2., 3.],
[ 4., 5., 6., 7.],
[ 8., 9., 10., 11.],
[12., 13., 14., 15.]],
[[ 1., 2., 3., 4.],
[ 5., 6., 7., 8.],
[ 9., 10., 11., 12.],
[13., 14., 15., 16.]]]])As we can see, the number of output channels is still two after pooling.
pool2d = nn.MaxPool2d(3, padding=1, stride=2)
pool2d(X)tensor([[[[ 5., 7.],
[13., 15.]],
[[ 6., 8.],
[14., 16.]]]])paddings = tf.constant([[0, 0], [1,0], [1,0], [0,0]])
X_padded = tf.pad(X, paddings, "CONSTANT")
pool2d = tf.keras.layers.MaxPool2D(pool_size=[3, 3], padding='valid',
strides=2)
pool2d(X_padded)<tf.Tensor: shape=(1, 2, 2, 2), dtype=float32, numpy=
array([[[[ 5., 6.],
[ 7., 8.]],
[[13., 14.],
[15., 16.]]]], dtype=float32)>X_padded = jnp.pad(X, ((0, 0), (1, 0), (1, 0), (0, 0)), mode='constant')
nnx.max_pool(X_padded, window_shape=(3, 3), padding='VALID', strides=(2, 2))Array([[[[ 5., 6.],
[ 7., 8.]],
[[13., 14.],
[15., 16.]]]], dtype=float32)pool2d = nn.MaxPool2D(3, padding=1, strides=2)
pool2d(X)array([[[[ 5., 7.],
[13., 15.]],
[[ 6., 8.],
[14., 16.]]]])Note that the output for the TensorFlow pooling appears at first glance to be different, however numerically the same results are presented as MXNet and PyTorch. The difference lies in the dimensionality, and reading the output vertically yields the same output as the other implementations.
6.5.4 Summary
Pooling is a simple operation: it replaces each window of values with a single summary, the maximum or the mean. The stride and padding semantics of convolutions carry over unchanged, and pooling applies to each channel separately, so the number of channels is preserved. There are no parameters to learn. A \(2 \times 2\) window with stride 2, which quarters the number of spatial locations, is the classical local configuration; global average pooling is now the common classification head.
Be aware, though, that pooling is no longer how most downsampling happens. Modern convolutional networks reduce resolution mainly with strided convolutions: a convolution with stride 2 halves the resolution just as a pooling layer would, but it learns its aggregation weights rather than fixing them to max or mean. ResNet (Section 7.4) and its successors follow this pattern. Pooling survives in two roles. Global average pooling, introduced with the network-in-network architecture (Section 7.2.2) (Lin et al. 2013), averages each channel over all spatial positions; it turns the final feature map into one number per channel and has replaced the large fully connected layers of early CNNs as the default classifier head. Max-pooling persists in some network stems (ResNet opens with one) and in detection models that merge feature maps across scales.
One caveat applies to every stride-2 downsampler, pooled or convolutional: subsampling a signal without first removing its high spatial frequencies can alias, so that shifting the input by a single pixel changes the output noticeably; applying a small low-pass (blur) filter before subsampling can make the result substantially more shift-consistent, though not exactly invariant (Zhang 2019). Beyond these mainstays there are randomized variants such as stochastic pooling (Zeiler and Fergus 2013) and fractional max-pooling (Graham 2014), and the attention mechanisms of Chapter 10 aggregate by learned alignment between a query and representation vectors rather than by spatial location.
6.5.5 Exercises
- Implement average pooling through a convolution.
- Prove that max-pooling cannot be implemented through a convolution alone.
- Max-pooling can be accomplished using ReLU operations, i.e., \(\textrm{ReLU}(x) = \max(0, x)\).
- Express \(\max (a, b)\) by using only ReLU operations.
- Use this to implement max-pooling by means of convolutions and ReLU layers.
- How many channels and layers do you need for a \(2 \times 2\) convolution? How many for a \(3 \times 3\) convolution?
- What is the computational cost of the pooling layer? Assume that the input to the pooling layer is of size \(c\times h\times w\), the pooling window has a shape of \(p_\textrm{h}\times p_\textrm{w}\) with a padding of \((p_\textrm{h}, p_\textrm{w})\) and a stride of \((s_\textrm{h}, s_\textrm{w})\).
- Why do you expect max-pooling and average pooling to work differently?
- Do we need a separate minimum pooling layer? Can you replace it with another operation?
- We could use the softmax operation for pooling. Why might it not be so popular?
- Naive stride-2 downsampling keeps every second entry of its input. Apply it to the one-dimensional signals \((1, 0, 1, 0, 1, 0)\) and \((0, 1, 0, 1, 0, 1)\), i.e., the same pattern shifted by one position.
- Compare the two outputs. Why is this behavior called aliasing, and which input frequencies can a stride-2 subsampler represent faithfully?
- Blur-pool counteracts aliasing by applying a small averaging filter before subsampling. Work out what blur-pool with a two-tap box filter \((\tfrac{1}{2}, \tfrac{1}{2})\) computes on the two signals above. Which pooling operation from this section does it coincide with?