Fonction PyTorch nn.MaxPool2d

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

torch.nn.MaxPool2dIl s'agit d'un module de PyTorch pour le max pooling 2D.

La couche de pooling peut réduire la taille spatiale des cartes de caractéristiques, diminuer le calcul et offrir un certain degré d'invariance à la translation.

Définition de fonction

torch.nn.MaxPool2d(kernel_size, stride=None, padding=0, dilation=1, return_indices=False, ceil_mode=False)

Description des paramètres :

  • kernel_size(int ou tuple) : La taille de la fenêtre de pooling.
  • stride(int ou tuple) : Le pas de déplacement de la fenêtre de pooling. Valeur par défaut :kernel_size。
  • padding(int ou tuple) : La taille du padding au bord de l'entrée. Valeur par défaut : 0.
  • dilation(int ou tuple) : L'espacement entre les éléments de la fenêtre. Valeur par défaut : 1.
  • return_indices(bool) : Indique s'il faut renvoyer les indices des valeurs maximales. Utilisé pour MaxUnpool2d. Valeur par défaut : False.
  • ceil_mode(bool) : Indique s'il faut utiliser ceil au lieu de floor pour calculer la taille de sortie. Valeur par défaut : False.

Exemples d'utilisation

Exemple 1 : Utilisation de base

Créer une couche de max pooling :

Exemple

import torch
import torch.nn as nn

# Créer une couche de max pooling : fenêtre 2x2, pas 2
max_pool = nn.MaxPool2d(kernel_size=2, stride=2)

# Créer un tenseur d'entrée
input_tensor = torch.randn(1, 1, 4, 4)
print("Input:n", input_tensor.squeeze().tolist())

# Propagation avant
output = max_pool(input_tensor)

print("nSortie :n", output.squeeze().tolist())
print("nForme de l'entrée :", input_tensor.shape)
print("Forme de sortie :", output.shape)

La sortie est :

输入:
[[-0.4128, 0.2341, -0.9876, 0.4567],
 [ 0.1234, 0.8765, -0.2345, 0.6789],
 [-0.5678, 0.3456, 0.7890, -0.1234],
 [ 0.9012, -0.4567, 0.2345, 0.5678]]

输出:
[[0.8765, 0.6789],
 [0.9012, 0.7890]]

输入形状: torch.Size([1, 1, 4, 4])
输出形状: torch.Size([1, 1, 2, 2])

On peut voir que la valeur maximale dans chaque fenêtre 2x2 est conservée.

Exemple 2 : kernel_size et stride différents

Ajustez les paramètres de pooling :

Exemple

import torch
import torch.nn as nn

# 3x3 pooling, stride 1 (sans chevauchement)
pool3x3 = nn.MaxPool2d(kernel_size=3, stride=1)

# Pooling non carré
pool_rect = nn.MaxPool2d(kernel_size=(2, 3), stride=(2, 3))

input_tensor = torch.randn(1, 1, 6, 9)

print("Forme de l'entrée :", input_tensor.shape)
print("Sortie du pooling 3x3 :", pool3x3(input_tensor).shape)
print("Sortie du pooling rectangulaire :", pool_rect(input_tensor).shape)

Exemple 3 : Utilisation du padding

Le padding des bords peut préserver les informations de bord dans une certaine mesure :

Exemple

import torch
import torch.nn as nn

# Pooling avec padding
pool_padding = nn.MaxPool2d(kernel_size=3, stride=1, padding=1)

input_tensor = torch.randn(1, 1, 4, 4)
output = pool_padding(input_tensor)

print("Forme de l'entrée :", input_tensor.shape)
print("Forme de sortie (avec padding) :", output.shape)

Exemple 4 : Retour des indices

L'utilisation de return_indices peut restaurer les positions dans le décodeur :

Exemple

import torch
import torch.nn as nn

# Créer une couche de pooling qui renvoie les indices
pool_indices = nn.MaxPool2d(kernel_size=2, stride=2, return_indices=True)

input_tensor = torch.randn(1, 1, 4, 4)
output, indices = pool_indices(input_tensor)

print("Forme de sortie :", output.shape)
print("Forme des indices :", indices.shape)
print("Valeurs des indices :", indices.squeeze().tolist())

Exemple 5 : Utilisation dans un CNN

La position de la couche de pooling dans une structure CNN typique :

Exemple

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # Couche convolutionnelle
        self.conv1 = nn.Conv2d(3, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.relu = nn.ReLU()

        # Couche de pooling : la taille est réduite de moitié à chaque fois
        self.pool = nn.MaxPool2d(2, 2)

    def forward(self, x):
        x = self.relu(self.conv1(x))  # 32x32
        x = self.pool(x)              # 16x16

        x = self.relu(self.conv2(x))  # 16x16
        x = self.pool(x)              # 8x8

        return x

model = SimpleCNN()
input_image = torch.randn(1, 3, 32, 32)
output = model(input_image)

print("Forme de l'entrée :", input_image.shape)
print("Forme de sortie :", output.shape)

Pooling maximal vs Pooling moyen

Type Formule Fonctionnalités Cas d'utilisation
MaxPool2d max(region) Conserve les caractéristiques saillantes et est plus robuste au bruit Classification d'images, détection d'objets (couramment utilisées)
AvgPool2d mean(region) Lisse les caractéristiques et préserve les informations d'arrière-plan Pooling moyen global, extraction de caractéristiques

FAQ

Q1 : Peut-on supprimer la couche de pooling ?

Les réseaux modernes tels que ResNet et DenseNet ont tendance à utiliser des convolutions avec un pas plus petit au lieu du pooling, mais le pooling est encore couramment utilisé pour un sous-échantillonnage rapide.

Q2 : Quelle est la relation entre stride et kernel_size ?

Lorsque stride = kernel_size, les fenêtres de pooling ne se chevauchent pas ; lorsque stride < kernel_size, les fenêtres de pooling se chevauchent.

Cas d'utilisation

nn.MaxPool2dLes principaux scénarios d'application incluent :

  • Réseaux de classification d'images: Réduire progressivement la résolution et extraire des caractéristiques de haut niveau
  • Détection d'objets: Préserver les positions des caractéristiques saillantes
  • Réduire le calcul: Réduire la taille des cartes de caractéristiques
  • Augmenter le champ récepteur: Permettre aux couches suivantes de voir une plus grande gamme de caractéristiques

PyTorch torch.nn 参考手册Manuel de référence torch.nn de PyTorch

Autres extensions