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 mediante Backpropagation Through Time (BPTT), se produce un producto encadenado 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. Para secuencias más largas, los gradientes que llegan desde pasos lejanos son tan diminutos que los pesos simplemente no se actualizan en la dirección que permitiría capturar esas dependencias a largo plazo. Es un problema que afecta tanto a tanh como a otras funciones de activación saturantes: dado que \(\tanh'(z) \leq 1\), cada factor del producto contribuye a reducir aún más la magnitud del gradiente.

📝 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.

Este principio — crear «atajos» para que el gradiente fluya sin atenuación — resultó ser una de las ideas más influyentes de la historia del deep learning. Las skip connections de los ResNets (He et al., 2015), las highway networks (Srivastava et al., 2015) y, en última instancia, las conexiones residuales que usan los Transformers modernos, comparten este mismo principio fundamental que el LSTM formuló por primera vez en 1997. Si te interesa entender las bases teóricas de las que parte esta arquitectura, puedes revisar el submódulo de Fundamentos de RNN, donde se trata en detalle el problema del vanishing gradient.

🛤️ 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.

Esta distinción es crucial: en una RNN vanilla, la información en \(h_t\) se transforma con \(\tanh(W_{hh} h_{t-1} + W_{xh} x_t + b)\) en cada paso — una multiplicación matricial seguida de una función no lineal saturante. Esto comprime los valores y dificulta la propagación del gradiente. En el LSTM, el cell state \(C_t\) se actualiza con operaciones mucho más suaves: una multiplicación elemento a elemento (para «olvidar» selectivamente) y una suma (para «escribir» nueva información). No hay multiplicación por matrices de pesos ni paso por funciones saturantes en el camino del cell state, lo que permite que la información — y los gradientes — fluyan a lo largo de secuencias mucho más largas.

🚪 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.

Es importante notar que las tres puertas comparten la misma estructura computacional: una transformación afín de la concatenación \([h_{t-1}, x_t]\) seguida de una sigmoide. Lo que las diferencia es únicamente qué matrices de pesos \(W_f, W_i, W_o\) y qué biases \(b_f, b_i, b_o\) utilizan — cada puerta aprende a responder a patrones distintos del contexto. La forget gate aprende a reconocer cuándo un dato almacenado ya no es relevante; la input gate aprende a detectar información nueva que merece ser almacenada; y la output gate aprende a identificar qué parte del conocimiento acumulado es útil para la tarea actual.

El hecho de que todas las puertas usen sigmoide (y no, por ejemplo, una función escalón binaria 0/1) es lo que hace al LSTM diferenciable y, por tanto, entrenable con backpropagation. Las puertas producen valores continuos entre 0 y 1, actuando como «reguladores suaves» del flujo de información. Durante el entrenamiento, la red aprende progresivamente a qué patrones de entrada debe abrirse o cerrarse cada puerta.

🔬 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

Observa cómo los cuatro pasos se ejecutan secuencialmente dentro de un mismo paso temporal, pero los pasos 1 y 2 pueden computarse en paralelo (ambos dependen solo de \([h_{t-1}, x_t]\)). En la implementación real de los frameworks, las matrices de peso de las tres gates y el candidato se concatenan en una sola multiplicación matricial grande, y luego se separa la salida en cuatro partes — esto aprovecha al máximo las operaciones BLAS/cuDNN de las GPUs.

Un detalle que a menudo se pasa por alto: el cell state \(C_t\) tiene la misma dimensión que el hidden state \(h_t\). Ambos son vectores en \(\mathbb{R}^{d_h}\). Sin embargo, sus roles son muy diferentes: \(C_t\) es la «memoria a largo plazo» (protegida por las puertas), mientras que \(h_t\) es una «vista filtrada» de esa memoria que se expone al exterior y se usa como entrada en el siguiente paso temporal. Esta separación de roles es lo que da al LSTM su capacidad única de recordar información durante muchos pasos sin necesariamente exponerla en la salida.

🎛️ 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. Las ecuaciones 1, 2 y 5 computan las tres puertas — todas siguen la misma estructura: una transformación afín seguida de sigmoide. La ecuación 3 genera los valores candidatos que podrían incorporarse al cell state, usando tanh para producir valores en \([-1, 1]\). La ecuación 4 es la actualización central del cell state: primero se olvida selectivamente (multiplicación por \(f_t\)), luego se añade selectivamente (suma del producto de \(i_t\) por \(\tilde{C}_t\)). Finalmente, la ecuación 6 produce la salida filtrando el cell state normalizado a través de la output gate.

Observa que las ecuaciones 1-3 y 5 pueden computarse en paralelo, ya que todas dependen únicamente de \([h_{t-1}, x_t]\). En la práctica, los frameworks de deep learning como PyTorch y TensorFlow concatenan las cuatro matrices de pesos en una sola operación matricial para maximizar la eficiencia:

donde \(W \in \mathbb{R}^{4d_h \times (d_h + d_x)}\) y \(b \in \mathbb{R}^{4d_h}\) se descomponen en 4 bloques tras la multiplicación. Esto permite aprovechar las operaciones matriciales altamente optimizadas de las GPUs modernas.

📏 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. Recordemos la ecuación de actualización: \(C_t = f_t \odot C_{t-1} + i_t \odot \tilde{C}_t\). Al calcular \(\frac{\partial C_t}{\partial C_{t-1}}\), observamos que el primer término es lineal en \(C_{t-1}\) (el segundo término no depende directamente de \(C_{t-1}\) salvo a través de las puertas, que contribuyen con términos de segundo orden generalmente pequeños):

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):

Sin embargo, es importante señalar que el LSTM no resuelve completamente el problema del vanishing gradient — lo mitiga de forma eficaz. Si la forget gate aprende valores consistentemente menores que 1, el gradiente seguirá atenuándose, aunque de forma mucho más controlada que en una RNN vanilla. En la práctica, los LSTMs pueden capturar dependencias de cientos de pasos temporales, pero no de decenas de miles. Para secuencias extremadamente largas, las arquitecturas basadas en mecanismos de atención (como los Transformers) ofrecen una solución más directa al permitir conexiones punto a punto entre cualquier par de posiciones.

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

Un detalle práctico importante que puede marcar una diferencia significativa en el rendimiento: al inicializar un LSTM, se recomienda inicializar el bias de la forget gate a un valor positivo (típicamente 1.0 o 2.0). Este truco fue propuesto por Jozefowicz et al. (2015) en su estudio empírico de arquitecturas recurrentes y se ha convertido en una práctica estándar. ¿Por qué es tan importante?

• Si \(b_f\) empieza en 0, \(f_t = \sigma(0) = 0.5\) → la celda «medio olvida» desde el principio, antes de aprender nada. Esto puede destruir información valiosa en las primeras épocas del entrenamiento.
• Con \(b_f = 1\), \(f_t = \sigma(1) \approx 0.73\) → la celda empieza manteniendo más información, y gradualmente aprende qué olvidar. Esto permite que los gradientes fluyan mejor al inicio del entrenamiento.
• Con \(b_f = 2\), \(f_t = \sigma(2) \approx 0.88\) → aún más conservador. Útil para tareas que requieren dependencias especialmente largas.

# 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). La elección entre ambas depende del nivel de control que necesites: nn.LSTM delega la iteración sobre los pasos temporales al framework (que puede usar kernels cuDNN altamente optimizados), mientras que nn.LSTMCell te permite implementar lógica personalizada en cada paso, como mecanismos de atención custom, teacher forcing con scheduling dinámico, o inspección de los estados intermedios para depuración y visualización.

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 numerosas variantes del LSTM, cada una intentando mejorar algún aspecto de la arquitectura original. Un estudio exhaustivo y riguroso de Greff et al. (2016), «LSTM: A Search Space Odyssey», evaluó sistemáticamente las variantes más populares con más de 5400 experimentos sobre diferentes tareas y conjuntos de datos. Las conclusiones fueron sorprendentes: la mayoría de las modificaciones no aportan mejoras significativas y consistentes sobre el LSTM estándar. Veamos las más relevantes:

La relación entre el LSTM y el GRU (Gated Recurrent Unit, Cho et al., 2014) merece especial atención. El GRU puede verse como una simplificación del LSTM que fusiona el cell state y el hidden state en un solo vector, y combina la forget gate y la input gate en una única «update gate». Con menos parámetros y rendimiento comparable en muchas tareas, el GRU es una alternativa atractiva cuando la eficiencia computacional es prioritaria. Puedes profundizar en esta comparación en el submódulo de GRU.

🌍 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. Durante ese período, prácticamente todos los avances en reconocimiento de voz, traducción automática, modelado de lenguaje y generación de texto se basaron en alguna variante de LSTM. Incluso hoy, muchos sistemas en producción siguen utilizando LSTMs en escenarios donde la eficiencia en memoria y la capacidad de procesamiento en streaming son prioritarias. 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.

Este descubrimiento fue particularmente sorprendente porque contradecía la intuición de la época: se asumía que la predicción de siguiente carácter era una tarea puramente sintáctica, incapaz de capturar propiedades semánticas de alto nivel como el sentimiento. El hecho de que un LSTM de tamaño modesto pudiera desarrollar esta capacidad de forma emergente sugería que los modelos de lenguaje podían aprender representaciones mucho más ricas de lo que se creía — una idea que resultaría profética con la llegada de GPT.

¿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:

La historia del LSTM es también una lección sobre la persistencia científica. Publicado en 1997, fue en gran medida ignorado por la comunidad de investigación durante más de una década. Solo cuando el hardware (GPUs) y los datos (internet) alcanzaron una masa crítica, el LSTM demostró su potencial. Hoy, con la arquitectura Transformer dominando el panorama, el LSTM comparte muchos principios con los modelos más avanzados: la idea de seleccionar información relevante mediante mecanismos aprendibles es exactamente lo que hace el mecanismo de atención, solo que de forma diferente.

Si quieres explorar la evolución natural del LSTM, los siguientes submódulos de esta web te resultarán de interés:

• Fundamentos de RNN — Las bases teóricas sobre las que se construye el LSTM.
• GRU (Gated Recurrent Unit) — La simplificación del LSTM que domina cuando se busca eficiencia.