Fonction torch.nn.Conv2d de PyTorch

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

torch.nn.Conv2dC'est un module de PyTorch pour la convolution bidimensionnelle, et c'est un composant essentiel des réseaux de neurones convolutifs (CNN).

Il extrait des caractéristiques spatiales en appliquant des noyaux de convolution apprenables au tenseur d'entrée, et est largement utilisé dans le traitement d'images et les tâches de vision par ordinateur.

Définition de fonction

torch.nn.Conv2d(in_channels, out_channels, kernel_size, stride=1, padding=0, dilation=1, groups=1, bias=True, padding_mode='zeros')

Paramètres :

  • in_channels(int) : Nombre de canaux d'entrée. Par exemple, 3 pour une image RGB.
  • out_channels(int) : Nombre de canaux de sortie, c'est-à-dire le nombre de noyaux de convolution.
  • kernel_size(int ou tuple) : Taille du noyau de convolution. Peut être un entier (carré) ou un tuple (hauteur x largeur).
  • stride(int ou tuple) : Le pas de déplacement du noyau de convolution. La valeur par défaut est 1.
  • padding(int ou tuple) : Taille du remplissage (padding) aux bords de l'entrée. La valeur par défaut est 0.
  • dilation(int ou tuple) : Espacement entre les éléments du noyau de convolution. La valeur par défaut est 1 (convolution standard).
  • groups(int) : Nombre de groupes pour la convolution groupée. La valeur par défaut est 1 (convolution standard).
  • bias(bool) : Indique s'il faut ajouter un terme de biais. La valeur par défaut estTrue。
  • padding_mode(str) : Mode de remplissage. Facultatif'zeros'、'reflect'、'replicate'、'circular'。

Attributs :

  • weight(Tensor) : Poids apprenables de forme (out_channels, in_channels/groups, kernel_size
  • bias(Tensor) : Biais apprenable de forme (out_channels).

Exemples d'utilisation

Exemple 1 : Utilisation de base

Créez une couche de convolution 2D simple :

Exemple

import torch
import torch.nn as nn

# Créer une couche de convolution : 3 canaux en entrée, 32 canaux en sortie, noyau 3x3
conv = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)

# Afficher les formes des poids et du biais
print("Forme des poids :", conv.weight.shape)  # torch.Size([32, 3, 3, 3])
print("Forme du biais :", conv.bias.shape)    # torch.Size([32])

# Créer un tenseur d'entrée : batch=1, canaux=3, hauteur=32, largeur=32
input_tensor = torch.randn(1, 3, 32, 32)

# Propagation avant
output = conv(input_tensor)

print("Forme de l'entrée :", input_tensor.shape)  # torch.Size([1, 3, 32, 32])
print("Forme de sortie :", output.shape)      # torch.Size([1, 32, 30, 30])

Le résultat de sortie est:

权重形状: torch.Size([32, 3, 3, 3])
偏置形状: torch.Size([32])
输入形状: torch.Size([1, 3, 32, 32])
输出形状: torch.Size([1, 32, 30, 30])

Par défaut, padding=0, donc la taille de sortie diminuera. Si vous avez besoin de conserver la taille, vous pouvez ajouter du padding.

Exemple 2 : Utilisation du padding pour conserver les dimensions

En ajoutant du padding, les tailles d'entrée et de sortie peuvent être maintenues cohérentes :

Exemple

import torch
import torch.nn as nn

# Créer une couche de convolution avec padding : padding=1 conserve la taille
conv_pad = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1)

# Entrée
input_tensor = torch.randn(1, 3, 32, 32)

# Propagation avant
output = conv_pad(input_tensor)

print("Forme de l'entrée :", input_tensor.shape)
print("Forme de sortie :", output.shape)  # Conserver 32x32

Le résultat de sortie est:

输入形状: torch.Size([1, 3, 32, 32])
输出形状: torch.Size([1, 32, 32, 32])

Exemple 3 : Stride et dilation différents

Le réglage du pas et de la dilatation peut modifier la taille de sortie et le champ récepteur :

Exemple

import torch
import torch.nn as nn

# Convolution avec pas : stride=2 réduit la taille
conv_stride = nn.Conv2d(3, 32, kernel_size=3, stride=2, padding=1)
input_tensor = torch.randn(1, 3, 32, 32)
output_stride = conv_stride(input_tensor)
print("Stride=2 -> Forme de sortie :", output_stride.shape)

# Convolution dilatée : dilation=2 augmente le champ récepteur
conv_dilation = nn.Conv2d(3, 32, kernel_size=3, dilation=2)
output_dilation = conv_dilation(input_tensor)
print("Dilation=2 -> Forme de sortie :", output_dilation.shape)

Le résultat de sortie est:

Stride=2 -> 输出形状: torch.Size([1, 32, 16, 16])
Dilation=2 -> 输出形状: torch.Size([1, 32, 28, 28])

Exemple 4 : Convolution groupée

Le paramètre groups peut implémenter une convolution groupée, couramment utilisée dans les réseaux légers :

Exemple

import torch
import torch.nn as nn

# Convolution groupée : groups=2 divise l'entrée en 2 groupes
conv_group = nn.Conv2d(in_channels=4, out_channels=8, kernel_size=3, groups=2)

# Entrée avec 4 canaux
input_tensor = torch.randn(1, 4, 16, 16)

# Propagation avant
output = conv_group(input_tensor)

print("Forme de l'entrée :", input_tensor.shape)
print("Forme de sortie :", output.shape)
print("Forme du poids :", conv_group.weight.shape)  # La forme du poids est différente après regroupement

Le résultat de sortie est:

输入形状: torch.Size([1, 4, 16, 16])
输出形状: torch.Size([1, 8, 14, 14])
权重形状: torch.Size([8, 2, 3, 3])

Exemple 5 : Utilisation dans les réseaux de neurones

Construisez un réseau simple de reconnaissance de chiffres manuscrits :

Exemple

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        # Premier bloc de convolution
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.bn1 = nn.BatchNorm2d(32)
        self.relu1 = nn.ReLU()

        # Deuxième bloc de convolution
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.relu2 = nn.ReLU()

        # Couche de pooling
        self.pool = nn.MaxPool2d(2, 2)

        # Couche entièrement connectée
        self.fc = nn.Linear(64 * 7 * 7, num_classes)

    def forward(self, x):
        # Premier bloc de convolution
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.pool(x)

        # Deuxième bloc de convolution
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.pool(x)

        # Aplatir et classifier
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# Créer le modèle
model = SimpleCNN(num_classes=10)

# Entrée de test : batch=4, image en niveaux de gris 28x28
input_image = torch.randn(4, 1, 28, 28)
output = model(input_image)

print("Forme de l'entrée :", input_image.shape)
print("Forme de sortie :", output.shape)  # torch.Size([4, 10])

Calcul de la taille de sortie

La formule pour calculer la taille de sortie d'une couche de convolution :

H_out = floor((H_in + 2 * padding[0] - dilation[0] * (kernel_size[0] - 1) - 1) / stride[0]) + 1
W_out = floor((W_in + 2 * padding[1] - dilation[1] * (kernel_size[1] - 1) - 1) / stride[1]) + 1

Questions courantes

Q1 : Comment choisir la taille du noyau ?

Tailles de noyau courantes :

  • 1x1: Utilisé pour changer le nombre de canaux, ajouter de la non-linéarité
  • 3x3: Le plus couramment utilisé, équilibre le nombre de paramètres et le champ récepteur
  • 5x5、7x7: Champ récepteur plus grand, mais nombre de paramètres plus élevé

Q2 : Comment choisir le padding et le pas ?

  • Pour conserver la taille de la carte de caractéristiques, utilisezpadding = (kernel_size - 1) / 2
  • Pour le sous-échantillonnage, utilisezstride > 1

Cas d'utilisation

nn.Conv2dC'est l'une des couches les plus importantes en vision par ordinateur. Les principaux scénarios d'application incluent :

  • Classification d'images: Extraire les caractéristiques d'image, telles que VGG, ResNet, etc.
  • Détection d'objets: YOLO, Faster R-CNN, etc.
  • Segmentation sémantique: U-Net, FCN, etc.
  • Transfert de style: Générer des images artistiques

Astuce : Dans les CNN modernes, la convolution 3x3 est la plus couramment utilisée. Elle peut couvrir suffisamment d'informations spatiales tout en conservant un nombre relativement faible de paramètres.

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

Autres extensions