Apply a 2D Max Pooling in PyTorch
Last Updated :
24 Apr, 2025
Pooling is a technique used in the CNN model for down-sampling the feature coming from the previous layer and produce the new summarised feature maps. In computer vision reduces the spatial dimensions of an image while retaining important features. The goal of pooling is to reduce the computational complexity of the model and make it less sensitive to small translations in the input image.
Types of Pooling
There are two main types of pooling used in deep learning: Max Pooling and Average Pooling.
Max Pooling: Max Pooling selects the maximum value from each set of overlapping filters and passes this maximum value to the next layer. This helps to retain the most important feature information while reducing the size of the representation.
Average Pooling: Average Pooling computes the average value of each set of overlapping filters, and passes this average value to the next layer. This helps to retain a more general form of the feature information, but with a reduced spatial resolution.
Pooling is usually applied after a convolution operation and helps to reduce overfitting and improve the generalization performance of the model.
2d Max pooling
As the name suggests, selects the maximum value in each pooling region and passes it on to the next layer. This helps to retain the most important feature information while discarding less important information. Max pooling is used to detect the presence of a feature in an image.
Syntax :
torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)
where,
kernel_size : It denotes the filtered kernel shape, which is considered at a time.
stride : Number of pixel shift over the input feature,(default is kernel_size)
padding : Extra 0 padding layers around both side the feature, (default is 0)
dialation: Control the stride (default is 1)
return_indices : True or False (default is False) return the max indices.
ceil_mode : True or False (default is False) when True it will use ceil instead of floor.
Let the input tensor be of a shape (n, c, h, w) and our kernel size is (k_h, k_w) then the output can be computed as:
\begin{aligned}out(n_i, c_j, h, w) =& \max_{m=0, \ldots, k_h-1} \;\; \max_{n=0, \ldots, k_w-1} &[\text{input}(n_i, c_j, \text{stride[0]} \times h + m,\; \text{stride[1]} \times w + n)] \end{aligned}
then the output Shape will be :
h_{out} = \left[\frac{h_{in} - \text{kernel\_size[0]}+ 2 * \text{padding[0]}}{\text{stride[0]}} + 1 \right]
w_{out} = \left[\frac{w_{in} - \text{kernel\_size[1]}+ 2 * \text{padding[1]}}{\text{stride[1]}} + 1 \right]
In this example, the input image is 4x4 and the Max-pooling operation is performed using a 2x2 pooling kernel and with stride 2X2. Stride defines how many numbers of pixels will shift over the input image.
2d Max Pooling with 2X2 kernel and stride 2
Here's an example of how Max-pooling can be implemented in PyTorch:
Python
import torch
import torch.nn as nn
# Define the input tensor
input_tensor = torch.tensor(
[
[1, 1, 2, 4],
[5, 6, 7, 8],
[3, 2, 1, 0],
[1, 2, 3, 4]
], dtype = torch.float32)
# Reshape the input_tensor
input_tensor = input_tensor.reshape(1, 1, 4, 4)
# Initialize the Max-pooling layer with kernel 2X2 and stride 2
pool = nn.MaxPool2d(kernel_size=2, stride=2)
# Apply the Max-pooling layer to the input tensor
output = pool(input_tensor)
# Print the output tensor
output
Output :
tensor([[[[6., 8.],
[3., 4.]]]])
Mathematically, the Output shape can be calculated as:
\begin{aligned} h_{out} & =\left[\frac{h_{in} - \text{kernel\_size[0]} + 2 * \text{padding[0]} }{\text{stride[0]}} + 1\right] \\&=\left [\frac{4 -2 + 2 * 0}{2} + 1\right] \\ &= \left[\frac{4 -2 + 0}{2} + 1\right] \\ &= \left[\frac{2}{2} + 1\right] \\ &= \left [1+1 \right] \\ &= 2 \end{aligned}
\begin{aligned} w_{out} & =\left[\frac{w_{in} - \text{kernel\_size[1]} + 2 * \text{padding[1]} }{\text{stride[1]}} + 1\right] \\&=\left [\frac{4 -2 + 2 * 0}{2} + 1\right] \\ &= \left[\frac{4 -2 + 0}{2} + 1\right] \\ &= \left[\frac{2}{2} + 1\right] \\ &= \left [1+1 \right] \\ &= 2 \end{aligned}
Apply 2d max pooling on a real image
Python3
import torch
from PIL import Image
import torchvision.transforms as T
# Read the image file
image = Image.open('GFG.jpg')
# convert input image to torch tensor
Input = T.ToTensor()(image)
# unsqueeze image to make 4D
Input = Input.unsqueeze(0)
print('Input Tensor :',Input.shape)
# define 2d Max pooling with square window
# of (kernel_size=4, stride=2 and padding=1)
pooling = torch.nn.MaxPool2d(kernel_size=(5,3),
stride=(3,2),
padding=(1,1),
dilation=1)
Output = pooling(Input)
print('Output Tensor :',Output.shape)
# squeeze image
Out_img = Output.squeeze(0)
# convert tensor to image
Out_img = T.ToPILImage()(Out_img)
Out_img
Output:
Input Tensor : torch.Size([1, 3, 561, 799])
Output Tensor : torch.Size([1, 3, 187, 400])
Output Image 2d max pooling
The output shape can be calculated as:
\begin{aligned} h_{out} & =\left[\frac{h_{in} -\text{kernel\_size[0]}+ 2 * \text{padding[0]}}{\text{stride[0]}} + 1\right] \\&=\left [\frac{561 - 5 + 2 * 1 }{3} + 1\right] \\ &= \left[\frac{561 - 5+2}{3} + 1\right] \\ &= \left[\frac{561 - 3}{3} + 1\right] \\ &= \left[\frac{558}{3} + 1\right] \\ &= \left [186+1 \right] \\ &= 187 \end{aligned}
\begin{aligned} w_{out} & =\left[\frac{w_{in} -\text{kernel\_size[1]}+ 2 * \text{padding[1]}}{\text{stride[1]}} + 1\right] \\&=\left [\frac{799 - 3 + 2 * 1 }{2} + 1\right] \\ &= \left[\frac{799 -3+2}{2} + 1\right] \\ &= \left[\frac{799 - 1}{2} + 1\right] \\ &= \left[\frac{798}{2} + 1\right] \\ &= \left [399+1 \right] \\ &= 400 \end{aligned}
1D, 2D, 3D pooling
In PyTorch, the terms "1D," "2D," and "3D" pooling refer to the number of spatial dimensions in the input that are being reduced by the pooling operation.
1D Pooling is used to reduce the spatial resolution of 1D signals, such as time series or audio signals. In 1D pooling, the input is divided into non-overlapping regions along the time axis, and the values in each region are aggregated into a single output value.
2D Pooling is used to reduce the spatial resolution of 2D images or maps. In 2D pooling, the input is divided into non-overlapping regions along both the row and column axes, and the values in each region are aggregated into a single output value.
3D Pooling is used to reduce the spatial resolution of 3D signals, such as video sequences or volumetric data. In 3D pooling, the input is divided into non-overlapping regions along all three spatial dimensions (height, width, and depth), and the values in each region are aggregated into a single output value.
Similar Reads
How to Apply a 2D Average Pooling in PyTorch?
In this article, we will see how to apply a 2D average pooling in PyTorch. AvgPool2d() method AvgPool2d() method of torch.nn module is used to apply 2D average pooling over an input image composed of several input planes in PyTorch. The shape of the input 2D average pooling layer should be [N, C, H
2 min read
Apply a 2D Convolution Operation in PyTorch
A 2D Convolution operation is a widely used operation in computer vision and deep learning. It is a mathematical operation that applies a filter to an image, producing a filtered output (also called a feature map). In this article, we will look at how to apply a 2D Convolution operation in PyTorch.
8 min read
Data Preprocessing in PyTorch
Data preprocessing is a crucial step in any machine learning pipeline, and PyTorch offers a variety of tools and techniques to help streamline this process. In this article, we will explore the best practices for data preprocessing in PyTorch, focusing on techniques such as data loading, normalizati
5 min read
Displaying a Single Image in PyTorch
Displaying images is a fundamental task in data visualization, especially when working with machine learning frameworks like PyTorch. This article will guide you through the process of displaying a single image using PyTorch, covering various methods and best practices.Table of ContentUnderstanding
3 min read
Apply a 2D Transposed Convolution Operation in PyTorch
Transposed convolution, also known as fractionally-strided convolution, is a technique used in convolutional neural networks (CNNs) for the upsampling layer that increases the spatial resolution of an image. It is similar to a deconvolutional layer. A deconvolutional layer reverses the layer to a st
7 min read
How to Make a grid of Images in PyTorch?
In this article, we are going to see How to Make a grid of Images in PyTorch. we can make a grid of images using the make_grid() function of torchvision.utils package. make_grid() function: The make_grid() function accept 4D tensor with [B, C ,H ,W] shape. where B represents the batch size, C repres
3 min read
Pytorch - Index-based Operation
PyTorch is a python library developed by Facebook to run and train deep learning and machine learning algorithms. Tensor is the fundamental data structure of the machine or deep learning algorithms and to deal with them, we perform several operations, for which PyTorch library offers many functional
7 min read
Python - PyTorch div() method
PyTorch torch.div() method divides every element of the input with a constant and returns a new modified tensor. Syntax: torch.div(inp, other, out=None) Arguments inp: This is input tensor. other: This is a number to be divided to each element of input inp. out: The output tensor. Return: It returns
1 min read
Pooling Layers in R
Pooling layers are part of convolutional neural networks (CNNs). This article explores the concept of pooling layers, their types, and how to implement them in R.Prerequisites: Convolutional Neural Network, Pooling Layers Pooling layers perform down-sampling operations on feature maps, which:Reduce
4 min read
Maximum Flow Problem in Python
The maximum flow problem is a classic optimization problem in network theory, where the goal is to determine the maximum possible flow from a source node to a sink node in a flow network. A flow network is represented as a directed graph with each edge having a capacity, which is the maximum amount
4 min read