Arquitecturas Recurrentes: Dinámica, Vanishing Gradients y Gating Mechanisms

El tratamiento de datos secuenciales, donde $x_t$ depende temporalmente de $x_{t-1}$, presenta desafíos que las redes feedforward convencionales no pueden resolver debido a su incapacidad para mantener estado. Las Redes Neuronales Recurrentes (RNN) abordan esto introduciendo ciclos en el grafo computacional, permitiendo la persistencia de información a través del tiempo.

Las arquitecturas basadas en LSTM (Long Short-Term Memory) y GRU (Gated Recurrent Unit) constituyen el estándar industrial (SOTA) para tareas de Sequence-to-Sequence como traducción automática (GNMT), reconocimiento de voz y modelado de lenguaje. Estas variantes solucionan las deficiencias numéricas de las RNNs simples, específicamente la dificultad de aprender dependencias a largo plazo.

Fundamentos matemáticos

La premisa central de una red recurrente es el uso de un estado oculto $h_t$ que actúa como memoria de la secuencia hasta el instante $t$.

RNN Estándar (Vanilla)

En una RNN simple, el estado oculto se actualiza mediante una función de activación no lineal (usualmente tangente hiperbólica):

$$h_t = \tanh(W_{hh} h_{t-1} + W_{xh} x_t + b_h)$$

Donde $W_{hh}$ y $W_{xh}$ son matrices de pesos compartidas a través de todos los pasos temporales. La salida $y_t$ se calcula a partir de este estado:

$$y_t = W_{hy} h_t + b_y$$

El problema crítico aquí es el cálculo del gradiente durante el Backpropagation Through Time (BPTT). La regla de la cadena implica productos sucesivos de matrices de pesos. Si el radio espectral de $W_{hh}$ es menor a 1, los gradientes tienden a cero (vanishing gradient); si es mayor, tienden a infinito (exploding gradient).

LSTM (Long Short-Term Memory)

La arquitectura LSTM (Hochreiter & Schmidhuber, 1997) introduce una celda de memoria $C_t$ separada del estado oculto $h_t$, regulada por compuertas (gates) que deciden qué información olvidar, escribir o leer.

Las ecuaciones fundamentales para un paso $t$ son:

Forget Gate ($f_t$): Decide qué descartar del estado anterior.

$$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$$

Input Gate ($i_t$) y Candidato ($\tilde{C}_t$): Deciden qué nueva información almacenar.

$$i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$$$$\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$$

Update Cell State ($C_t$):

$$C_t = f_t * C_{t-1} + i_t * \tilde{C}_t$$

Output Gate ($o_t$) y Hidden State ($h_t$):

$$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$$$$h_t = o_t * \tanh(C_t)$$

La operación aditiva en la actualización de $C_t$ ($f_t * C_{t-1}$) actúa como una "autopista" para el gradiente, mitigando su desvanecimiento.

El siguiente diagrama ilustra el flujo de datos dentro de una celda LSTM, destacando las tres compuertas (forget, input, output) y la operación aditiva del Cell State que actúa como "autopista del gradiente":

GRU (Gated Recurrent Unit)

Propuesta por Cho et al. (2014), simplifica la LSTM fusionando el estado de celda y el estado oculto, y reduciendo las compuertas a dos: Reset ($r$) y Update ($z$).

$$z_t = \sigma(W_z \cdot [h_{t-1}, x_t])$$$$r_t = \sigma(W_r \cdot [h_{t-1}, x_t])$$$$\tilde{h}_t = \tanh(W \cdot [r_t * h_{t-1}, x_t])$$$$h_t = (1 - z_t) * h_{t-1} + z_t * \tilde{h}_t$$

La arquitectura GRU simplifica el diseño de LSTM fusionando el estado de celda con el hidden state y reduciendo las compuertas a dos (Update y Reset):

Implementación práctica

A continuación, se presenta una implementación funcional utilizando Keras (backend TensorFlow) para un problema de clasificación de secuencias (análisis de sentimiento). Se prioriza la configuración explícita de capas recurrentes.

import numpy as np
from keras.models import Sequential
from keras.layers import Dense, LSTM, GRU, Embedding
from keras.preprocessing import sequence
from keras.datasets import imdb

# 1. Configuración de hiperparámetros
max_features = 20000    # Vocabulario
maxlen = 80             # Longitud de secuencia
batch_size = 32
embedding_dims = 128
hidden_units = 64       # Unidades en el estado oculto

# 2. Carga y preprocesamiento de datos
print('Cargando datos...')
(x_train, y_train), (x_test, y_test) = imdb.load_data(num_words=max_features)

print('Pad sequences (samples x time)')
x_train = sequence.pad_sequences(x_train, maxlen=maxlen)
x_test = sequence.pad_sequences(x_test, maxlen=maxlen)

# 3. Definición del modelo (LSTM)
print('Construyendo modelo...')
model = Sequential()
model.add(Embedding(max_features, embedding_dims))

# Capa Recurrente: Se puede intercambiar por GRU(hidden_units)
# dropout y recurrent_dropout son vitales para regularización en RNNs
model.add(LSTM(hidden_units, dropout=0.2, recurrent_dropout=0.2)) 

model.add(Dense(1, activation='sigmoid'))

# 4. Compilación
# RMSprop o Adam son preferibles a SGD para RNNs
model.compile(loss='binary_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

# 5. Entrenamiento
print('Entrenando...')
model.fit(x_train, y_train,
          batch_size=batch_size,
          epochs=5,
          validation_data=(x_test, y_test))

Análisis de comportamiento

Estabilidad Numérica y Gradientes

• RNN Simple: Es extremadamente inestable para secuencias largas (>10 pasos). El entrenamiento falla frecuentemente por NaN (exploding) o estancamiento (vanishing). Se requiere Gradient Clipping obligatorio (cortar la norma del gradiente, ej: clipnorm=1.0).
• LSTM/GRU: Mantienen la magnitud del gradiente de forma efectiva durante cientos de pasos temporales. Sin embargo, no son inmunes a exploding gradients, por lo que el clipping sigue siendo una práctica recomendada.

Sensibilidad a Hiperparámetros

• Inicialización de pesos: Crítica. Inicializaciones ortogonales suelen funcionar mejor que las aleatorias gaussianas para las matrices recurrentes.
• Bias de la Forget Gate: En LSTMs, es crucial inicializar el bias de la forget gate en 1.0 (o un valor alto) para fomentar el recuerdo al inicio del entrenamiento (Jozefowicz et al., 2015). Implementaciones modernas de frameworks como TensorFlow ya incorporan esto por defecto.

Coste Computacional

Las operaciones secuenciales impiden la paralelización completa en GPU. El tiempo de entrenamiento escala linealmente con la longitud de la secuencia $T$.

• LSTM: 4 operaciones matriciales por paso temporal.
• GRU: 3 operaciones matriciales por paso temporal.
• En la práctica, GRU entrena aproximadamente un 15-20% más rápido que LSTM, dependiendo de la implementación de bajo nivel (cuDNN).

Comparativas o referencias técnicas

Al comparar arquitecturas para tareas de modelado de lenguaje o traducción (basado en benchmarks de 2016-2017):

• Chung et al. (2014): Evaluaron empíricamente GRU vs LSTM. Concluyeron que no hay un ganador claro universal; GRU tiende a funcionar mejor en datasets más pequeños y con menos frecuencia de actualización, mientras que LSTM domina en secuencias muy largas y complejas.

La siguiente comparativa resume las diferencias arquitectónicas clave entre las tres variantes de redes recurrentes

Limitaciones y casos donde no conviene usarlo

A pesar de su predominancia actual, estas arquitecturas presentan cuellos de botella estructurales:

1. Secuencialidad obligatoria: El cálculo de $h_t$ requiere estrictamente haber calculado $h_{t-1}$. Esto subutiliza la capacidad masiva de paralelismo de las GPUs modernas, haciendo que el entrenamiento en secuencias muy largas sea costoso en tiempo de reloj.
2. Cuello de botella de información: Todo el contenido de la secuencia procesada debe comprimirse en un vector de tamaño fijo $h_t$. Para oraciones largas en traducción automática, esto degrada el rendimiento significativamente (aunque mecanismos de Attention mitigan esto parcialmente).
3. Memoria finita: Aunque teóricamente pueden recordar indefinidamente, en la práctica el flujo de gradiente se degrada más allá de las 500-1000 iteraciones, haciendo difícil capturar contextos a nivel de documento completo.