Fundamentos de RNN

📊 Datos secuenciales: cuando el orden importa

La mayoría de modelos que hemos estudiado hasta ahora — perceptrones, MLPs, CNNs — asumen que los datos de entrada son independientes entre sí. Cada imagen se clasifica sin «recordar» las anteriores. Pero el mundo real está lleno de datos donde el orden temporal es fundamental:

• Texto y lenguaje natural: «El gato se sentó en la alfombra» tiene sentido; «alfombra la en sentó se gato el» no. Cada palabra depende de las anteriores.
• Series temporales financieras: El precio de una acción hoy depende de su trayectoria pasada, no es un punto aislado.
• Audio y habla: Un fonema solo tiene significado en contexto con los fonemas vecinos.
• Señales biológicas: Electrocardiogramas (ECG), electroencefalogramas (EEG), datos de sensores biomédicos.
• Vídeo: Cada frame tiene relación con los anteriores y posteriores.
• Trayectorias y movimiento: GPS, movimiento de robots, tracking de objetos.

¿Qué es una secuencia?

Formalmente, una secuencia es una colección ordenada de elementos \(x_1, x_2, \ldots, x_T\), donde \(T\) es la longitud de la secuencia. Cada elemento \(x_t\) puede ser:

• Un escalar — por ejemplo, la temperatura en el instante \(t\).
• Un vector — por ejemplo, un word embedding de dimensión 300.
• Un tensor — por ejemplo, un frame de vídeo de dimensiones \(H \times W \times 3\).

Lo que distingue a los datos secuenciales de un simple conjunto de datos es que existe una dependencia estadística entre elementos vecinos: \(p(x_t | x_{t-1}, x_{t-2}, \ldots)\) no es igual a \(p(x_t)\).

Dependencias temporales: cortas y largas

No todas las dependencias son iguales. Algunas son de corto plazo y otras de largo plazo:

Como veremos, las RNN simples son buenas capturando dependencias de corto plazo, pero tienen dificultades serias con las de largo plazo — un problema fundamental que motivará arquitecturas más avanzadas como LSTM y GRU.

🌍 Ejemplos y aplicaciones

Antes de entrar en la arquitectura de las RNNs, veamos la diversidad de problemas que involucran datos secuenciales:

Taxonomía de problemas secuenciales

Los problemas con secuencias se clasifican según la relación entre la entrada y la salida:

🚫 Limitaciones del MLP para secuencias

¿Por qué no podemos simplemente usar un perceptrón multicapa (MLP) para procesar secuencias? Intentémoslo y veamos qué problemas aparecen:

Problema 1: Tamaño de entrada fijo

Un MLP necesita un vector de entrada de dimensión fija. Si queremos procesar una oración de 5 palabras, necesitamos una capa de entrada de tamaño \(5 \times d\) (donde \(d\) es la dimensión del embedding). Pero:

• ¿Qué pasa con oraciones de 10, 50 o 200 palabras?
• Tendríamos que hacer padding (rellenar con ceros) hasta la longitud máxima — desperdiciando cómputo
• O truncar las secuencias largas — perdiendo información

Problema 2: Sin noción de orden

Para un MLP, las características de entrada son intercambiables. Si alimentamos «el gato come» como \([x_\text{el}, x_\text{gato}, x_\text{come}]\) o «come gato el» como \([x_\text{come}, x_\text{gato}, x_\text{el}]\), el MLP puede aprender a distinguirlos, pero no tiene un mecanismo innato para entender la posición.

Problema 3: Sin compartición de parámetros temporal

Imagina que entrenas un MLP para detectar el patrón «subida rápida» en una serie temporal. Si ese patrón aparece en la posición 5, el MLP necesita pesos diferentes a si aparece en la posición 50. No puede reutilizar lo aprendido en una posición temporal para aplicarlo en otra.

Problema 4: Sin memoria

El problema más fundamental es que un MLP no tiene memoria. Cada entrada se procesa de forma completamente independiente. No hay mecanismo para que la información de \(x_1\) influya en cómo se procesa \(x_5\).

Esto es como intentar entender una película viendo cada fotograma por separado, sin recordar los anteriores. Puedes describir lo que ves en cada instante, pero no puedes entender la trama.

Resumen de limitaciones

🔁 La idea de la recurrencia

La clave para procesar secuencias es sorprendentemente simple: darle memoria a la red. En cada paso temporal, la red no solo recibe la entrada actual \(x_t\), sino también un resumen de todo lo que ha visto hasta el momento. A este resumen lo llamamos estado oculto (hidden state) \(h_t\).

De un bucle en código a una neurona recurrente

La idea de la recurrencia es natural en programación. Piensa en un bucle que acumula información:

# El concepto de recurrencia en pseudocódigo
estado = inicializar()  # h₀ = 0

for t in range(len(secuencia)):
    # En cada paso: la función f recibe el estado anterior Y la entrada actual
    estado = f(estado, secuencia[t])
    # El "estado" acumula información de TODOS los pasos anteriores

# Al final, "estado" contiene un resumen de toda la secuencia
salida = g(estado)

Esta es exactamente la idea de una RNN: una función \(f\) que se aplica repetidamente, actualizando un estado interno con cada nueva entrada. La diferencia es que \(f\) es una red neuronal con parámetros aprendibles.

La celda RNN: vista plegada

La forma más compacta de representar una RNN es la vista plegada (folded view). Un solo bloque con una flecha que «vuelve a sí mismo», indicando la recurrencia:

Vista desplegada (unrolled)

Si «desenrollamos» la recurrencia en el tiempo, obtenemos la vista desplegada (unrolled view). Aquí se ve claramente cómo la misma celda procesa cada paso temporal:

🧠 El estado oculto (hidden state)

El hidden state \(h_t \in \mathbb{R}^{d_h}\) es el corazón de la RNN. Es un vector que actúa como memoria comprimida de toda la secuencia procesada hasta el paso \(t\).

¿Qué captura el hidden state?

Imagina que la RNN procesa la frase «El gato negro duerme en el sofá». En cada paso, el hidden state acumula información:

Cada \(h_t\) es un vector de números reales. La red aprende a codificar la información relevante en estos vectores durante el entrenamiento.

Dimensión del hidden state

La dimensión \(d_h\) del hidden state es un hiperparámetro que controla la capacidad de la memoria:

Valores típicos de \(d_h\): 32–64 para tareas simples, 128–256 para tareas medias, 512–1024 para modelos grandes.

Inicialización del hidden state

Antes de procesar el primer elemento de la secuencia, necesitamos un hidden state inicial \(h_0\). Lo más común es:

📐 Matemáticas de la RNN

Ahora formalizamos la intuición anterior con las ecuaciones exactas de una RNN vanilla (también llamada Elman RNN). El forward pass en cada paso temporal \(t\) se define con dos ecuaciones:

Donde:

¿Por qué la tangente hiperbólica?

La activación \(\tanh\) se usa por defecto en la ecuación del hidden state por varias razones:

• Rango \([-1, 1]\): Mantiene los valores del hidden state acotados, evitando explosión numérica
• Centrada en cero: A diferencia de la sigmoide, tiene media cero, facilitando el entrenamiento
• Gradientes más fuertes: El gradiente máximo de \(\tanh\) es 1 (en \(x=0\)), mejor que la sigmoide (máximo 0.25)

Flujo computacional paso a paso

Diagrama del flujo computacional

🔢 Ejemplo numérico

Veamos un ejemplo concreto con dimensiones pequeñas para entender las operaciones matriciales. Supongamos:

• \(d_x = 2\) (entrada bidimensional)
• \(d_h = 3\) (hidden state de 3 dimensiones)
• \(d_y = 1\) (salida escalar)

Conteo de parámetros

El número total de parámetros de una RNN vanilla es:

Para nuestro ejemplo: \(3\times2 + 3\times3 + 3 + 1\times3 + 1 = 6+9+3+3+1 = \mathbf{22}\) parámetros.

🏗️ Arquitecturas y tipos de RNN

Dependiendo de la tarea, podemos usar la RNN de diferentes formas: tomando solo la última salida, todas las salidas, o combinaciones. Estas variantes se clasifican según la relación entre entrada y salida:

💻 RNN en la práctica: PyTorch y TensorFlow

Veamos cómo implementar una RNN en los dos frameworks más populares. Empezamos con la API de alto nivel y luego exploramos el uso a nivel de celda.

PyTorch: nn.RNN

import torch
import torch.nn as nn

class SentimentRNN(nn.Module):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = nn.Embedding(vocab_size, embed_dim)
        
        # RNN: procesa la secuencia completa
        # batch_first=True → entrada shape: (batch, seq_len, embed_dim)
        self.rnn = nn.RNN(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=1,
            batch_first=True,
            nonlinearity='tanh'    # activación por defecto
        )
        
        # Capa de salida: del último hidden state a la predicción
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x):
        # x shape: (batch, seq_len) — índices de palabras
        embedded = self.embedding(x)         # (batch, seq_len, embed_dim)
        
        # output: (batch, seq_len, hidden_dim) — todos los hidden states
        # h_n:    (1, batch, hidden_dim)       — último hidden state
        output, h_n = self.rnn(embedded)
        
        # Usamos el ÚLTIMO hidden state para clasificar
        last_hidden = h_n.squeeze(0)         # (batch, hidden_dim)
        logits = self.fc(last_hidden)        # (batch, output_dim)
        return logits

# Ejemplo de uso
model = SentimentRNN(vocab_size=10000, embed_dim=128, hidden_dim=256, output_dim=2)
x = torch.randint(0, 10000, (32, 50))       # batch=32, seq_len=50
logits = model(x)                            # (32, 2) — positivo/negativo
print(f"Shape de salida: {logits.shape}")
print(f"Parámetros totales: {sum(p.numel() for p in model.parameters()):,}")

import torch
import torch.nn as nn

class ManualRNN(nn.Module):
    """RNN paso a paso usando RNNCell — máximo control."""
    def __init__(self, input_dim, hidden_dim, output_dim):
        super().__init__()
        self.hidden_dim = hidden_dim
        
        # RNNCell: un solo paso temporal
        self.rnn_cell = nn.RNNCell(input_dim, hidden_dim)
        self.fc = nn.Linear(hidden_dim, output_dim)
    
    def forward(self, x):
        # x shape: (batch, seq_len, input_dim)
        batch_size, seq_len, _ = x.shape
        
        # Inicializar hidden state a ceros
        h_t = torch.zeros(batch_size, self.hidden_dim, device=x.device)
        
        # Lista para guardar todos los hidden states
        all_h = []
        
        for t in range(seq_len):
            # Un paso temporal: h_t = tanh(W_xh · x_t + W_hh · h_{t-1} + b)
            h_t = self.rnn_cell(x[:, t, :], h_t)
            all_h.append(h_t)
        
        # all_h[-1] == último hidden state
        # Podemos devolver el último o todos
        output = self.fc(h_t)  # many-to-one: solo el último
        return output, torch.stack(all_h, dim=1)  # (batch, seq_len, hidden_dim)

# Uso
model = ManualRNN(input_dim=10, hidden_dim=64, output_dim=3)
x = torch.randn(16, 20, 10)  # batch=16, seq_len=20, features=10
out, hidden_states = model(x)
print(f"Salida: {out.shape}")              # (16, 3)
print(f"Hidden states: {hidden_states.shape}")  # (16, 20, 64)

TensorFlow / Keras: SimpleRNN

import tensorflow as tf
from tensorflow.keras import layers, Model

class SentimentRNN(Model):
    def __init__(self, vocab_size, embed_dim, hidden_dim, output_dim):
        super().__init__()
        self.embedding = layers.Embedding(vocab_size, embed_dim)
        
        # SimpleRNN: equivalente a nn.RNN de PyTorch
        # return_sequences=False → solo devuelve el último hidden state
        self.rnn = layers.SimpleRNN(
            units=hidden_dim,
            activation='tanh',
            return_sequences=False  # many-to-one
        )
        
        self.fc = layers.Dense(output_dim)
    
    def call(self, x):
        embedded = self.embedding(x)    # (batch, seq_len, embed_dim)
        h_last = self.rnn(embedded)     # (batch, hidden_dim)
        logits = self.fc(h_last)        # (batch, output_dim)
        return logits

# Ejemplo de uso
model = SentimentRNN(vocab_size=10000, embed_dim=128, hidden_dim=256, output_dim=2)
x = tf.random.uniform((32, 50), maxval=10000, dtype=tf.int32)
logits = model(x)
print(f"Shape de salida: {logits.shape}")
model.summary()

import tensorflow as tf
from tensorflow.keras import layers, Sequential

# Many-to-many: predecir el siguiente valor en cada paso
model = Sequential([
    # return_sequences=True → devuelve output en CADA paso temporal
    layers.SimpleRNN(64, activation='tanh', return_sequences=True,
                     input_shape=(None, 1)),  # None = cualquier longitud
    
    # Segunda capa RNN (stacked/apilada)
    layers.SimpleRNN(32, activation='tanh', return_sequences=True),
    
    # Capa Dense aplicada a cada paso temporal
    layers.TimeDistributed(layers.Dense(1))
])

model.compile(optimizer='adam', loss='mse')
model.summary()

# Datos de ejemplo: secuencia senoidal
import numpy as np
t = np.linspace(0, 10*np.pi, 1000)
x = np.sin(t).reshape(1, -1, 1).astype('float32')
y = np.cos(t).reshape(1, -1, 1).astype('float32')  # predecir cos a partir de sin

model.fit(x, y, epochs=50, verbose=0)
pred = model.predict(x)
print(f"Predicción shape: {pred.shape}")  # (1, 1000, 1)

RNN multicapa (stacked RNN)

Podemos apilar varias capas RNN: la salida de la primera capa en cada paso temporal se convierte en la entrada de la segunda capa:

import torch.nn as nn

# RNN de 3 capas apiladas con dropout entre capas
rnn = nn.RNN(
    input_size=128,
    hidden_size=256,
    num_layers=3,       # 3 capas apiladas
    batch_first=True,
    dropout=0.3,        # dropout entre capas (no en la última)
    bidirectional=False  # unidireccional
)

# h_n shape: (num_layers, batch, hidden_dim)
# output shape: (batch, seq_len, hidden_dim)
x = torch.randn(32, 50, 128)
output, h_n = rnn(x)
print(f"output: {output.shape}")   # (32, 50, 256)
print(f"h_n: {h_n.shape}")         # (3, 32, 256) — un h por capa

RNN bidireccional

Una RNN bidireccional procesa la secuencia en ambas direcciones: de izquierda a derecha y de derecha a izquierda. Esto permite que cada hidden state contenga información tanto del pasado como del futuro.

import torch.nn as nn

# RNN bidireccional
rnn_bidir = nn.RNN(
    input_size=128,
    hidden_size=256,
    num_layers=2,
    batch_first=True,
    bidirectional=True   # ← bidireccional
)

x = torch.randn(32, 50, 128)
output, h_n = rnn_bidir(x)

# output: (batch, seq_len, 2 * hidden_dim) — forward + backward concatenados
# h_n: (2 * num_layers, batch, hidden_dim)
print(f"output: {output.shape}")   # (32, 50, 512) ← 256*2
print(f"h_n: {h_n.shape}")         # (4, 32, 256)  ← 2 capas * 2 direcciones

⏪ Backpropagation Through Time (BPTT)

¿Cómo entrenamos una RNN? Usando Backpropagation Through Time (BPTT), que es el algoritmo de backpropagation estándar aplicado a la RNN desplegada en el tiempo. Es decir, tratamos la RNN desplegada como una red muy profunda donde cada «capa» es un paso temporal.

La función de pérdida

La pérdida total es la suma de las pérdidas en cada paso temporal:

Para optimizar los pesos, necesitamos calcular \(\frac{\partial \mathcal{L}}{\partial W}\) para cada matriz de pesos. Veamos cómo se propagan los gradientes hacia atrás en el tiempo.

Algoritmo BPTT paso a paso

El gradiente clave: ¿cómo depende \(h_t\) de \(h_k\)?

El problema central del BPTT aparece al calcular cómo el hidden state en el paso \(t\) depende de un hidden state anterior en el paso \(k\) (con \(k < t\)):

Donde \(z_i = W_{hh} h_{i-1} + W_{xh} x_i + b_h\). Esta es una cadena de productos matriciales. Y aquí es donde surgen los problemas:

📉 Gradientes que se desvanecen (vanishing gradients)

El problema de vanishing gradients ocurre cuando los gradientes se hacen exponencialmente pequeños al propagarse hacia atrás en secuencias largas.

¿Por qué ocurre?

Recordemos que \(\tanh'(z) \in (0, 1]\) y que el valor máximo de la derivada es 1 (solo cuando \(z = 0\)). Si los valores propios de \(W_{hh}\) son menores que 1, cada multiplicación en la cadena encoge el gradiente:

Consecuencia: La RNN no puede aprender dependencias a largo plazo. Si la palabra que determina el sentimiento de una oración está al principio, y la pérdida se calcula al final, el gradiente que llega hasta esa palabra es prácticamente cero.

📈 Gradientes que explotan (exploding gradients)

El problema inverso: si \(\gamma > 1\), los gradientes crecen exponencialmente. Esto causa actualizaciones de pesos enormes que desestabilizan el entrenamiento.

Los síntomas de exploding gradients incluyen:

• Loss que salta a NaN o Inf de repente
• Pesos que crecen sin control
• Entrenamiento inestable con oscilaciones grandes

Solución: Gradient clipping

A diferencia de vanishing gradients (difícil de solucionar sin cambiar la arquitectura), el exploding gradient tiene una solución directa: gradient clipping. Si la norma del gradiente supera un umbral, lo reescalamos:

import torch
import torch.nn as nn

model = ...  # tu modelo RNN
optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
max_grad_norm = 1.0  # umbral de clipping

for batch in dataloader:
    optimizer.zero_grad()
    output = model(batch.input)
    loss = criterion(output, batch.target)
    loss.backward()
    
    # ⚡ Gradient clipping — ANTES del optimizer.step()
    torch.nn.utils.clip_grad_norm_(model.parameters(), max_grad_norm)
    
    optimizer.step()

import tensorflow as tf

model = ...  # tu modelo RNN

# Opción 1: clipnorm en el optimizador
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipnorm=1.0)

# Opción 2: clipvalue (limita cada componente individualmente)
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipvalue=0.5)

model.compile(optimizer=optimizer, loss='mse')

Comparación de los dos problemas

⏱️ Memoria a corto plazo

Como consecuencia directa del vanishing gradient, las RNN vanilla sufren de memoria a corto plazo: pueden recordar información reciente, pero «olvidan» la información de pasos temporales lejanos.

Esto es un problema fundamental en muchas tareas reales. Algunos ejemplos:

• Traducción: El sujeto al inicio de una oración larga afecta la conjugación del verbo al final
• Resumen: La idea principal puede estar en el primer párrafo de un documento largo
• Series temporales: Patrones estacionales de hace meses afectan la predicción actual
• Generación de código: Una variable definida muchas líneas antes se usa ahora

🧱 Limitaciones de la RNN vanilla

Resumamos todas las limitaciones que hemos identificado en la RNN vanilla y veamos qué motivó la creación de arquitecturas más avanzadas.

Resumen de problemas

Más allá de la RNN vanilla

Estas limitaciones motivaron el desarrollo de arquitecturas más sofisticadas que atacan estos problemas de diferentes formas:

¿Cuándo usar RNN vanilla hoy?

A pesar de sus limitaciones, la RNN vanilla sigue siendo útil en ciertos escenarios: