PyTorch torch.nn.LayerNorm-Funktion
PyTorch torch.nn Referenzhandbuch
torch.nn.LayerNormist das Layer-Normalisierungsmodul in PyTorch.
Im Gegensatz zur Batch-Normalisierung normalisiert die Layer-Normalisierung entlang der Merkmalsdimension einer einzelnen Stichprobe und ist nicht von der Batch-Größe abhängig.
Funktionsdefinition
torch.nn.LayerNorm(normalized_shape, eps=1e-05, elementwise_affine=True)
Parameterbeschreibung:
normalized_shape(int or list): Die Dimensionen, die normalisiert werden sollen.eps(float): Epsilon für numerische Stabilität. Standard ist 1e-5.elementwise_affine(bool): Ob lernbare Skalierung und Verschiebung verwendet werden sollen. Standard ist True.
Mathematisches Prinzip
Formel für Layer-Normalisierung:
y = (x - E[x]) / sqrt(Var[x] + eps) * gamma + beta
Unterschied zur Batch-Normalisierung: Layer-Normalisierung berechnet den Mittelwert und die Varianz über die letzte Dimension der Merkmale.
Anwendungsbeispiele
Beispiel 1: Grundlegende Verwendung
Layer-Normalisierung auf Merkmale anwenden:
Beispiel
import torch.nn as nn
# Layer-Normalisierung: die letzte Dimension normalisieren
ln = nn.LayerNorm(normalized_shape=10)
# Eingabe: Batch=4, Merkmalsdimension=10
x = torch.randn(4, 10)
# Vorwärtspropagierung
output = ln(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
print("Erste Zeile der ursprünglichen Eingabe:", x[0].tolist())
print("Erste Zeile nach der Normalisierung:", output[0].tolist())
Beispiel 2: Mehrdimensionale Eingabe
Umgang mit 3D- oder 4D-Eingaben:
Beispiel
import torch.nn as nn
# Über Sequenzdimension normalisieren: (batch, seq, features)
ln_seq = nn.LayerNorm(normalized_shape=64)
# 3D-Eingabe
x_3d = torch.randn(2, 10, 64)
output_3d = ln_seq(x_3d)
print("3D-Eingabe:", x_3d.shape, "-> Ausgabe:", output_3d.shape)
# 4D-Eingabe (z. B. Bilder): (batch, height, width, channels)
# LayerNorm normalisiert die letzte Kanal-Dimension
ln_channel = nn.LayerNorm(normalized_shape=128)
x_4d = torch.randn(2, 8, 8, 128)
output_4d = ln_channel(x_4d)
print("4D-Eingabe:", x_4d.shape, "-> Ausgabe:", output_4d.shape)
Beispiel 3: Verwendung in Transformer
Typische LayerNorm-Verwendung:
Beispiel
import torch.nn as nn
class TransformerBlock(nn.Module):
def __init__(self, d_model, nhead):
super(TransformerBlock, self).__init__()
self.self_attn = nn.MultiheadAttention(d_model, nhead, batch_first=True)
self.norm1 = nn.LayerNorm(d_model)
self.norm2 = nn.LayerNorm(d_model)
self.ffn = nn.Sequential(
nn.Linear(d_model, d_model * 4),
nn.GELU(),
nn.Linear(d_model * 4, d_model)
)
def forward(self, x):
# Self-Attention mit Residualverbindung
attn_out, _ = self.self_attn(x, x, x)
x = self.norm1(x + attn_out)
# FFN mit Residualverbindung
ffn_out = self.ffn(x)
x = self.norm2(x + ffn_out)
return x
# Test
block = TransformerBlock(d_model=512, nhead=8)
x = torch.randn(4, 100, 512) # (batch, seq, d_model)
output = block(x)
print("Eingabeform:", x.shape)
print("Ausgabeform:", output.shape)
Beispiel 4: Ohne lernbare Parameter
Reine Normalisierung ohne Skalierung und Verschiebung:
Beispiel
import torch.nn as nn
# Ohne lernbare Parameter
ln = nn.LayerNorm(16, elementwise_affine=False)
x = torch.randn(4, 16)
output = ln(x)
# Keine Gewichte und kein Bias
print("Hat Gewicht:", hasattr(ln, 'weight'))
print("Hat Bias:", hasattr(ln, 'bias'))
print("Ausgabeform:", output.shape)
Vergleich von Normalisierungsmethoden
| Methode | Normalisierungsdimension | Batch-Abhängigkeit | Anwendbare Szenarien |
|---|---|---|---|
BatchNorm |
Batch-Dimension | Ja | CNN, stabiler Batch |
LayerNorm |
Feature-Dimension | nein | Transformer, RNN |
InstanceNorm |
Kanal + räumlich | nein | Stilübertragung |
GroupNorm |
Kanalgruppierung | nein | Szenarien mit kleinen Batches |
Häufig gestellte Fragen
F1: Was ist der Unterschied zwischen LayerNorm und BatchNorm?
LayerNorm hängt nicht von der Batch-Größe ab, was es für Sequenzmodelle und Szenarien geeignet macht, in denen die Batch-Größe stark variiert.
F2: Wie wählt man normalized_shape?
Üblicherweise wählt man die Feature-Dimension, z. B. 768 oder 1024 in BERT.
F3: Warum verwendet Transformer LayerNorm?
Die Eingabesequenzlänge des Transformers ist variabel, und LayerNorm ist stabiler.
Anwendungsfälle
nn.LayerNormZu den wichtigsten Anwendungsszenarien gehören:
- Transformer-Architektur: BERT, GPT usw.
- Rekurrente neuronale Netze: LSTM, GRU
- Verarbeitung von Sequenzen variabler Länge: Batch-Größe ist nicht fest
Tipp: LayerNorm ist eine Standardkomponente von Transformer, platziert nach der Residualverbindung (Post-LN) oder davor (Pre-LN).
Weitere Erweiterungen