Gradient clipping: cómo evitar los gradientes explosivos

¿Cuántas veces has visto un valor de pérdida NaN mientras entrenabas una red neuronal profunda?

Tras horas de entrenamiento, la curva de pérdida va bien y, de repente, se dispara hasta el infinito. La causa suele ser los gradientes explosivos: valores de gradiente que crecen tanto durante la retropropagación que las actualizaciones de parámetros se vuelven inestables y el modelo se rompe. Este problema golpea con más fuerza a las redes recurrentes, pero también aparece en transformers y redes feedforward profundas.

El gradient clipping lo soluciona limitando el tamaño de los gradientes antes de que lleguen al optimizador. Es una línea en tu bucle de entrenamiento que mantiene acotadas las actualizaciones sin cambiar nada del modelo.

En este artículo, verás la intuición detrás del gradient clipping, sus dos métodos principales, cómo elegir el umbral y cómo implementarlo en PyTorch y TensorFlow.

Pero ¿qué es exactamente la pérdida en ciencia de datos? Lee nuestra entrada sobre funciones de pérdida en machine learning para descubrirlo.

¿Qué es el gradient clipping?

El gradient clipping es una técnica que limita la magnitud de los gradientes durante el entrenamiento para evitar actualizaciones de parámetros inestables.

Cuando un gradiente se hace demasiado grande, el optimizador da un paso enorme en el espacio de parámetros y empuja los pesos a una región donde la pérdida se dispara. El clipping te ayuda limitando ese tamaño de paso antes de que cause problemas.

Es importante tener en cuenta que el gradient clipping no afecta a la arquitectura del modelo. No añades capas ni cambias funciones de activación. Solo modifica el proceso de entrenamiento interceptando los gradientes entre la retropropagación y el paso del optimizador.

Por eso es barato de probar y fácil de quitar. Como verás, se implementa con una sola línea de código.

Cómo funciona el gradient clipping

La mecánica es sencilla. La operación de clipping se coloca entre el paso backward y el paso del optimizador, y sigue los mismos cuatro pasos en cada iteración.

1. Calcular gradientes: ejecuta el forward pass, calcula la pérdida y realiza la retropropagación. Aquí no cambia nada: los gradientes fluyen por la red como siempre.
2. Comprobar la magnitud de los gradientes: mide cuán grandes son. Según el método, esto implica mirar valores individuales o calcular la norma global en todos los parámetros.
3. Reducir los gradientes si superan un umbral: si la magnitud rebasa el límite que has definido, escala los gradientes a la baja. Si no, déjalos como están.
4. Actualizar los parámetros del modelo: pasa los gradientes recortados al optimizador y aplica la actualización de pesos.

La mayoría de las veces, tus gradientes se quedan por debajo y el entrenamiento avanza igual que sin clipping. Cuando aparece un pico, el clipping lo atrapa antes de que el optimizador reaccione.

Y ya está.

Métodos de gradient clipping más comunes

Hay dos formas de recortar gradientes, y la diferencia radica en qué mides y qué escalas.

Clip by value

Clip by value limita individualmente cada elemento del gradiente.

Eliges un rango, por ejemplo [-1.0, 1.0], y cualquier valor de gradiente fuera de ese rango se redondea al límite más cercano. Un gradiente de 2.5 pasa a 1.0. Un gradiente de -2.5 pasa a -1.0. Los valores que ya están dentro del rango no cambian.

Ejemplo de clip by value

Su gran atractivo es la simplicidad. No hay más matemáticas que una operación min/max, y se ejecuta muy rápido.

Pero tiene una pega: recortar valores individuales cambia la dirección del vector gradiente. Si un componente se recorta y los demás no, el vector resultante ya no apunta adonde indicó la retropropagación. El optimizador acaba dando un paso en una dirección ligeramente equivocada.

Por eso el clip by value es menos habitual en la práctica.

Clip by norm

Clip by norm escala todo el vector de gradiente cuando su magnitud total supera un umbral.

En lugar de mirar valores individuales, calcula la norma de todos los gradientes juntos (normalmente la norma L2) y la compara con un valor máximo. Si la norma está por debajo del umbral, no pasa nada. Si está por encima, cada gradiente se multiplica por el mismo factor de escala para devolver la norma al límite.

Ejemplo de clip by norm

La ventaja es que conserva la dirección. Como todos los componentes se encogen por el mismo factor, el vector gradiente sigue apuntando en la dirección original. Solo acortas el paso, no lo rediriges.

Por eso el clip by norm se ha convertido en el estándar. clip_grad_norm_ de PyTorch y clipnorm de TensorFlow implementan este método, y la mayoría de pipelines modernos lo usan por defecto.

Gradientes explosivos vs gradientes que se desvanecen

Ambos son problemas comunes en deep learning, pero solo uno es el que resuelve el gradient clipping.

Gradientes explosivos

Ocurren cuando los valores del gradiente crecen demasiado durante la retropropagación.

Suele verse en redes profundas o arquitecturas recurrentes, donde los gradientes se multiplican a lo largo de muchas capas o pasos temporales. Si esas multiplicaciones se encadenan en la dirección equivocada, la magnitud del gradiente se dispara. El optimizador hace entonces una actualización enorme, los pesos saltan a valores extremos y la pérdida a menudo se convierte en NaN o Inf.

Lo verás como picos repentinos en la pérdida o un modelo que diverge sin más.

Gradientes que se desvanecen

Es el problema opuesto. Los gradientes se encogen hacia cero al propagarse hacia atrás por la red.

Cuando los gradientes son muy pequeños, las actualizaciones de pesos son minúsculas. Las capas iniciales dejan de aprender, las más profundas aprenden despacio y el entrenamiento prácticamente se detiene. La curva de pérdida se aplana y no mejora, incluso tras muchas épocas.

Fue la razón principal por la que las RNN sufrían con secuencias largas antes de la llegada de LSTMs y GRUs.

Dónde encaja el gradient clipping

El gradient clipping ataja los gradientes explosivos, no los que se desvanecen.

El clipping reduce gradientes demasiado grandes, pero no hace nada cuando son demasiado pequeños. Para los que se desvanecen, necesitas una mejor inicialización de pesos, conexiones residuales, batch normalization o arquitecturas diseñadas para preservar el flujo de gradiente.

Clipping por norma, explicado

El clipping por norma es el método que la mayoría busca cuando piensa en gradient clipping.

Consta de tres pasos. Primero, calcula la norma de todos los gradientes combinados. Segundo, compárala con el umbral elegido. Tercero, reescala los gradientes si la norma es demasiado grande.

La norma suele ser la L2, es decir, elevas al cuadrado cada valor de gradiente, los sumas y haces la raíz cuadrada. Si tienes gradientes g_1, g_2, ..., g_n en todos los parámetros del modelo, la norma L2 es:

Fórmula de clipping por norma

Una vez tienes la norma, la comparas con tu umbral c. Si ||g|| <= c, los gradientes pasan sin cambios. Si ||g|| > c, cada gradiente se multiplica por el factor c / ||g||. Así la nueva norma baja exactamente a c.

Esto importa porque todos los componentes se reducen por el mismo factor. Se mantienen las proporciones relativas entre valores, de modo que el vector sigue apuntando a la misma dirección. Acortas el paso del optimizador, no cambias su rumbo.

Esa propiedad de conservar la dirección es lo que convierte el clipping por norma en la opción por defecto. Clip by value puede torcer el vector gradiente. Clip by norm solo cambia su longitud.

clip_grad_norm_ de PyTorch y clipnorm de TensorFlow hacen exactamente esto. Cuando alguien dice "estoy usando gradient clipping", casi siempre se refiere al clipping por norma.

Cómo elegir el umbral de gradient clipping

El umbral es un hiperparámetro, así que no hay un valor universal que funcione para todos los modelos.

Si lo pones demasiado alto, casi nunca se activará. Los gradientes casi siempre quedarán por debajo y la red de seguridad no atrapará nada. Entrenarás como si no existiera el clipping, y seguirás viendo picos cuando los gradientes exploten.

Si lo pones demasiado bajo, recortarás en exceso. Cada lote verá sus gradientes encogidos, haciendo las actualizaciones más pequeñas de lo que deberían. El aprendizaje se ralentiza y tu modelo tarda más en converger, a veces mucho más.

Un punto de partida habitual es 1.0, que funciona bien en muchas arquitecturas. Valores entre 0.5 y 5.0 cubren la mayoría de casos prácticos.

Lo mejor es monitorizar las normas de tus gradientes durante el entrenamiento. Registra la norma sin recortar en cada paso y analiza la distribución. Si la mayoría de normas rondan 0.3 con picos ocasionales hasta 50, fija el umbral por encima del rango típico pero muy por debajo de los picos: 2.0 o 3.0 serían razonables aquí.

Trátalo como cualquier otro hiperparámetro. Empieza con 1.0, observa qué pasa y ajusta según el comportamiento del entrenamiento.

Gradient clipping en redes neuronales recurrentes

Las RNN fueron el primer terreno donde el gradient clipping se volvió estándar.

El motivo es cómo propagan los gradientes en el tiempo. La retropropagación temporal multiplica las mismas matrices de pesos a lo largo de muchos pasos, y esas multiplicaciones repetidas pueden acumularse en valores enormes. Las secuencias largas agravan el problema.

LSTMs y GRUs lo reducen con mecanismos de puertas, pero no lo eliminan. Ambas arquitecturas siguen beneficiándose del clipping, especialmente con secuencias largas o tasas de aprendizaje altas.

En RNN, el clip by norm con un umbral entre 1.0 y 5.0 suele ser el valor por defecto. Si usas nn.LSTM o nn.GRU de PyTorch y la pérdida explota durante el entrenamiento, añadir clip_grad_norm_ suele ser lo primero que hay que probar.

Gradient clipping en el deep learning moderno

El gradient clipping no desapareció cuando los transformers sustituyeron a las RNN.

Los grandes modelos de lenguaje como GPT y BERT lo usan en el preentrenamiento y el fine-tuning. Lo mismo ocurre con vision transformers, modelos de difusión y la mayoría de arquitecturas profundas con cientos de capas. Los optimizadores Adam y AdamW, predominantes hoy, suelen combinarse con clipping por norma en umbrales alrededor de 1.0.

El motivo es el mismo que en las RNN. Las redes profundas multiplican gradientes a través de muchas capas, y tamaños de lote grandes combinados con tasas de aprendizaje altas pueden producir picos ocasionales. El clipping gestiona esos picos sin afectar a los pasos normales de entrenamiento.

La mayoría de implementaciones de referencia incluyen clipping por defecto. Trainer de Hugging Face, PyTorch Lightning y DeepSpeed lo exponen como una opción estándar de configuración. Si entrenas algo más que un modelo de juguete, casi seguro forma parte del pipeline.

Es una línea que cuesta casi nada y evita que entrenamientos se estrellen tras horas de cómputo. Por eso se ha mantenido.

Gradient clipping en PyTorch

PyTorch gestiona el clipping con una única utilidad: torch.nn.utils.clip_grad_norm_.

La llamada al clipping va entre loss.backward() y optimizer.step(). Primero la retropropagación rellena los gradientes, luego el clipping los reduce si hace falta, y después el optimizador aplica la actualización. En otro sitio no funcionará.

Aquí tienes un script completo y ejecutable que entrena un MLP pequeño en datos sintéticos de regresión con gradient clipping activado:

import torch
import torch.nn as nn
from torch.utils.data import DataLoader, TensorDataset

torch.manual_seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
inputs = torch.randn(n_samples, n_features)
targets = (inputs.sum(dim=1, keepdim=True) * 2.0 + torch.randn(n_samples, 1) * 0.1)

dataset = TensorDataset(inputs, targets)
dataloader = DataLoader(dataset, batch_size=32, shuffle=True)

# Small feedforward network
model = nn.Sequential(
    nn.Linear(n_features, 64),
    nn.ReLU(),
    nn.Linear(64, 64),
    nn.ReLU(),
    nn.Linear(64, 1),
)

optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)
loss_fn = nn.MSELoss()

# Training loop with gradient clipping
n_epochs = 5
max_grad_norm = 1.0

for epoch in range(n_epochs):
    epoch_loss = 0.0
    for batch_inputs, batch_targets in dataloader:
        optimizer.zero_grad()

        predictions = model(batch_inputs)
        loss = loss_fn(predictions, batch_targets)
        loss.backward()

        # Gradient clipping
        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=max_grad_norm)

        optimizer.step()
        epoch_loss += loss.item()

    print(f"Epoch {epoch + 1}: loss = {epoch_loss / len(dataloader):.4f}")

Salida de PyTorch

La función clip_grad_norm_ acepta dos argumentos principales:

• parameters: los parámetros del modelo cuyos gradientes quieres recortar. Pasa model.parameters() para cubrir todo el modelo.

• max_norm: el umbral para la norma del gradiente. Un valor de 1.0 es un buen comienzo.

Hay un argumento opcional norm_type que por defecto es 2.0 (norma L2). Rara vez necesitarás cambiarlo.

El guion bajo final en clip_grad_norm_ indica que es in-place. La función modifica los gradientes directamente en el atributo .grad de cada parámetro, así que no necesitas guardar el valor de retorno. Devuelve la norma total antes del clipping, útil si quieres registrarla.

Para clip-by-value en lugar de clip-by-norm, PyTorch tiene torch.nn.utils.clip_grad_value_:

torch.nn.utils.clip_grad_value_(model.parameters(), clip_value=0.5)

Pero, como hemos comentado, rara vez (si es que alguna vez) usarás esta versión.

Eso es todo el montaje. Dos líneas añadidas a tu bucle de entrenamiento.

Gradient clipping en TensorFlow

TensorFlow gestiona el clipping a nivel del optimizador, no como una llamada aparte.

Al crear un optimizador, pasas clipnorm o clipvalue como argumento. El optimizador aplica el clipping internamente en cada paso, así que no necesitas modificar tu bucle de entrenamiento.

Aquí tienes un ejemplo completo con la API de Keras sobre datos sintéticos de regresión:

import numpy as np
import tensorflow as tf

tf.random.set_seed(42)
np.random.seed(42)

# Synthetic regression data
n_samples = 1000
n_features = 20
x_train = np.random.randn(n_samples, n_features).astype(np.float32)
y_train = (x_train.sum(axis=1, keepdims=True) * 2.0
           + np.random.randn(n_samples, 1).astype(np.float32) * 0.1)

# Small feedforward network
model = tf.keras.Sequential([
    tf.keras.layers.Dense(64, activation="relu", input_shape=(n_features,)),
    tf.keras.layers.Dense(64, activation="relu"),
    tf.keras.layers.Dense(1),
])

# Optimizer with gradient clipping by norm
optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipnorm=1.0)

model.compile(optimizer=optimizer, loss="mse")
model.fit(x_train, y_train, epochs=5, batch_size=32)

Salida de TensorFlow

Los dos argumentos hacen cosas distintas:

• clipnorm recorta por la norma L2 de cada tensor de gradiente. Si la norma supera el umbral, el tensor se escala proporcionalmente a la baja.

• clipvalue recorta cada elemento del gradiente de forma individual. Cualquier valor por encima del umbral se limita al umbral, y cualquier valor por debajo del negativo se limita a ese negativo.

Para pasar de clipping por norma a clipping por valor, basta con cambiar el argumento:

optimizer = tf.keras.optimizers.Adam(learning_rate=1e-3, clipvalue=0.5)

Ambos argumentos funcionan con cualquier optimizador de Keras: Adam, SGD, RMSprop, AdamW y el resto. También existe global_clipnorm, que recorta según la norma calculada en todos los gradientes combinados, en lugar de por tensor. Esto se parece más al comportamiento por defecto de PyTorch.

Si escribes un bucle de entrenamiento personalizado con tf.GradientTape, el optimizador sigue aplicando el clipping cuando llamas a apply_gradients:

for epoch in range(5):
    for batch_x, batch_y in zip(np.array_split(x_train, 32), np.array_split(y_train, 32)):
        with tf.GradientTape() as tape:
            predictions = model(batch_x, training=True)
            loss = tf.reduce_mean(tf.square(predictions - batch_y))

        gradients = tape.gradient(loss, model.trainable_variables)
        optimizer.apply_gradients(zip(gradients, model.trainable_variables))

Esa es la diferencia entre frameworks. PyTorch pone el clipping en tus manos dentro del bucle. TensorFlow lo integra en el propio optimizador. La lógica de fondo es idéntica.

Gradient clipping vs otras técnicas de estabilización

El gradient clipping no es la única forma de estabilizar el entrenamiento, y no siempre es la herramienta adecuada.

Otras técnicas abordan problemas relacionados pero distintos. Algunas evitan que los gradientes crezcan en primer lugar, otras impiden que se desvanezcan y otras hacen que la superficie de pérdida sea más fácil de optimizar. Te muestro un par de técnicas.

Batch normalization

Batch normalization normaliza las activaciones dentro de cada mini-batch durante el entrenamiento.

Mantiene las salidas de las capas en un rango estable, lo que hace más predecibles las magnitudes de los gradientes. Con batch norm, las redes toleran tasas de aprendizaje más altas, convergen antes y son menos sensibles a la inicialización de pesos.

Pero batch norm no detiene directamente las explosiones de gradiente. Reduce su frecuencia, no actúa cuando ocurren. Por eso muchos modelos lo combinan con gradient clipping.

Conexiones residuales

Añaden atajos que saltan una o más capas, permitiendo que los gradientes fluyan directamente de capas tardías a tempranas.

Esto soluciona el problema de los gradientes que se desvanecen en redes profundas. Sin conexiones residuales, entrenar redes de más de 20–30 capas es difícil porque los gradientes se encogen al retropropagar. Con ellas, redes de cientos de capas se entrenan sin problema.

Las residuales atacan el extremo opuesto del problema respecto al clipping. El clipping maneja gradientes demasiado grandes. Las residuales, los que se quedan demasiado pequeños.

Inicialización cuidadosa de pesos

Los valores iniciales de los pesos fijan la magnitud inicial de activaciones y gradientes. Una mala inicialización puede causar explosiones o desvanecimientos desde el primer paso.

Métodos como Xavier y He escalan los pesos iniciales según el tamaño de la capa. Esto mantiene estables las varianzas de activación al inicio, evitando muchos problemas de gradiente antes de que aparezcan.

Una buena inicialización reduce la probabilidad de necesitar clipping, pero no la elimina. Los picos pueden aparecer más tarde, sobre todo con tasas de aprendizaje altas o lotes atípicos.

Cómo encajan entre sí

Estas técnicas no son alternativas, son complementarias: resuelven piezas distintas del mismo problema.

Un setup moderno típico usa una inicialización cuidada al principio, conexiones residuales en la arquitectura, batch o layer normalization dentro de la red y gradient clipping como red de seguridad durante la optimización. Cada una cubre un modo de fallo concreto y, juntas, hacen entrenables las redes profundas.

Conclusión

El gradient clipping es uno de los arreglos más sencillos en deep learning y soluciona un problema que puede arruinar horas de entrenamiento en un solo paso.

La buena noticia es que no necesitas cambiar la arquitectura del modelo ni reescribir tu código. Una línea en PyTorch o un argumento en TensorFlow bastan para implementarlo.

Funciona mejor como parte de un conjunto mayor. Combínalo con una inicialización cuidadosa de pesos, conexiones residuales y batch o layer normalization, y tendrás un pipeline de entrenamiento que gestiona la inestabilidad desde varios frentes.

Si tu pérdida explota, empieza con clipping. Si se desvanece, busca otra cosa. Y si entrenas algo más grande que un modelo pequeño, añade clipping a tu pipeline por defecto y olvídate.

El gradient clipping es solo uno de los muchos términos que todo ingeniero de machine learning debe conocer. Si quieres aprender los demás y estar listo para trabajar en 2026, apúntate hoy a nuestro itinerario Machine Learning Engineer.