Función PyTorch torch.nn.LSTM

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

torch.nn.LSTMEs el módulo de PyTorch para redes de memoria a largo plazo.

LSTM es un tipo especial de red neuronal recurrente que puede aprender dependencias a largo plazo y se usa ampliamente en tareas de modelado de secuencias.

Definición de la función

torch.nn.LSTM(input_size, hidden_size, num_layers=1, bias=True, batch_first=True, dropout=0, bidirectional=False)

Descripción de parámetros:

  • input_size(int): Dimensión de las características de entrada.
  • hidden_size(int): Dimensión del estado oculto.
  • num_layers(int): Número de capas LSTM. El valor predeterminado es 1.
  • bias(bool): Si se utiliza sesgo. El valor predeterminado es True.
  • batch_first(bool): Si es True, las formas de entrada y salida son (batch, seq, feature). El valor predeterminado es True.
  • dropout(float): Dropout utilizado en capas que no son la última. El valor predeterminado es 0.
  • bidirectional(bool): Si se usa LSTM bidireccional. El valor predeterminado es False.

Entrada y salida

Entrada:

  • input: Tensor de forma (batch, seq_len, input_size)
  • h_0: Estado oculto inicial, de forma (num_layers * num_directions, batch, hidden_size)
  • c_0: Estado de celda inicial, de forma (num_layers * num_directions, batch, hidden_size)

Salida:

  • output: Salida de la última capa oculta, de forma (batch, seq_len, num_directions * hidden_size)
  • h_n: Último estado oculto de todas las capas
  • c_n: Último estado de celda de todas las capas

Ejemplos de uso

Ejemplo 1: Uso básico

Crear y usar LSTM:

Ejemplo

import torch
import torch.nn as nn

# Crear LSTM: dimensión de entrada 256, dimensión oculta 512, 2 capas
lstm = nn.LSTM(input_size=256, hidden_size=512, num_layers=2, batch_first=True)

# Crear entrada: batch=4, longitud de secuencia=10, dimensión de entrada=256
input_tensor = torch.randn(4, 10, 256)

# Propagación hacia adelante
output, (h_n, c_n) = lstm(input_tensor)

print("Forma de entrada:", input_tensor.shape)
print("Forma de salida:", output.shape)      # (4, 10, 512)
print("Forma del estado oculto:", h_n.shape)     # (2, 4, 512)
print("Forma del estado de celda:", c_n.shape)     # (2, 4, 512)

Ejemplo 2: LSTM bidireccional

Usar LSTM bidireccional para capturar contexto bidireccional:

Ejemplo

import torch
import torch.nn as nn

# LSTM bidireccional
bilstm = nn.LSTM(input_size=256, hidden_size=256, num_layers=2, batch_first=True, bidirectional=True)

input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = bilstm(input_tensor)

print("Forma de salida del LSTM bidireccional:", output.shape)   # (4, 10, 512) = 256*2
print("Forma del estado oculto:", h_n.shape)            # (4, 4, 256) = 2 capas * 2 direcciones
print("Estado oculto de la última capa:", h_n[-2:, :, :].shape)  # Dirección hacia adelante y hacia atrás

Ejemplo 3: Inicializar el estado oculto

Inicializar manualmente el estado oculto:

Ejemplo

import torch
import torch.nn as nn

lstm = nn.LSTM(input_size=256, hidden_size=512, batch_first=True)

# Crear manualmente el estado oculto inicial
batch_size = 4
num_layers = 2
hidden_size = 512

h_0 = torch.zeros(num_layers, batch_size, hidden_size)
c_0 = torch.zeros(num_layers, batch_size, hidden_size)

# Pasar el estado inicial
input_tensor = torch.randn(4, 10, 256)
output, (h_n, c_n) = lstm(input_tensor, (h_0, c_0))

print("Completado usando estado inicial personalizado")
print("Forma de salida:", output.shape)

Ejemplo 4: Modelo completo de clasificación de sentimientos

Clasificación de texto basada en LSTM:

Ejemplo

import torch
import torch.nn as nn

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes=2):
        super(LSTMClassifier, self).__init__()
        # Capa de embedding
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        # Capa LSTM
        self.lstm = nn.LSTM(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=2,
            batch_first=True,
            bidirectional=True,
            dropout=0.3
        )
        # Capa de clasificación totalmente conectada
        self.fc = nn.Linear(hidden_dim * 2, num_classes)

    def forward(self, x):
        # x: (batch, seq_len)
        embedded = self.embedding(x)  # (batch, seq_len, embed_dim)

        # Salida del LSTM
        output, (hidden, cell) = self.lstm(embedded)

        # Concatenar el estado oculto de la última capa bidireccional
        # hidden: (4, batch, hidden_dim) - 2 capas * 2 direcciones
        hidden = torch.cat([hidden[-2], hidden[-1]], dim=1)  # (batch, hidden_dim*2)

        # Clasificación
        logits = self.fc(hidden)
        return logits

# Instanciar el modelo
vocab_size = 10000
model = LSTMClassifier(vocab_size=vocab_size, embed_dim=128, hidden_dim=128, num_classes=2)

# Entrada de prueba: batch=8, longitud de secuencia=50
input_ids = torch.randint(1, vocab_size, (8, 50))
output = model(input_ids)

print("Estructura del modelo:")
print(model)
print("Forma de entrada:", input_ids.shape)
print("Forma de salida:", output.shape)  # (8, 2)

Ejemplo 5: LSTM apilado de múltiples capas

Red LSTM profunda:

Ejemplo

import torch
import torch.nn as nn

# LSTM apilado de 4 capas, con dropout
deep_lstm = nn.LSTM(
    input_size=256,
    hidden_size=512,
    num_layers=4,
    batch_first=True,
    dropout=0.4  # Dropout entre cada capa
)

input_tensor = torch.randn(2, 20, 256)
output, (h_n, c_n) = deep_lstm(input_tensor)

print("Forma de salida del LSTM de 4 capas:", output.shape)
print("Forma del estado oculto (4 capas):", h_n.shape)
print("Forma del estado de celda (4 capas):", c_n.shape)

Concepto de compuertas LSTM

LSTM controla el flujo de información a través de tres compuertas:

  • Compuerta de olvido: Determina cuánta información del momento anterior se conserva.
  • Compuerta de entrada: Determina cuánta información nueva se añade.
  • Compuerta de salida: Determina cuánta información se emite.

Preguntas frecuentes

Q1: ¿Qué significa batch_first=True?

La primera dimensión de los tensores de entrada y salida es batch_size. Si es False, la primera dimensión es la longitud de la secuencia.

Q2: ¿Cuándo usar LSTM bidireccional?

Tareas que requieren contexto bidireccional, como el etiquetado de secuencias y el análisis de sentimientos. La traducción automática suele usar la arquitectura encoder-decoder.

Q3: ¿Cómo elegir el tamaño de la capa oculta?

Normalmente 128-512, ajustándolo según la complejidad de la tarea y la cantidad de datos. Demasiado pequeño provoca subajuste (underfitting), demasiado grande provoca sobreajuste (overfitting).

Casos de uso

nn.LSTMLos principales escenarios de aplicación incluyen:

  • Procesamiento del lenguaje natural: Clasificación de texto, reconocimiento de entidades nombradas
  • Predicción de series temporales: Predicción de acciones, reconocimiento de voz
  • Tareas de secuencia a secuencia: Traducción automática, generación de texto

Sugerencia: al usar bidirectional=True, la dimensión de salida se convierte en hidden_size * 2.

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

Otras extensiones