Función PyTorch torch.nn.LayerNorm
Manual de referencia de PyTorch torch.nn
torch.nn.LayerNormEs el módulo de normalización de capas en PyTorch.
A diferencia de la normalización por lotes, la normalización de capas normaliza sobre la dimensión de características de una sola muestra y no depende del tamaño del lote (batch size).
Definición de la función
torch.nn.LayerNorm(normalized_shape, eps=1e-05, elementwise_affine=True)
Descripción de parámetros:
normalized_shape(int o list): las dimensiones a normalizar.eps(float): épsilon para la estabilidad numérica. Por defecto es 1e-5.elementwise_affine(bool): si se utilizan escalado y desplazamiento aprendibles. Por defecto es True.
Principio matemático
Fórmula de normalización de capas:
y = (x - E[x]) / sqrt(Var[x] + eps) * gamma + beta
Diferencia con la normalización por lotes: la normalización de capas calcula la media y la varianza en la última dimensión de las características.
Ejemplos de uso
Ejemplo 1: Uso básico
Aplicar normalización de capas a las características:
Ejemplo
import torch.nn as nn
# Normalización de capas: normalizar sobre la última dimensión
ln = nn.LayerNorm(normalized_shape=10)
# Entrada: batch=4, dimensión de características=10
x = torch.randn(4, 10)
# Propagación hacia adelante
output = ln(x)
print("Forma de entrada:", x.shape)
print("Forma de salida:", output.shape)
print("\nPrimera fila de la entrada original:", x[0].tolist())
print("Primera fila después de la normalización:", output[0].tolist())
Ejemplo 2: Entrada multidimensional
Procesar entradas 3D o 4D:
Ejemplo
import torch.nn as nn
# Normalizar sobre la dimensión de secuencia: (batch, seq, features)
ln_seq = nn.LayerNorm(normalized_shape=64)
# Entrada 3D
x_3d = torch.randn(2, 10, 64)
output_3d = ln_seq(x_3d)
print("Entrada 3D:", x_3d.shape, "-> Salida:", output_3d.shape)
# Entrada 4D (como imágenes): (batch, height, width, channels)
# LayerNorm normaliza sobre la última dimensión de canales
ln_channel = nn.LayerNorm(normalized_shape=128)
x_4d = torch.randn(2, 8, 8, 128)
output_4d = ln_channel(x_4d)
print("Entrada 4D:", x_4d.shape, "-> Salida:", output_4d.shape)
Ejemplo 3: Uso en Transformer
Uso típico de LayerNorm:
Ejemplo
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 with residual
attn_out, _ = self.self_attn(x, x, x)
x = self.norm1(x + attn_out)
# FFN with residual
ffn_out = self.ffn(x)
x = self.norm2(x + ffn_out)
return x
# Prueba
block = TransformerBlock(d_model=512, nhead=8)
x = torch.randn(4, 100, 512) # (batch, seq, d_model)
output = block(x)
print("Forma de entrada:", x.shape)
print("Forma de salida:", output.shape)
Ejemplo 4: Sin parámetros aprendibles
Normalización pura sin escalado ni desplazamiento:
Ejemplo
import torch.nn as nn
# Sin parámetros aprendibles
ln = nn.LayerNorm(16, elementwise_affine=False)
x = torch.randn(4, 16)
output = ln(x)
# Sin weight ni bias
print("¿Hay weight?:", hasattr(ln, 'weight'))
print("¿Hay bias?:", hasattr(ln, 'bias'))
print("\nForma de salida:", output.shape)
Comparación de métodos de normalización
| Método | Dimensión de normalización | Dependencia del batch | Escenarios aplicables |
|---|---|---|---|
BatchNorm |
Dimensión del batch | Sí | CNN, batch estable |
LayerNorm |
Dimensión de características | no | Transformer、RNN |
InstanceNorm |
Canales + espacial | no | Transferencia de estilo |
GroupNorm |
Agrupación de canales | no | Escenarios de batch pequeño |
Preguntas frecuentes
Q1: ¿Cuál es la diferencia entre LayerNorm y BatchNorm?
LayerNorm no depende del batch, es adecuado para modelos de secuencia y escenarios donde el batch varía mucho.
Q2: ¿Cómo elegir normalized_shape?
Normalmente se elige la dimensión de características, como 768 o 1024 en BERT.
Q3: ¿Por qué Transformer usa LayerNorm?
La longitud de la secuencia de entrada de Transformer es variable, LayerNorm es más estable.
Escenarios de uso
nn.LayerNormLos principales escenarios de aplicación incluyen:
- Arquitectura Transformer: BERT, GPT, etc.
- Redes neuronales recurrentes: LSTM、GRU
- Procesamiento de secuencias de longitud variable: tamaño de batch no fijo
Consejo: LayerNorm es estándar en Transformer, se coloca después de la conexión residual (Post-LN) o antes (Pre-LN).
Otras extensiones