Función PyTorch torch.nn.GELU

PyTorch torch.nn 参考手册Manual de referencia de PyTorch torch.nn

torch.nn.GELUEs la función de activación de Unidad Lineal de Error Gaussiano (Gaussian Error Linear Unit, GELU) en PyTorch.

Es la función de activación predeterminada de la arquitectura Transformer y, en comparación con ReLU, ofrece un mejor rendimiento y gradientes más suaves.

Definición de la función

torch.nn.GELU(approximate='none')

Descripción de parámetros:

  • approximate(str): algoritmo de aproximación. Opcional'none'、'tanh'. Por defecto es'none'。

Fundamento matemático

La fórmula matemática de GELU:

GELU(x) = x * Φ(x)

donde Φ(x) es la función de distribución acumulativa (CDF) de la distribución normal estándar.

Cuando se usa la aproximación tanh:

GELU(x) ≈ 0.5x * (1 + tanh(√(2/π) * (x + 0.044715 * x³)))

Ejemplo de uso

Ejemplo 1: Uso básico

Crear y usar la activación GELU:

Ejemplo

import torch
import torch.nn as nn

# Crear la capa de activación GELU
gelu = nn.GELU()

# Entrada de prueba
x = torch.tensor([-2.0, -1.0, 0.0, 1.0, 2.0])

# Propagación hacia adelante
output = gelu(x)

print("Entrada:", x.tolist())
print("Salida:", output.tolist())
print("Observación: los valores negativos tienen una activación leve (no nula), los valores positivos siguen creciendo")

Ejemplo 2: Comparación de diferentes funciones de activación

Comparar GELU, ReLU, Sigmoid:

Ejemplo

import torch
import torch.nn as nn

x = torch.linspace(-4, 4, 21)

# Diferentes funciones de activación
gelu = nn.GELU()
relu = nn.ReLU()
sigmoid = nn.Sigmoid()
tanh = nn.Tanh()

print("x       GELU      ReLU      Sigmoid   Tanh")
print("-" * 50)
for i in range(0, 21, 3):
    xi = x[i:i+3]
    print(f"{xi[0]:6.2f} {gelu(xi)[0]:8.4f} {relu(xi)[0]:8.4f} {sigmoid(xi)[0]:8.4f} {tanh(xi)[0]:8.4f}")

Ejemplo 3: Uso en Transformer

Capa FFN típica de Transformer:

h2 class="example">Ejemplo
import torch
import torch.nn as nn

class FeedForward(nn.Module):
    def __init__(self, d_model, dim_feedforward=2048, dropout=0.1):
        super(FeedForward, self).__init__()
        self.linear1 = nn.Linear(d_model, dim_feedforward)
        self.dropout = nn.Dropout(dropout)
        self.activation = nn.GELU()
        self.linear2 = nn.Linear(dim_feedforward, d_model)

    def forward(self, x):
        x = self.linear1(x)
        x = self.activation(x)
        x = self.dropout(x)
        x = self.linear2(x)
        return x

# Probar FFN
ffn = FeedForward(d_model=512, dim_feedforward=2048)
x = torch.randn(32, 100, 512)  # (batch, seq, d_model)

output = ffn(x)
print("Forma de entrada:", x.shape)
print("Forma de salida:", output.shape)

Ejemplo 4: Uso de la aproximación tanh

Usar la aproximación tanh para acelerar el cálculo:

Ejemplo

import torch
import torch.nn as nn

# Versión exacta
gelu_exact = nn.GELU(approximate='none')

# Versión de aproximación tanh
gelu_approx = nn.GELU(approximate='tanh')

x = torch.randn(1000)

output_exact = gelu_exact(x)
output_approx = gelu_approx(x)

# Calcular la diferencia
diff = (output_exact - output_approx).abs().max().item()
print(f"Máxima diferencia: {diff:.8f}")

# Comparación de rendimiento
import time

for _ in range(100):
    _ = gelu_exact(x)

start = time.time()
for _ in range(1000):
    _ = gelu_exact(x)
time_exact = time.time() - start

start = time.time()
for _ in range(1000):
    _ = gelu_approx(x)
time_approx = time.time() - start

print(f"Tiempo de la versión exacta: {time_exact:.4f}s")
print(f"Tiempo de la versión aproximada: {time_approx:.4f}s")

Comparación de funciones de activación

Función de activación Características Escenarios de aplicación
nn.GELU Suave, valores negativos no nulos, predeterminada en Transformer Transformer、BERT、GPT
nn.ReLU Simple, activación dispersa, neuronas muertas CNN, aprendizaje profundo general
nn.SiLU Suave, autocompuerta (self-gating) MobileNet、EfficientNet

Preguntas frecuentes

P1: ¿Qué ventajas tiene GELU frente a ReLU?

  • Los valores negativos tienen una activación leve, no se pierde información
  • Los gradientes son más suaves, lo que ayuda al entrenamiento
  • Mejor rendimiento en Transformer

P2: ¿Cuándo usar la versión aproximada?

Cuando se requiere velocidad de inferencia y la precisión no es estricta, la aproximación tanh es más rápida.

P3: ¿Se puede usar GELU en la capa de salida?

Normalmente no se usa en la capa de salida. Para tareas de clasificación se usa Softmax, para tareas de regresión se usa la función identidad.

Escenarios de uso

nn.GELULos principales escenarios de aplicación incluyen:

  • Arquitectura Transformer: modelos como BERT, GPT, etc.
  • Redes neuronales profundas: casos que requieren una activación suave
  • Modelos preentrenados: modelos modernos de NLP

Nota: GELU es la función de activación más utilizada en el campo del NLP actual y es el estándar en Transformer.

PyTorch torch.nn 参考手册Manual de referencia de PyTorch torch.nn

Otras extensiones