Gradient clipping: zo voorkom je exploderende gradiënten

Hoe vaak heb je tijdens het trainen van een diep neuraal netwerk een NaN-waardeverlies gezien?

Na uren trainen ziet de verliescurve er gezond uit, en dan schiet hij uit het niets naar oneindig. De oorzaak is meestal exploderende gradiënten — gradientwaarden die tijdens backpropagation zo groot worden dat parameterupdates onstabiel worden en het model stukloopt. Dit probleem treft recurrente netwerken het hardst, maar het komt ook voor bij transformers en diepe feedforward-netwerken.

Gradient clipping lost dit op door de grootte van gradiënten te beperken vóór ze de optimizer bereiken. Het is een toevoeging van één regel aan je trainingslus die updates binnen grenzen houdt zonder iets aan het model te wijzigen.

In dit artikel behandel ik de intuïtie achter gradient clipping, de twee belangrijkste methoden, hoe je een drempel kiest en hoe je het implementeert in PyTorch en TensorFlow.

Maar wat is verlies (loss) in data science nu precies? Lees onze blogpost over de lossfunctie in machine learning om erachter te komen.

Wat is gradient clipping?

Gradient clipping is een techniek die de grootte van gradiënten tijdens het trainen beperkt om onstabiele parameterupdates te voorkomen.

Wanneer een gradiënt te groot wordt, zet de optimizer een enorme stap in de parameter-ruimte en duwt gewichten een gebied in waar het verlies explodeert. Clipping helpt door die stapgrootte te begrenzen vóór er schade kan ontstaan.

Belangrijk om te weten: gradient clipping beïnvloedt de modelarchitectuur niet. Je voegt geen lagen toe en je wijzigt geen activatiefuncties. Het verandert alleen het trainingsproces door gradiënten te onderscheppen tussen backpropagation en de optimizerstap.

Daardoor is het goedkoop om te proberen en makkelijk weer te verwijderen. Zoals je zo ziet, kost het maar één regel code.

Hoe gradient clipping werkt

De mechaniek is simpel. De clipping-operatie staat tussen je backward pass en je optimizerstap, en volgt elke iteratie dezelfde vier stappen.

1. Gradiënten berekenen: Voer de forward pass uit, bereken de loss en draai backpropagation. Hier verandert niets: gradiënten stromen door het netwerk zoals altijd.
2. Grootte van de gradiënt controleren: Meet hoe groot de gradiënten zijn. Afhankelijk van de methode kijk je naar individuele waarden of bereken je de algehele norm over alle parameters.
3. Gradiënten verkleinen als ze een drempel overschrijden: Als de grootte de ingestelde limiet overschrijdt, schaal je de gradiënten omlaag. Zo niet, dan laat je ze ongemoeid.
4. Modelparameters updaten: Geef de geclipte gradiënten door aan de optimizer en pas de gewichtsupdate toe.

Meestal blijven je gradiënten eronder en verloopt het trainen zoals zonder gradient clipping. Bij een piek grijpt clipping in vóór de optimizer kan reageren.

Dat is alles.

Veelgebruikte methoden voor gradient clipping

Er zijn twee manieren om gradiënten te clippen; het verschil zit in wat je meet en wat je schaalt.

Clippen op waarde

Clippen op waarde begrenst elk gradiëntelement afzonderlijk.

Je kiest een bereik, bijvoorbeeld [-1.0, 1.0], en elke gradiëntwaarde buiten dat bereik wordt afgerond naar de dichtstbijzijnde grens. Een gradiënt van 2.5 wordt 1.0. Een gradiënt van -2.5 wordt -1.0. Waarden binnen het bereik blijven ongewijzigd.

Voorbeeld: clippen op waarde

Het aantrekkelijke is de eenvoud. Er komt geen wiskunde bij kijken behalve een min/max-bewerking, en het is snel uit te voeren.

Maar deze aanpak heeft een nadeel. Het clippen van individuele waarden verandert de richting van de gradiëntvector. Als één component wordt geclipt en de andere niet, wijst de bijgewerkte vector niet meer waar backpropagation aangaf. Je optimizer zet dan een stap in een iets verkeerde richting.

Daarom is clippen op waarde in de praktijk minder gebruikelijk.

Clippen op norm

Clippen op norm schaalt de volledige gradiëntvector als de totale grootte een drempel overschrijdt.

In plaats van naar individuele waarden te kijken, berekent het de norm van alle gradiënten samen (meestal de L2-norm) en vergelijkt die met een maximumwaarde. Als de norm onder de drempel ligt, gebeurt er niets. Ligt die erboven, dan wordt elke gradiënt met dezelfde schaalfactor vermenigvuldigd om de norm terug te brengen naar de limiet.

Voorbeeld: clippen op norm

Het voordeel is het behouden van de richting. Omdat elke component met dezelfde factor krimpt, wijst de gradiëntvector nog steeds in de oorspronkelijke richting. Je verkort alleen de stap, je verandert hem niet van richting.

Daarom is clippen op norm de standaard geworden. PyTorch’ clip_grad_norm_ en TensorFlows clipnorm implementeren beide deze methode, en de meeste moderne trainingspijplijnen gebruiken het standaard.

Exploderende gradiënten vs. verdwijnende gradiënten

Exploderende en verdwijnende gradiënten zijn beide veelvoorkomende problemen in deep learning, maar slechts één ervan wordt opgelost met gradient clipping.

Exploderende gradiënten

Exploderende gradiënten ontstaan wanneer gradientwaarden tijdens backpropagation te groot worden.

Dit zie je vaak bij diepe netwerken of recurrente architecturen, waar gradiënten over veel lagen of tijdstappen worden vermenigvuldigd. Als die vermenigvuldigingen de verkeerde kant op samengestelde effecten hebben, loopt de gradiëntgrootte uit de hand. De optimizer doet dan een enorme parameterupdate, gewichten schieten naar extreme waarden en de loss wordt vaak NaN of Inf.

Je merkt het als plotselinge verliespieken of een model dat uit het niets divergeert.

Verdwijnende gradiënten

Verdwijnende gradiënten zijn het tegenovergestelde probleem. Gradientwaarden krimpen richting nul terwijl ze achterwaarts door het netwerk propaganderen.

Als gradiënten te klein worden, worden gewichtsupdates minuscuul. Vroege lagen stoppen met leren, diepere lagen leren traag en het trainen komt praktisch stil te staan. De verliescurve vlakt af en verbetert niet, zelfs niet na veel epochs.

Dit was de belangrijkste reden dat RNN’s moeite hadden met lange sequenties voordat LSTM’s en GRU’s kwamen.

Waar gradient clipping past

Gradient clipping pakt exploderende gradiënten aan, niet verdwijnende gradiënten.

Clipping verkleint gradiënten die te groot zijn, maar doet niets wanneer gradiënten te klein zijn. Voor verdwijnende gradiënten heb je betere gewichtsinitialisatie, residual connections, batchnormalisatie of architecturen nodig die de gradiëntenstroom behouden.

Gradient clipping op norm uitgelegd

Clippen op norm is de methode die de meeste lezers bedoelen wanneer ze zoeken op gradient clipping.

Het proces kent drie stappen. Eerst bereken je de norm van alle gradiënten samen. Vervolgens vergelijk je die norm met je gekozen drempel. Tot slot herschaal je de gradiënten als de norm te groot is.

De norm is meestal de L2-norm: je kwadrateert elke gradiëntwaarde, telt ze op en neemt de wortel. Als je gradiënten g_1, g_2, ..., g_n over alle modelparameters hebt, dan is de L2-norm:

Formule: clippen op norm

Zodra je de norm hebt, vergelijk je die met je drempel c. Als ||g|| <= c, gaan de gradiënten ongewijzigd door. Als ||g|| > c, wordt elke gradiënt vermenigvuldigd met de schaalfactor c / ||g||. Daardoor wordt de nieuwe norm precies c.

Dit is belangrijk omdat elke component met dezelfde factor krimpt. De onderlinge verhoudingen tussen gradiëntwaarden blijven gelijk, dus de vector wijst nog steeds in de oorspronkelijke richting. Je verkort de stap die de optimizer zet, niet de richting waarin hij gaat.

Dat richtingbehoud maakt normclipping de standaardkeuze. Clippen op waarde kan de gradiëntvector een nieuwe richting op duwen. Clippen op norm verandert alleen de lengte.

PyTorch’ clip_grad_norm_ en TensorFlows clipnorm doen precies dit. Als iemand zegt: "Ik gebruik gradient clipping", bedoelt die bijna altijd clippen op norm.

Een drempel voor gradient clipping kiezen

De drempel is een hyperparameter, wat betekent dat er geen universele waarde is die voor elk model werkt.

Zet je hem te hoog, dan treedt clipping bijna nooit in werking. Je gradiënten blijven vrijwel altijd onder de limiet, dus het vangnet pakt niets. Het trainen verloopt alsof clipping er niet was, en je ziet nog steeds verliespieken wanneer gradiënten exploderen.

Zet je hem te laag, dan clip je te agressief. Elke batch krijgt verkleinde gradiënten, waardoor gewichtsupdates kleiner zijn dan nodig. Het leren vertraagt en je model doet er langer over om te convergeren — soms veel langer.

Een gangbaar startpunt is 1.0, wat goed werkt voor veel architecturen. Waarden tussen 0.5 en 5.0 dekken de meeste praktische use-cases.

Beter is om je gradientnormen tijdens het trainen te monitoren. Log de ongeclipte norm bij elke stap en bekijk de verdeling. Als de meeste normen rond 0.3 liggen met af en toe pieken naar 50, zet de drempel dan boven het typische bereik maar ruim onder de pieken — 2.0 of 3.0 zou hier redelijk zijn.

Behandel het zoals elke andere hyperparameter. Begin met 1.0, kijk wat er gebeurt en stel bij op basis van het trainingsgedrag.

Gradient clipping in recurrente neurale netwerken

RNN’s zijn waar gradient clipping eerst standaard werd.

Dat komt door hoe RNN’s gradiënten door de tijd propaganderen. Backpropagation through time vermenigvuldigt dezelfde gewichtsmatrices over veel tijdstappen, en die herhaalde vermenigvuldigingen kunnen zich opstapelen tot enorme waarden. Lange sequenties verergeren het probleem.

LSTM’s en GRU’s hebben het probleem verminderd met hun gating-mechanismen, maar niet geëlimineerd. Beide architecturen profiteren nog steeds van clipping, zeker bij trainen op lange sequenties of met hoge leersnelheden.

Voor RNN-training is clippen op norm met een drempel tussen 1.0 en 5.0 de typische standaard. Als je PyTorch’ nn.LSTM of nn.GRU gebruikt en je loss explodeert tijdens het trainen, is clip_grad_norm_ toevoegen meestal het eerste wat je probeert.

Gradient clipping in moderne deep learning

Gradient clipping is niet verdwenen toen transformers RNN’s vervingen.

Grote taalmodellen zoals GPT en BERT gebruiken clipping tijdens pretraining en fine-tuning. Hetzelfde geldt voor vision transformers, diffusie-modellen en de meeste diepe architecturen met honderden lagen. De Adam- en AdamW-optimizers, die modern trainen domineren, worden vaak gekoppeld aan normclipping met drempels rond 1.0.

De reden is dezelfde als bij RNN’s. Diepe netwerken vermenigvuldigen gradiënten over veel lagen, en grote batchgroottes gecombineerd met hoge leersnelheden kunnen af en toe gradientpieken veroorzaken. Clipping vangt die pieken op zonder normale trainingsstappen te beïnvloeden.

De meeste referentie-implementaties bevatten clipping standaard. Hugging Face’ Trainer, PyTorch Lightning en DeepSpeed bieden clipping allemaal aan als standaardconfigoptie. Als je iets traint dat groter is dan een klein speelgoedmodel, is clipping vrijwel zeker onderdeel van de pijplijn.

Het is een toevoeging van één regel die bijna niets kost en voorkomt dat trainingsruns na uren compute crashen. Daarom is het gebleven.

Gradient clipping in PyTorch

PyTorch handelt gradient clipping af met één hulpfunctie: torch.nn.utils.clip_grad_norm_.

De clipping-aanroep komt tussen loss.backward() en optimizer.step(). Backpropagation moet eerst de gradiënten invullen, dan verkleint clipping ze indien nodig, daarna past de optimizer de update toe. De aanroep ergens anders plaatsen werkt niet.

Hier is een complete, uitvoerbare trainingsscript dat een kleine MLP traint op synthetische regressiedata met gradient clipping ingeschakeld:

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

PyTorch-uitvoer

De functie clip_grad_norm_ neemt twee hoofdargumenten:

• parameters: de modelparameters waarvan je de gradiënten wilt clippen. Geef model.parameters() door om het hele model te dekken.

• max_norm: de drempel voor de gradiëntnorm. Een waarde van 1.0 is een gebruikelijk startpunt.

Er is een optioneel norm_type-argument dat standaard 2.0 is voor L2-norm. Dat hoef je zelden te wijzigen.

De underscore aan het eind van clip_grad_norm_ duidt op een in-place operatie. De functie wijzigt de gradiënten direct in het .grad-attribuut van elke parameter, dus je hoeft de retourwaarde niet bij te houden. Hij retourneert wel de totale norm van de gradiënten vóór clipping, handig als je die wilt loggen.

Voor clippen op waarde in plaats van op norm heeft PyTorch torch.nn.utils.clip_grad_value_:

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

Maar zoals eerder besproken zul je deze implementatie zelden (of nooit) gebruiken.

Dat is de volledige setup. Twee regels toegevoegd aan je trainingslus.

Gradient clipping in TensorFlow

TensorFlow handelt clipping af op het niveau van de optimizer in plaats van als een aparte functieaanroep.

Wanneer je een optimizer aanmaakt, geef je clipnorm of clipvalue mee als argument. De optimizer past intern bij elke stap clipping toe, dus je hoeft je trainingslus niet aan te passen.

Hier is een volledig werkend voorbeeld met de Keras-API op synthetische regressiedata:

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)

TensorFlow-uitvoer

De twee argumenten doen verschillende dingen:

• clipnorm clipt op de L2-norm van elke gradiënttensor. Als de norm de drempel overschrijdt, wordt de tensor proportioneel omlaag geschaald.

• clipvalue clipt elk gradiëntelement afzonderlijk. Elke waarde boven de drempel wordt vastgezet op de drempel, en elke waarde onder de negatieve drempel wordt vastgezet op de negatieve drempel.

Om te wisselen van normclipping naar waardeclipping, vervang je simpelweg het argument:

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

Beide argumenten werken met elke Keras-optimizer: Adam, SGD, RMSprop, AdamW en de rest. Er is ook een global_clipnorm-argument dat clipt op basis van de norm berekend over alle gradiënten samen, in plaats van per tensor. Dit komt dichter in de buurt van PyTorch’ standaardgedrag.

Als je een custom trainingslus schrijft met tf.GradientTape, dan handelt de optimizer het clippen nog steeds af wanneer je apply_gradients aanroept:

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))

Dat is het verschil tussen de twee frameworks. PyTorch geeft clipping in jouw handen binnen de lus. TensorFlow verplaatst het naar de optimizer zelf. De achterliggende logica is identiek.

Gradient clipping vs. andere stabilisatietechnieken

Gradient clipping is niet de enige manier om trainen te stabiliseren, en het is niet altijd het juiste middel.

Andere technieken pakken gerelateerde maar andere problemen aan. Sommige voorkomen dat gradiënten überhaupt te groot worden, andere voorkomen dat ze verdwijnen, en weer andere maken het verlieslandschap makkelijker te optimaliseren. Ik laat je een paar technieken zien.

Batchnormalisatie

Batchnormalisatie normaliseert activaties binnen elke minibatch tijdens het trainen.

Het houdt laaguitkomsten binnen een stabiel bereik, waardoor de grootten van gradiënten voorspelbaarder worden. Netwerken met batchnorm verdragen hogere leersnelheden en convergeren sneller, en ze zijn minder gevoelig voor keuzes in gewichtsinitialisatie.

Maar batchnorm stopt exploderende gradiënten niet direct. Het vermindert hoe vaak ze optreden, niet wat je doet als ze optreden. Veel modellen koppelen daarom batchnorm aan gradient clipping.

Residual connections

Residual connections voegen kortere paden toe die één of meer lagen overslaan, zodat gradiënten direct van latere naar eerdere lagen kunnen stromen.

Dit lost het probleem van verdwijnende gradiënten in diepe netwerken op. Zonder residual connections wordt het trainen van netwerken met meer dan 20–30 lagen lastig omdat gradiënten richting nul krimpen tijdens backpropagation. Mét residuals trainen netwerken met honderden lagen probleemloos.

Residual connections richten zich op de tegenovergestelde kant van het gradiëntprobleem vergeleken met clipping. Clipping pakt te grote gradiënten aan. Residuals pakken gradiënten aan die te klein worden.

Zorgvuldige gewichtsinitialisatie

De beginwaarden van je gewichten bepalen de startgrootte van activaties en gradiënten. Slechte initialisatie kan al bij de eerste stap exploderende of verdwijnende gradiënten veroorzaken.

Methoden zoals Xavier- en He-initialisatie schalen initiële gewichten op basis van de laaggrootte. Dit houdt activatievarianties bij de start van het trainen stabiel over lagen heen, wat veel gradiëntproblemen voorkomt.

Goede initialisatie verkleint de kans dat je clipping nodig hebt, maar sluit het niet uit. Gradientpieken kunnen later in het trainen nog steeds opduiken, zeker bij hoge leersnelheden of ongewone batches.

Hoe ze samenkomen

De technieken die ik noemde zijn geen alternatieven. Het zijn complementaire tools die verschillende delen van hetzelfde overkoepelende probleem oplossen.

Een typische moderne trainingssetup gebruikt zorgvuldige initialisatie aan het begin, residual connections in de architectuur, batchnormalisatie (of layernormalisatie) binnen het netwerk en gradient clipping als vangnet tijdens de optimalisatie. Elk pakt een specifieke faalmodus aan en samen maken ze diepe netwerken trainbaar.

Conclusie

Gradient clipping is een van de eenvoudigste fixes in deep learning en lost een probleem op dat uren aan training in één klap kan verpesten.

Het goede nieuws: je hoeft je modelarchitectuur niet te veranderen of je trainingscode te herschrijven. Eén regel in PyTorch of één argument in TensorFlow is genoeg om gradient clipping te implementeren.

Het werkt het best als onderdeel van een groter geheel. Combineer het met zorgvuldige gewichtsinitialisatie, residual connections en batch- of layernormalisatie, en je hebt een trainingspijplijn die instabiliteit van meerdere kanten aanpakt.

Als je loss explodeert, begin met clipping. Als hij verdwijnt, kijk dan elders. En als je iets traint dat groter is dan een klein model, voeg clipping dan standaard toe aan je pijplijn en vergeet het verder.

Gradient clipping is slechts één van de vele termen die elke machine learning engineer moet kennen. Wil je de rest leren en in 2026 klaar zijn voor de arbeidsmarkt? Schrijf je vandaag nog in voor onze Machine Learning Engineer-track.