Gated Recurrent Unit (GRU)

⚡ ¿Por qué simplificar el LSTM?

El LSTM resolvió el problema del vanishing gradient de forma brillante, pero su arquitectura con 3 puertas, un cell state separado y 4 conjuntos de matrices de pesos es relativamente pesada. En 2014, Kyunghyun Cho et al. se preguntaron: ¿podemos lograr un rendimiento similar con una arquitectura más simple?

Esta reducción del ~25% en parámetros puede parecer modesta, pero tiene implicaciones prácticas significativas. Menos parámetros significa entrenamiento más rápido, menor consumo de memoria GPU, y menor riesgo de sobreajuste en datasets pequeños o medianos. Además, con menos operaciones por paso temporal, el GRU permite procesar secuencias más largas en el mismo tiempo — una ventaja crucial en aplicaciones de tiempo real como reconocimiento de voz en streaming o predicción de texto en teclados móviles.

📜 Origen del GRU

El Gated Recurrent Unit fue propuesto por Cho et al. en junio de 2014 en el paper «Learning Phrase Representations using RNN Encoder-Decoder for Statistical Machine Translation», dentro del contexto de traducción automática neuronal. Los autores buscaban una unidad recurrente eficiente para su sistema encoder-decoder que pudiera capturar dependencias a largo plazo sin la complejidad computacional del LSTM. El resultado fue una arquitectura que demostraba que la simplificación podía lograrse sin sacrificar rendimiento.

Curiosamente, Dzmitry Bahdanau — coautor del paper del GRU — publicó en el mismo año su célebre paper sobre el mecanismo de atención, que eventualmente llevaría a los Transformers. El GRU y la atención nacieron de la misma necesidad: hacer que los modelos secuenciales fueran más eficientes y capaces. De hecho, el paper original del GRU fue uno de los primeros en utilizar una arquitectura encoder-decoder para traducción automática neuronal — un paradigma que dominaría el campo durante los siguientes años.

🔄 Las dos puertas del GRU

A diferencia del LSTM con sus 3 puertas + cell state, el GRU opera con solo 2 puertas y un único estado (el hidden state \(h_t\)):

La diferencia fundamental entre las puertas del GRU y las del LSTM radica en el acoplamiento. En el LSTM, la forget gate y la input gate son independientes: pueden ambas estar abiertas simultáneamente (añadir información nueva sin borrar la vieja) o ambas cerradas. En el GRU, la update gate \(z_t\) implementa un trade-off obligatorio: si \(z_t\) es alta (actualizar mucho), automáticamente \(1 - z_t\) es baja (retener poco del pasado), y viceversa. Esta restricción simplifica la dinámica del modelo y reduce la cantidad de configuraciones posibles que la red necesita aprender.

La reset gate, por su parte, juega un papel que no tiene equivalente directo en el LSTM. Al controlar cuánto del hidden state previo se utiliza para calcular el candidato, permite a la celda «ignorar» su historia cuando detecta un cambio de contexto abrupto — por ejemplo, al cruzar un límite de oración en un texto, o al iniciar un nuevo patrón en una serie temporal.

🔬 Anatomía de una celda GRU

El GRU es más compacto que el LSTM. Cada paso temporal recibe \(h_{t-1}\) y \(x_t\), y produce \(h_t\) — sin cell state separado:

Paso a paso: flujo de datos en una celda GRU

🔍 GRU vs LSTM: comparación visual

La mejor forma de entender las diferencias arquitectónicas entre GRU y LSTM es verlas en paralelo. Aunque ambas resuelven el mismo problema (capturar dependencias a largo plazo evitando el vanishing gradient), lo hacen con mecanismos distintos:

La reducción de una gate y un estado completo no es cosmética: implica ~25% menos de parámetros y, en consecuencia, menos cómputo por paso temporal, menor riesgo de sobreajuste en datasets pequeños, y tiempos de entrenamiento más cortos. La pregunta práctica es si esa simplificación sacrifica expresividad — tema que exploraremos en la sección de comparación empírica.

📐 Ecuaciones del GRU

Las ecuaciones del GRU son notablemente más compactas que las del LSTM. Mientras que el LSTM requiere cuatro conjuntos de ecuaciones (forget, input, output gates más candidato), el GRU las condensa en tres, y la ecuación final de actualización del estado es una simple interpolación lineal. En cada paso temporal:

📏 Dimensiones y conteo de parámetros

El GRU tiene 3 conjuntos de matrices de pesos (vs 4 del LSTM):

COMPARACIÓN DE PARÁMETROS (d_h=256, d_x=100)

El GRU tiene ~25% menos parámetros que el LSTM → entrenamiento más rápido y menor riesgo de sobreajuste.

📈 ¿Por qué el GRU también resuelve el vanishing gradient?

El gradiente del hidden state a través del tiempo:

Cuando la update gate \(z_t \approx 1\), tenemos \(h_t \approx h_{t-1}\) y el gradiente es aproximadamente la identidad — la información fluye sin atenuación, exactamente como en el cell state del LSTM. El mecanismo es análogo a una residual connection adaptativa: en lugar de sumar un residuo fijo, la red aprende cuánto del residuo (el candidato) añadir en cada paso temporal.

Para secuencias largas, si la update gate permanece alta en múltiples pasos, el gradiente se propaga casi sin cambios a lo largo de cientos de timesteps:

🎛️ Explorador interactivo del GRU

Ajusta los valores de las gates y observa cómo el GRU interpola entre mantener el estado anterior y adoptar el candidato:

🔥 GRU en PyTorch

La API de PyTorch para GRU es prácticamente idéntica a la de LSTM. La principal diferencia es que nn.GRU retorna (output, h_n) en vez de (output, (h_n, c_n)) — no hay cell state. Esto simplifica notablemente el código: no necesitas desempaquetar tuplas al recibir la salida, la función forward es más limpia, y la inicialización del estado oculto requiere una sola variable en vez de dos.

El primer ejemplo muestra un clasificador bidireccional completo usando nn.GRU de alto nivel. Observa que la única diferencia con un LSTM equivalente está en la línea de desempaquetado de la salida (línea 25) y en el constructor (línea 11). Todo lo demás — embeddings, dropout, capa de clasificación — es idéntico.

import torch
import torch.nn as nn

class GRUClassifier(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.gru = nn.GRU(
            input_size=embed_dim,
            hidden_size=hidden_dim,
            num_layers=num_layers,
            batch_first=True,
            dropout=dropout,
            bidirectional=bidirectional
        )
        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):
        embedded = self.dropout(self.embedding(x))

        # GRU retorna (output, h_n) — sin cell state
        output, h_n = self.gru(embedded)

        if self.gru.bidirectional:
            h_final = torch.cat([h_n[-2], h_n[-1]], dim=1)
        else:
            h_final = h_n[-1]

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

# Comparación directa: misma tarea, GRU vs LSTM
gru_model = GRUClassifier(vocab_size=10000, embed_dim=128,
                           hidden_dim=256, num_classes=5)
x = torch.randint(0, 10000, (32, 50))
logits = gru_model(x)

# Contar parámetros
gru_params = sum(p.numel() for p in gru_model.parameters())
print(f"GRU params: {gru_params:,}")

El segundo ejemplo muestra nn.GRUCell, la versión paso a paso que te da control total sobre el bucle temporal. Esto es útil cuando necesitas lógica condicional dentro del bucle (por ejemplo, teacher forcing, atención, o beam search) o cuando implementas variantes del GRU como el GRU-D para datos con tiempos irregulares. Compara con el equivalente LSTMCell, donde necesitarías gestionar dos variables de estado en cada paso.

import torch
import torch.nn as nn

class ManualGRU(nn.Module):
    """GRU paso a paso con GRUCell."""
    def __init__(self, input_dim, hidden_dim):
        super().__init__()
        self.hidden_dim = hidden_dim
        self.cell = nn.GRUCell(input_dim, hidden_dim)

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

        outputs = []
        for t in range(seq_len):
            h = self.cell(x[:, t, :], h)  # Solo h, sin cell state
            outputs.append(h)

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

# Ventaja del GRU: inicialización más simple
model = ManualGRU(input_dim=64, hidden_dim=128)
x = torch.randn(1, 20, 64)
outputs, h_final = model(x)
print(f"Hidden state final: norma={h_final.norm():.4f}")
# No necesitas gestionar cell state — una variable menos

🟧 GRU en TensorFlow/Keras

En Keras, la transición de LSTM a GRU es igualmente directa: basta con reemplazar tf.keras.layers.LSTM por tf.keras.layers.GRU. La ventaja adicional en TensorFlow es la compatibilidad automática con cuDNN: si usas reset_after=True (el valor por defecto desde TF 2.x) y no activas recurrent_dropout, Keras delega el cálculo completo a la implementación optimizada de NVIDIA, consiguiendo speed-ups de 3× a 10×.

import tensorflow as tf

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

        # GRU bidireccional
        tf.keras.layers.Bidirectional(
            tf.keras.layers.GRU(hidden_dim, return_sequences=True,
                                dropout=0.2, recurrent_dropout=0.2)
        ),
        tf.keras.layers.Bidirectional(
            tf.keras.layers.GRU(hidden_dim // 2,
                                dropout=0.2, recurrent_dropout=0.2)
        ),

        tf.keras.layers.Dense(32, 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_gru_model()
model.summary()
# Comparar el total de parámetros con un LSTM equivalente:
# GRU tendrá ~25% menos parámetros en las capas recurrentes

import tensorflow as tf
import numpy as np

def build_gru_time_series(seq_len=60, n_features=3, hidden_dim=64):
    """GRU para predicción multivariante de series temporales."""
    inputs = tf.keras.Input(shape=(seq_len, n_features))

    x = tf.keras.layers.GRU(hidden_dim, return_sequences=True)(inputs)
    x = tf.keras.layers.Dropout(0.2)(x)
    x = tf.keras.layers.GRU(hidden_dim // 2)(x)
    x = tf.keras.layers.Dense(16, activation='relu')(x)
    outputs = tf.keras.layers.Dense(1)(x)

    model = tf.keras.Model(inputs, outputs)
    model.compile(optimizer='adam', loss='mse')
    return model

# Ejemplo: 3 features (temperatura, humedad, presión)
model = build_gru_time_series()
X = np.random.randn(1000, 60, 3).astype(np.float32)
y = np.random.randn(1000).astype(np.float32)
model.fit(X, y, epochs=5, batch_size=32, verbose=0)
print(f"GRU time series model params: {model.count_params():,}")

⚖️ LSTM vs GRU: comparación sistemática

¿Cuándo usar LSTM y cuándo GRU? No hay una respuesta universal. La investigación empírica (Chung et al. 2014, Jozefowicz et al. 2015, Greff et al. 2016) muestra que depende de la tarea y los datos. Aquí tienes una guía práctica:

📊 Simulador comparativo: RNN vs LSTM vs GRU

Observa cómo los tres modelos propagan un gradiente a lo largo de una secuencia. Ajusta los parámetros y compara el comportamiento:

🌍 Aplicaciones destacadas del GRU

🔮 RNN, LSTM, GRU y Transformers: el panorama completo

Para cerrar el módulo de redes recurrentes, veamos cómo encajan las tres arquitecturas en el panorama general del deep learning para secuencias: