Long Short-Term Memory (LSTM)

🧠 ¿Por qué necesitamos LSTM?

En el módulo de Fundamentos de RNN vimos que la RNN vanilla sufre un problema fundamental: el vanishing gradient. Al propagar gradientes hacia atrás a través de muchos pasos temporales, se produce un producto de Jacobianas:

Cuando \(\|W_{hh}\| < 1\), este producto decae exponencialmente — los gradientes se desvanecen. En la práctica, esto significa que la RNN solo puede «recordar» información de los últimos ~10-20 pasos temporales.

📝 La analogía: tomar apuntes

Imagina que estás en una clase magistral de 2 horas. Si solo confías en tu memoria de trabajo (la RNN vanilla), al final de la clase habrás olvidado la mayoría de los detalles del principio. Pero si tomas apuntes — un soporte externo donde puedes escribir, tachar y consultar selectivamente — puedes retener la información importante durante toda la sesión.

El LSTM implementa exactamente esta idea: además del hidden state \(h_t\) (la «memoria de trabajo»), introduce un cell state \(C_t\) (los «apuntes»), que es un canal de información separado controlado por puertas (gates) que deciden qué información escribir, mantener y borrar.

📜 Breve historia del LSTM

El Long Short-Term Memory fue propuesto por Sepp Hochreiter y Jürgen Schmidhuber en 1997, precisamente para resolver el problema del vanishing gradient que Hochreiter había identificado formalmente en su tesis doctoral de 1991.

La idea central del LSTM es elegantemente simple: en lugar de forzar toda la información a fluir a través de un único vector \(h_t\) con una función de activación que comprime continuamente los valores, crear un camino directo (highway) para que la información pueda fluir sin ser transformada — y usar puertas aprendibles para controlar qué información fluye por ese camino.

🛤️ El Cell State: la cinta transportadora

La innovación central del LSTM es el cell state \(C_t\) — un vector que recorre toda la secuencia como una cinta transportadora. A diferencia del hidden state \(h_t\), que se transforma con una función de activación no lineal en cada paso, el cell state fluye a través del tiempo con solo operaciones lineales: multiplicaciones y sumas elemento a elemento.

🚪 Las tres puertas del LSTM

El LSTM controla el flujo de información a través de tres puertas (gates), cada una implementada como una capa sigmoide seguida de una multiplicación elemento a elemento. La sigmoide produce valores entre 0 y 1 que actúan como «reguladores»: 0 = cerrar completamente, 1 = abrir completamente.

🔬 Anatomía de una celda LSTM

Veamos el diagrama completo de una celda LSTM. Cada paso temporal recibe tres entradas (\(x_t\), \(h_{t-1}\), \(C_{t-1}\)) y produce dos salidas (\(h_t\), \(C_t\)):

Paso a paso: flujo de datos en una celda LSTM

🎛️ Explorador interactivo de gates

Usa el widget para visualizar cómo los valores de las puertas afectan al cell state y la salida. Ajusta los controles y observa el flujo de información:

📐 Ecuaciones del LSTM

Formalicemos las operaciones de la celda LSTM. En cada paso temporal \(t\), se computa el siguiente conjunto de ecuaciones. La entrada es la concatenación \([h_{t-1}, x_t]\):

Donde \(\sigma\) es la función sigmoide, \(\odot\) denota multiplicación elemento a elemento (Hadamard product), y \([h_{t-1}, x_t]\) es la concatenación de los dos vectores.

📏 Dimensiones y parámetros

Sea \(d_x\) la dimensión de la entrada y \(d_h\) la dimensión del hidden state (que es la misma que la del cell state). Cada puerta tiene su propia matriz de pesos y bias:

Conteo total de parámetros

El LSTM tiene 4 conjuntos idénticos de pesos (uno para cada gate + candidato), frente a 1 solo conjunto en la RNN vanilla:

📈 ¿Por qué el LSTM resuelve el vanishing gradient?

El secreto está en la derivada del cell state. Al calcular \(\frac{\partial C_t}{\partial C_{t-1}}\):

Si la forget gate \(f_t \approx 1\), entonces \(\frac{\partial C_t}{\partial C_{t-1}} \approx I\) (la identidad). Esto significa que el gradiente puede fluir sin atenuación a través de muchos pasos temporales, similar a una conexión residual (skip connection):

⚙️ Truco práctico: inicialización del forget bias

Un detalle práctico importante: al inicializar un LSTM, se recomienda inicializar el bias de la forget gate a un valor positivo (típicamente 1.0 o 2.0). ¿Por qué?

• Si \(b_f\) empieza en 0, \(f_t = \sigma(0) = 0.5\) → la celda «medio olvida» desde el principio, antes de aprender nada.
• Con \(b_f = 1\), \(f_t = \sigma(1) \approx 0.73\) → la celda empieza manteniendo más información, y gradualmente aprende qué olvidar.

# PyTorch: inicializar forget bias a 1.0
import torch.nn as nn

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

# El bias del LSTM en PyTorch se almacena como:
# bias_ih: [b_i, b_f, b_g, b_o] concatenados
# bias_hh: [b_i, b_f, b_g, b_o] concatenados
# Cada uno tiene tamaño hidden_size

for name, param in lstm.named_parameters():
    if 'bias' in name:
        n = param.size(0)
        # El forget gate es el segundo cuarto del bias
        start = n // 4
        end = n // 2
        param.data[start:end].fill_(1.0)
        print(f"{name}: forget bias → 1.0")

# TensorFlow: LSTM tiene unit_forget_bias=True por defecto
import tensorflow as tf

# Por defecto, TF inicializa b_f = 1.0
lstm = tf.keras.layers.LSTM(
    units=256,
    unit_forget_bias=True,   # ← True por defecto
    return_sequences=True
)

# Si quieres desactivarlo (no recomendado):
# lstm = tf.keras.layers.LSTM(256, unit_forget_bias=False)

🔥 LSTM en PyTorch

PyTorch ofrece dos interfaces para LSTM: nn.LSTM (procesa secuencias completas y soporta stacking/bidireccionalidad) y nn.LSTMCell (procesa un solo paso temporal, más control manual).

import torch
import torch.nn as nn

class LSTMClassifier(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, num_classes,
                 num_layers=2, dropout=0.3, bidirectional=True):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim, padding_idx=0)
        self.lstm = nn.LSTM(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,        # entrada: (batch, seq, features)
            dropout=dropout,         # dropout entre capas (no en la última)
            bidirectional=bidirectional
        )
        # Si es bidireccional, la salida tiene 2 * hidden_dim
        direction_factor = 2 if bidirectional else 1
        self.fc = nn.Linear(hidden_dim * direction_factor, num_classes)
        self.dropout = nn.Dropout(dropout)

    def forward(self, x):
        # x: (batch, seq_len) — índices de tokens
        embedded = self.dropout(self.embedding(x))  # (batch, seq, embed_dim)

        # output: (batch, seq, hidden*directions)
        # h_n: (layers*directions, batch, hidden) — último hidden state
        # c_n: (layers*directions, batch, hidden) — último cell state
        output, (h_n, c_n) = self.lstm(embedded)

        # Usar el último hidden state de ambas direcciones
        if self.lstm.bidirectional:
            # Concatenar forward y backward del último layer
            h_final = torch.cat([h_n[-2], h_n[-1]], dim=1)
        else:
            h_final = h_n[-1]

        logits = self.fc(self.dropout(h_final))
        return logits

# Ejemplo de uso
model = LSTMClassifier(
    vocab_size=10000, embed_dim=128,
    hidden_dim=256, num_classes=5
)
x = torch.randint(0, 10000, (32, 50))  # batch=32, seq_len=50
logits = model(x)  # (32, 5)
print(f"Salida: {logits.shape}")  # torch.Size([32, 5])

import torch
import torch.nn as nn

class ManualLSTM(nn.Module):
    """LSTM paso a paso con LSTMCell para máximo control."""
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.cell = nn.LSTMCell(input_dim, hidden_dim)

    def forward(self, x):
        # x: (batch, seq_len, input_dim)
        batch, seq_len, _ = x.shape
        h = torch.zeros(batch, self.hidden_dim, device=x.device)
        c = torch.zeros(batch, self.hidden_dim, device=x.device)

        outputs = []
        for t in range(seq_len):
            h, c = self.cell(x[:, t, :], (h, c))
            outputs.append(h)
            # Aquí puedes inspeccionar h, c en cada paso
            # o aplicar lógica condicional

        return torch.stack(outputs, dim=1), (h, c)

# Ejemplo: inspeccionar el cell state en cada paso
model = ManualLSTM(input_dim=64, hidden_dim=128)
x = torch.randn(1, 10, 64)  # 1 secuencia de 10 pasos
outputs, (h_final, c_final) = model(x)
print(f"Cell state final — norma: {c_final.norm():.4f}")
print(f"Cell state final — rango: [{c_final.min():.3f}, {c_final.max():.3f}]")

🟧 LSTM en TensorFlow/Keras

import tensorflow as tf

def build_lstm_model(vocab_size=10000, embed_dim=128, hidden_dim=256,
                     max_len=200, num_classes=2):
    model = tf.keras.Sequential([
        # Embedding
        tf.keras.layers.Embedding(vocab_size, embed_dim,
                                  input_length=max_len),
        tf.keras.layers.SpatialDropout1D(0.2),

        # LSTM bidireccional stacked (2 capas)
        tf.keras.layers.Bidirectional(
            tf.keras.layers.LSTM(hidden_dim, return_sequences=True,
                                 dropout=0.2, recurrent_dropout=0.2)
        ),
        tf.keras.layers.Bidirectional(
            tf.keras.layers.LSTM(hidden_dim // 2,
                                 dropout=0.2, recurrent_dropout=0.2)
            # return_sequences=False → solo el último hidden state
        ),

        # Clasificación
        tf.keras.layers.Dense(64, activation='relu'),
        tf.keras.layers.Dropout(0.3),
        tf.keras.layers.Dense(num_classes, activation='softmax')
    ])

    model.compile(
        optimizer='adam',
        loss='sparse_categorical_crossentropy',
        metrics=['accuracy']
    )
    return model

model = build_lstm_model()
model.summary()

import tensorflow as tf
import numpy as np

def build_time_series_lstm(seq_len=60, n_features=1, hidden_dim=64):
    """LSTM para predicción de series temporales (e.g., precios)."""
    model = tf.keras.Sequential([
        tf.keras.layers.LSTM(
            hidden_dim, return_sequences=True,
            input_shape=(seq_len, n_features)
        ),
        tf.keras.layers.LSTM(hidden_dim // 2),
        tf.keras.layers.Dense(32, activation='relu'),
        tf.keras.layers.Dense(1)  # Predicción del siguiente valor
    ])

    model.compile(optimizer='adam', loss='mse', metrics=['mae'])
    return model

# Ejemplo: predecir el siguiente valor de una serie sintética
np.random.seed(42)
t = np.linspace(0, 20*np.pi, 2000)
series = np.sin(t) + 0.3 * np.sin(3*t) + 0.1 * np.random.randn(len(t))

# Crear ventanas deslizantes
SEQ_LEN = 60
X = np.array([series[i:i+SEQ_LEN] for i in range(len(series)-SEQ_LEN-1)])
y = series[SEQ_LEN+1:]
X = X.reshape(-1, SEQ_LEN, 1)

model = build_time_series_lstm(seq_len=SEQ_LEN)
model.fit(X[:1500], y[:1500], epochs=10, batch_size=32,
          validation_data=(X[1500:], y[1500:]))

🔀 Variantes del LSTM

Desde la publicación original, se han propuesto varias variantes del LSTM. Un estudio exhaustivo de Greff et al. (2016), «LSTM: A Search Space Odyssey», evaluó las variantes más populares:

🌍 Aplicaciones del LSTM en el mundo real

El LSTM dominó el procesamiento de secuencias desde ~2013 hasta ~2018, antes de que los Transformers tomaran el relevo. Algunas de sus aplicaciones más impactantes:

🔮 La «neurona sintiente»: emergencia en LSTMs

En abril de 2017, investigadores de OpenAI publicaron un resultado fascinante que anticipó muchos de los fenómenos que luego veríamos en los grandes modelos de lenguaje: un LSTM entrenado de forma completamente no supervisada para predecir el siguiente carácter en textos de reseñas de Amazon desarrolló espontáneamente una neurona que codificaba el sentimiento del texto.

¿Por qué es esto tan importante?

Este resultado de 2017 fue uno de los primeros ejemplos claros de emergencia en modelos de lenguaje — capacidades que surgen de manera no programada durante el entrenamiento no supervisado:

🏛️ El legado del LSTM

Aunque los Transformers han reemplazado al LSTM como arquitectura dominante en NLP desde ~2018, el LSTM sigue siendo relevante y ampliamente utilizado: