PyTorch torch.nn.Conv2d Funktion

PyTorch torch.nn 参考手册PyTorch torch.nn Referenzhandbuch

torch.nn.Conv2dEs ist ein Modul in PyTorch für zweidimensionale Faltung und eine Kernkomponente von Convolutional Neural Networks (CNN).

Es extrahiert räumliche Merkmale, indem es erlernbare Faltungskerne auf den Eingabe-Tensor anwendet, und wird häufig in Aufgaben der Bildverarbeitung und Computer Vision eingesetzt.

Funktionsdefinition

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

Parameter:

  • in_channels(int): Anzahl der Eingangskanäle. Zum Beispiel 3 für ein RGB-Bild.
  • out_channels(int): Anzahl der Ausgangskanäle, d. h. die Anzahl der Faltungskerne.
  • kernel_size(int oder Tupel): Größe des Faltungskerns. Kann eine Ganzzahl (quadratisch) oder ein Tupel (Höhe x Breite) sein.
  • stride(int oder Tupel): Die Schrittweite der Bewegung des Faltungskerns. Standardwert ist 1.
  • padding(int oder Tupel): Größe des Paddings an den Rändern der Eingabe. Standardwert ist 0.
  • dilation(int oder Tupel): Abstand zwischen den Elementen des Faltungskerns. Standardwert ist 1 (Standardfaltung).
  • groups(int): Anzahl der Gruppen für gruppierte Faltung. Standardwert ist 1 (Standardfaltung).
  • bias(bool): Ob ein Bias-Term hinzugefügt werden soll. Standard istTrue。
  • padding_mode(str): Padding-Modus. Optional'zeros'、'reflect'、'replicate'、'circular'。

Attribute:

  • weight(Tensor): Lernbare Gewichte mit Form (out_channels, in_channels/groups, kernel_size
  • bias(Tensor): Lernbarer Bias mit Form (out_channels,).

Anwendungsbeispiele

Beispiel 1: Grundlegende Verwendung

Erstellen Sie eine einfache 2D-Faltungsschicht:

Beispiel

import torch
import torch.nn as nn

# Eine Faltungsschicht erstellen: 3 Eingangskanäle, 32 Ausgangskanäle, Kernel 3x3
conv = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3)

# Die Formen von Gewichten und Bias ausgeben
print("Gewichtsform:", conv.weight.shape)  # torch.Size([32, 3, 3, 3])
print("Bias-Form:", conv.bias.shape)    # torch.Size([32])

# Einen Eingabetensor erstellen: batch=1, channels=3, height=32, width=32
input_tensor = torch.randn(1, 3, 32, 32)

# Vorwärtspropagierung
output = conv(input_tensor)

print("Eingabeform:", input_tensor.shape)  # torch.Size([1, 3, 32, 32])
print("Ausgabeform:", output.shape)      # torch.Size([1, 32, 30, 30])

Das Ausgabeergebnis ist:

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

Standardmäßig ist padding=0, daher wird die Ausgabegröße abnehmen. Wenn Sie die Größe beibehalten möchten, können Sie padding hinzufügen.

Beispiel 2: Padding verwenden, um Dimensionen beizubehalten

Durch Hinzufügen von Padding können die Eingabe- und Ausgabegrößen konsistent gehalten werden:

Beispiel

import torch
import torch.nn as nn

# Erstellen einer Faltungsschicht mit Padding: padding=1 behält die Größe
conv_pad = nn.Conv2d(in_channels=3, out_channels=32, kernel_size=3, padding=1)

# Eingabe
input_tensor = torch.randn(1, 3, 32, 32)

# Vorwärtspropagierung
output = conv_pad(input_tensor)

print("Eingabeform:", input_tensor.shape)
print("Ausgabeform:", output.shape)  # 32x32 beibehalten

Das Ausgabeergebnis ist:

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

Beispiel 3: Unterschiedliche Stride und Dilation

Das Anpassen von Schrittweite und Dilatation kann die Ausgabegröße und das rezeptive Feld verändern:

Beispiel

import torch
import torch.nn as nn

# Faltung mit Schrittweite: stride=2 reduziert die Größe
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 -> Ausgabegröße:", output_stride.shape)

# Dilatierte Faltung: dilation=2 vergrößert das rezeptive Feld
conv_dilation = nn.Conv2d(3, 32, kernel_size=3, dilation=2)
output_dilation = conv_dilation(input_tensor)
print("Dilation=2 -> Ausgabegröße:", output_dilation.shape)

Das Ausgabeergebnis ist:

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

Beispiel 4: Gruppierte Faltung

Der Parameter groups kann eine gruppierte Faltung implementieren, die häufig in leichtgewichtigen Netzwerken verwendet wird:

Beispiel

import torch
import torch.nn as nn

# Gruppierte Faltung: groups=2 teilt die Eingabe in 2 Gruppen auf
conv_group = nn.Conv2d(in_channels=4, out_channels=8, kernel_size=3, groups=2)

# Eingabe mit 4 Kanälen
input_tensor = torch.randn(1, 4, 16, 16)

# Vorwärtspropagierung
output = conv_group(input_tensor)

print("Eingabeform:", input_tensor.shape)
print("Ausgabeform:", output.shape)
print("Gewichtsform:", conv_group.weight.shape)  # Die Gewichtsform ist nach der Gruppierung anders

Das Ausgabeergebnis ist:

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

Beispiel 5: Verwendung in neuronalen Netzen

Erstellen Sie ein einfaches Netzwerk zur Erkennung handschriftlicher Ziffern:

Beispiel

import torch
import torch.nn as nn

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

        # Zweiter Faltungsblock
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.bn2 = nn.BatchNorm2d(64)
        self.relu2 = nn.ReLU()

        # Pooling-Schicht
        self.pool = nn.MaxPool2d(2, 2)

        # Vollständig verbundene Schicht
        self.fc = nn.Linear(64 * 7 * 7, num_classes)

    def forward(self, x):
        # Erster Faltungsblock
        x = self.conv1(x)
        x = self.bn1(x)
        x = self.relu1(x)
        x = self.pool(x)

        # Zweiter Faltungsblock
        x = self.conv2(x)
        x = self.bn2(x)
        x = self.relu2(x)
        x = self.pool(x)

        # Abflachen und klassifizieren
        x = x.view(x.size(0), -1)
        x = self.fc(x)
        return x

# Das Modell erstellen
model = SimpleCNN(num_classes=10)

# Testeingabe: batch=4, Graustufenbild 28x28
input_image = torch.randn(4, 1, 28, 28)
output = model(input_image)

print("Eingabeform:", input_image.shape)
print("Ausgabeform:", output.shape)  # torch.Size([4, 10])

Berechnung der Ausgabegröße

Die Formel zur Berechnung der Ausgabegröße einer Faltungsschicht:

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

Häufige Fragen

F1: Wie wählt man die Kernelgröße?

Häufige Kernelgrößen:

  • 1x1: Wird verwendet, um die Anzahl der Kanäle zu ändern und Nichtlinearität hinzuzufügen
  • 3x3: Am häufigsten verwendet, balanciert Parameteranzahl und rezeptives Feld aus
  • 5x5、7x7: Größeres rezeptives Feld, aber größere Anzahl an Parametern

F2: Wie wählt man Padding und Stride?

  • Um die Größe der Feature-Map beizubehalten, verwendepadding = (kernel_size - 1) / 2
  • Für Downsampling verwendestride > 1

Anwendungsfälle

nn.Conv2dEs ist eine der wichtigsten Schichten im Computer Vision. Zu den wichtigsten Anwendungsszenarien gehören:

  • Bildklassifizierung: Bildmerkmale extrahieren, wie VGG, ResNet usw.
  • Objekterkennung: YOLO, Faster R-CNN usw.
  • Semantische Segmentierung: U-Net, FCN usw.
  • Stilübertragung: Künstlerische Bilder generieren

Tipp: In modernen CNNs ist die 3x3-Faltung am häufigsten verwendet. Sie kann ausreichend räumliche Informationen abdecken und gleichzeitig eine relativ kleine Anzahl von Parametern beibehalten.

PyTorch torch.nn 参考手册PyTorch torch.nn Referenzhandbuch

Andere Erweiterungen