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?

📜 Origen del GRU

El Gated Recurrent Unit fue propuesto por Cho et al. en 2014, en el contexto de traducción automática neuronal. Los autores querían una unidad recurrente eficiente para su sistema encoder-decoder:

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.

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

🔬 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

📐 Ecuaciones del GRU

Las ecuaciones del GRU son más compactas que las del LSTM. En cada paso temporal:

📏 Dimensiones y conteo de parámetros

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

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

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

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:,}")

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

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: