PyTorch torch.nn.BatchNorm2d-Funktion

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

torch.nn.BatchNorm2dEs ist ein Modul in PyTorch für zweidimensionale Batch-Normalisierung.

Batch-Normalisierung beschleunigt das Training und stabilisiert die Konvergenz, indem sie die Eingabe einer Schicht normalisiert, und ist eine der am häufigsten verwendeten Techniken in modernen tiefen neuronalen Netzen.

Funktionsdefinition

torch.nn.BatchNorm2d(num_features, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)

Parameterbeschreibung:

  • num_features(int): Anzahl der Eingangskanäle C.
  • eps(float): Wert, der dem Nenner für numerische Stabilität hinzugefügt wird. Standard ist 1e-5.
  • momentum(float): Wird zur Berechnung des laufenden Mittelwerts und der laufenden Varianz verwendet. Standardwert ist 0.1.
  • affine(bool): Ob lernbare affine Parameter (gamma und beta) verwendet werden sollen. Standardwert ist True.
  • track_running_stats(bool): Ob laufende Statistiken verfolgt werden sollen. Standardwert ist True.

Attribute:

  • weight(Tensor): Lernbarer Skalierungsparameter gamma, Form (num_features,).
  • bias(Tensor): Lernbarer Verschiebungsparameter beta, Form (num_features,).
  • running_mean(Tensor): Laufender Mittelwert, wird während des Trainings nicht aktualisiert.
  • running_var(Tensor): Laufende Varianz, wird während des Trainings nicht aktualisiert.

Mathematisches Prinzip

Batch-Normalisierung normalisiert jeden Kanal unabhängig:

y = (x - E[x]) / sqrt(Var[x] + eps) * gamma + beta

Hierbei sind gamma und beta lernbare Parameter, die es dem Netzwerk ermöglichen, seine Ausdrucksfähigkeit wiederherzustellen.

Anwendungsbeispiele

Beispiel 1: Grundlegende Verwendung

Verwendung der Batch-Normalisierung nach einer Faltungsschicht:

Beispiel

import torch
import torch.nn as nn

# Eine Batch-Normalisierungsschicht erstellen: 32 Kanäle
bn = nn.BatchNorm2d(num_features=32)

# Parameter ausgeben
print("Gamma (Gewicht):", bn.weight.shape)
print("Beta (Bias):", bn.bias.shape)
print("running_mean:", bn.running_mean.shape)
print("running_var:", bn.running_var.shape)

# Eingabe erstellen: Batch=4, Kanäle=32, Höhe=16, Breite=16
input_tensor = torch.randn(4, 32, 16, 16)

# Vorwärtsdurchlauf
output = bn(input_tensor)

print("Eingabe-Mittelwert (pro Kanal):", input_tensor.mean(dim=(0, 2, 3))[:5].tolist())
print("Ausgabe-Mittelwert (pro Kanal):", output.mean(dim=(0, 2, 3))[:5].tolist())
print("Eingabe-Form:", input_tensor.shape)
print("Ausgabeform:", output.shape)

Das Ausgabeergebnis ist:

gamma (weight): torch.Size([32])
beta (bias): torch.Size([32])
running_mean: torch.Size([32])
running_var: torch.Size([32])

输入均值 (按通道): tensor([ 0.0234,  0.0456, -0.0123, -0.0345,  0.0567])
输出均值 (按通道): tensor([ 0.,  0.,  0.,  0.,  0.])

输入形状: torch.Size([4, 32, 16, 16])
输出形状: torch.Size([4, 32, 16, 16])

Während des Trainings wird die Ausgabe auf Mittelwert 0 und Varianz 1 normalisiert (gefolgt von Gamma- und Beta-Transformation).

Beispiel 2: Trainings- vs. Evaluierungsmodus

Batch-Normalisierung verhält sich während des Trainings und der Evaluierung unterschiedlich:

Beispiel

import torch
import torch.nn as nn

bn = nn.BatchNorm2d(num_features=16)

# Trainingsmodus
bn.train()
print("Trainingsmodus - erfordert grad:", bn.weight.requires_grad)

# Training simulieren
for _ in range(10):
    x = torch.randn(8, 16, 8, 8)
    output = bn(x)

print("Erste 5 running_mean nach dem Training:", bn.running_mean[:5].tolist())

# Evaluierungsmodus
bn.eval()
print("nEvaluierungsmodus - erfordert grad:", bn.weight.requires_grad)

# Laufende Statistiken während der Evaluierung verwenden
x = torch.randn(4, 16, 8, 8)
output = bn(x)
print("Ausgabeform während der Evaluierung:", output.shape)

Beispiel 3: Vollständiges CNN-Beispiel

Typische CNN-Struktur mit Batch-Normalisierung:

Beispiel

import torch
import torch.nn as nn

class BNConvNet(nn.Module):
    def __init__(self, num_classes=10):
        super(BNConvNet, self).__init__()
        # Faltung + Batch-Normalisierung + Aktivierung + Pooling
        self.block1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.BatchNorm2d(32),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)  # 32 -> 16
        )
        self.block2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.BatchNorm2d(64),
            nn.ReLU(),
            nn.MaxPool2d(2, 2)  # 16 -> 8
        )
        # Globales Average-Pooling
        self.gap = nn.AdaptiveAvgPool2d(1)
        self.classifier = nn.Linear(64, num_classes)

    def forward(self, x):
        x = self.block1(x)
        x = self.block2(x)
        x = self.gap(x)
        x = x.view(x.size(0), -1)
        x = self.classifier(x)
        return x

model = BNConvNet()
input_image = torch.randn(2, 3, 32, 32)
output = model(input_image)

print("Eingabeform:", input_image.shape)
print("Ausgabeform:", output.shape)

# Parameter der ersten BN-Schicht ausgeben
print("Gamma der ersten BN-Schicht:", model.block1[1].weight[:5].tolist())
print("Beta der ersten BN-Schicht:", model.block1[1].bias[:5].tolist())

Beispiel 4: Ohne Verwendung affiner Parameter

Lernbare Parameter deaktivieren:

Beispiel

import torch
import torch.nn as nn

# Batch-Normalisierung ohne lernbare Parameter
bn_no_affine = nn.BatchNorm2d(16, affine=False)

print("Hat Gewicht:", bn_no_affine.weight is not Keine)
print("Hat Bias:", bn_no_affine.bias is not Keine)

# Es führt weiterhin eine Normalisierung durch
x = torch.randn(4, 16, 8, 8)
output = bn_no_affine(x)
print("nAusgabeform:", output.shape)

Häufige Fragen

Q1: Sollte Batch-Normalisierung vor oder nach ReLU platziert werden?

Beide Ansätze sind wirksam. In der Originalarbeit wird sie nach der Faltung und vor der Aktivierung platziert; in der Praxis wird sie auch oft nach der Aktivierung platziert.

Q2: Was tun, wenn es mit kleinen Batch-Größen nicht gut funktioniert?

  • Verwenden SieGroupNormanstelle von
  • Verwenden SieLayerNorm
  • Batch-Größe erhöhen
  • Momentum-Parameter anpassen

Q3: Warum während der Evaluierung in den Eval-Modus wechseln?

Während des Trainings werden Batch-Statistiken verwendet; während der Evaluierung werden laufende Statistiken verwendet. Wenn man vergisst umzuschalten, führt dies zu inkonsistenten Ausgaben.

Anwendungsfälle

nn.BatchNorm2dZu den wichtigsten Anwendungsszenarien gehören:

  • Training beschleunigen: Ermöglicht die Verwendung einer größeren Lernrate
  • Konvergenz stabilisieren: Reduziert die interne Kovariatenverschiebung
  • Regularisierung: Bietet einen leichten Regularisierungseffekt
  • Bildklassifikation: Wird von fast allen modernen CNNs verwendet

Hinweis: Die Batch-Normalisierung erfordert während des Trainings eine ausreichende Batch-Größe; kleine Batches können zu instabilen Statistiken führen.

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

Andere Erweiterungen