Gradyan Kırpma: Patlayan Gradyanları Nasıl Önlersiniz

Derin bir sinir ağını eğitirken kaç kez NaN bir kayıp değeri gördünüz?

Saatler süren eğitimden sonra kayıp eğrisi sağlıklı görünür ve sonra aniden sonsuza fırlar. Bunun nedeni genellikle patlayan gradyanlardır — geri yayılım sırasında öyle büyüyen gradyan değerleri ki, parametre güncellemeleri kararsız hale gelir ve model bozulur. Bu sorun en çok yinelemeli ağları vurur, ancak transformer’larda ve derin ileri beslemeli ağlarda da ortaya çıkar.

Gradyan kırpma, gradyanlar optimizere ulaşmadan önce boyutlarını kısıtlayarak bunu çözer. Eğitim döngünüze tek satırlık bir eklemedir; modeli değiştirmeden güncellemeleri sınırlı tutar.

Bu yazıda, gradyan kırpmanın arkasındaki sezgiyi, iki ana yöntemi, eşik seçimini ve PyTorch ile TensorFlow’da nasıl uygulanacağını ele alacağım.

Peki veri biliminde kayıp tam olarak nedir? Öğrenmek için Makine Öğreniminde Kayıp Fonksiyonu blog yazımızı okuyun.

Gradyan Kırpma Nedir?

Gradyan kırpma, eğitim sırasında gradyanların büyüklüğünü sınırlayarak kararsız parametre güncellemelerini önleyen bir tekniktir.

Bir gradyan çok büyüdüğünde, optimizer parametre uzayında kocaman bir adım atar ve ağırlıkları kaybın patladığı bir bölgeye iter. Kırpma, bu adım boyutunu zarara yol açmadan önce sınırlandırarak yardımcı olur.

Şunu not etmek önemlidir: gradyan kırpma model mimarisini etkilemez. Katman eklemez veya aktivasyon fonksiyonlarını değiştirmezsiniz. Sadece geri yayılım ile optimizer adımı arasında gradyanları yakalayarak eğitim sürecini değiştirir.

Bu da denemeyi ucuz, kaldırmayı kolay kılar. Birazdan göreceğiniz gibi, sadece tek satır kod yeterlidir.

Gradyan Kırpma Nasıl Çalışır

Mekanik basittir. Kırpma işlemi geri yayılımın ve optimizer adımının arasına yerleştirilir ve her yinelemede aynı dört adımı izler.

1. Gradyanları hesaplayın: İleri geçişi çalıştırın, kaybı hesaplayın ve geri yayılımı gerçekleştirin. Burada hiçbir şey değişmez; gradyanlar her zamanki gibi ağdan akar.
2. Gradyan büyüklüğünü kontrol edin: Gradyanların ne kadar büyük olduğunu ölçün. Yönteme bağlı olarak bu, tek tek değerlere bakmak ya da tüm parametreler boyunca toplam normu hesaplamak anlamına gelir.
3. Eşik değeri aşılırsa gradyanları azaltın: Büyüklük, belirlediğiniz sınırı geçerse gradyanları ölçekleyerek küçültün. Geçmiyorsa olduğu gibi bırakın.
4. Model parametrelerini güncelleyin: Kırpılmış gradyanları optimizere iletin ve ağırlık güncellemesini uygulayın.

Çoğu zaman gradyanlarınız bu değerin altında kalır ve eğitim, gradyan kırpma yokmuş gibi ilerler. Bir sıçrama olduğunda, optimizer tepki vermeden önce kırpma onu yakalar.

Hepsi bu.

Yaygın Gradyan Kırpma Yöntemleri

Gradyanları kırpmanın iki yolu vardır; fark, neyi ölçtüğünüz ve neyi ölçeklediğinizle ilgilidir.

Değere göre kırpma

Değere göre kırpma, her bir gradyan öğesini tek tek sınırlar.

Bir aralık seçersiniz, örneğin [-1.0, 1.0] ve bu aralığın dışındaki herhangi bir gradyan değeri en yakın sınıra yuvarlanır. 2.5 olan bir gradyan 1.0 olur. -2.5 olan bir gradyan -1.0 olur. Zaten aralığın içinde olan değerler değişmeden kalır.

Değere göre kırpma örneği

Cazibesi sadeliğidir. En küçük/en büyük işleminden öte bir matematik yoktur ve çalıştırması hızlıdır.

Ancak bu yaklaşımın bir dezavantajı vardır. Tek tek değerleri kırpmak, gradyan vektörünün yönünü değiştirir. Bir bileşen kırpılır, diğerleri kırpılmazsa, güncellenmiş vektör artık geri yayılımın işaret ettiği yöne bakmaz. Optimizer, biraz yanlış bir yöne adım atmış olur.

Bu nedenle uygulamada değere göre kırpma daha az yaygındır.

Norma göre kırpma

Norma göre kırpma, genel büyüklüğü bir eşiği aştığında tüm gradyan vektörünü ölçekler.

Tek tek değerlere bakmak yerine, tüm gradyanların normunu (genellikle L2 normu) birlikte hesaplar ve bunu bir maksimum değerle karşılaştırır. Norm eşik değerin altındaysa hiçbir şey olmaz. Üstündeyse, normu sınıra geri getirmek için her gradyan aynı ölçekleme faktörüyle çarpılır.

Norma göre kırpma örneği

Avantajı yönün korunmasıdır. Her bileşen aynı oranda küçüldüğü için gradyan vektörü hâlâ orijinal yöne bakar. Yalnızca adımı kısaltırsınız, yönünü değiştirmezsiniz.

Bu nedenle norma göre kırpma standart haline gelmiştir. PyTorch’un clip_grad_norm_ ve TensorFlow’un clipnorm işlevleri bu yöntemi uygular ve çoğu modern eğitim hattı bunu varsayılan olarak kullanır.

Patlayan Gradyanlar ve Sönen Gradyanlar

Patlayan ve sönen gradyanlar derin öğrenmede yaygın sorunlardır; ancak gradyan kırpmanın çözdüğü yalnızca bunlardan biridir.

Patlayan gradyanlar

Patlayan gradyanlar, gradyan değerleri geri yayılım sırasında çok büyüdüğünde ortaya çıkar.

Bu genellikle derin ağlarda veya yinelemeli mimarilerde görülür; gradyanlar birçok katman veya zaman adımı boyunca çarpılır. Bu çarpmalar yanlış yönde bileşirse, gradyan büyüklüğü uçar. Optimizer ardından dev bir parametre güncellemesi yapar, ağırlıklar aşırı değerlere zıplar ve kayıp sıklıkla NaN ya da Inf olur.

Bunu ani kayıp sıçramalarıyla ya da bir anda sapıtan bir model olarak görürsünüz.

Sönen gradyanlar

Sönen gradyanlar bunun tam tersidir. Gradyan değerleri ağ boyunca geri yayılırken sıfıra doğru küçülür.

Gradyanlar çok küçüldüğünde, ağırlık güncellemeleri de küçülür. Erken katmanlar öğrenmeyi bırakır, derin katmanlar yavaş öğrenir ve eğitim adeta durur. Kayıp eğrisi yataylaşır ve birçok epoch sonrasında bile iyileşmez.

LSTM ve GRU’lar gelmeden önce RNN’lerin uzun dizilerle zorlanmasının başlıca nedeni buydu.

Gradyan kırpmanın yeri

Gradyan kırpma, sönen gradyanları değil patlayan gradyanları ele alır.

Kırpma, çok büyük olan gradyanları küçültür; ancak gradyanlar çok küçük olduğunda hiçbir şey yapmaz. Sönen gradyanlar için daha iyi ağırlık başlatma, artık bağlantılar (residual connections), katman/batch normu veya gradyan akışını korumak üzere tasarlanmış mimariler gerekir.

Norma Göre Gradyan Kırpma Açıklaması

Norma göre kırpma, gradyan kırpma arayanların çoğunun aslında istediği yöntemdir.

Süreç üç adımdan oluşur. Birincisi, tüm gradyanların birlikte normunu hesaplayın. İkincisi, bu normu seçtiğiniz eşikle karşılaştırın. Üçüncüsü, norm çok büyükse gradyanları yeniden ölçekleyin.

Norm genellikle L2 normudur; yani her gradyan değerini kareler, toplar ve karekökünü alırsınız. Tüm model parametreleri boyunca g_1, g_2, ..., g_n gradyanlarına sahipseniz, L2 normu şöyledir:

Norma göre kırpma formülü

Normu elde ettiğinizde, bunu c eşiğiyle karşılaştırırsınız. ||g|| <= c ise gradyanlar değişmeden geçer. ||g|| > c ise her gradyan c / ||g|| ölçekleme faktörüyle çarpılır. Bu, yeni normu tam olarak c değerine indirir.

Bu önemlidir çünkü her bileşen aynı oranda küçülür. Gradyan değerleri arasındaki göreli oranlar değişmez; yani vektör hâlâ orijinal yöne bakar. Optimizer’ın attığı adımı kısaltırsınız, gittiği yönü değil.

Yönü koruyan bu özellik, norm kırpmayı varsayılan seçim yapar. Değere göre kırpma gradyan vektörünü yeni bir yöne büker. Norma göre kırpma sadece uzunluğunu değiştirir.

PyTorch’un clip_grad_norm_ ve TensorFlow’un clipnorm işlevleri tam olarak bunu yapar. Biri “Gradyan kırpma kullanıyorum” dediğinde neredeyse her zaman norma göre kırpmayı kastediyordur.

Gradyan Kırpma Eşiği Seçimi

Eşik bir hiperparametredir; yani her model için işe yarayan evrensel bir değer yoktur.

Çok yüksek ayarlarsanız kırpma neredeyse hiç devreye girmez. Gradyanlar neredeyse her zaman sınırın altında kalır, dolayısıyla güvenlik ağı hiçbir şeyi yakalamaz. Eğitim sanki kırpma yokmuş gibi ilerler ve gradyanlar patladığında yine kayıp sıçramaları görürsünüz.

Çok düşük ayarlarsanız, aşırı kırpma yapmış olursunuz. Her yığın gradyanlarını küçültür, bu da ağırlık güncellemelerini olması gerekenden daha küçük yapar. Öğrenme yavaşlar ve modelinizin yakınsaması daha uzun sürer, bazen çok daha uzun.

Yaygın bir başlangıç noktası 1.0’dır ve birçok mimari için iyi çalışır. 0.5 ile 5.0 arasındaki değerler çoğu pratik kullanım durumunu kapsar.

Daha iyi yaklaşım, eğitim sırasında gradyan normlarınızı izlemektir. Her adımda kırpılmamış normu kaydedin ve dağılıma bakın. Çoğu norm 0.3 civarında, ara sıra 50’ye sıçrıyorsa, eşiği tipik aralığın üstünde ama sıçramaların epey altında bir yere koyun — burada 2.0 ya da 3.0 makul olur.

Bunu diğer hiperparametreler gibi ele alın. 1.0 ile başlayın, ne olduğuna bakın ve eğitim davranışına göre ayarlayın.

Yinelemeli Sinir Ağlarında Gradyan Kırpma

Gradyan kırpma, ilk olarak RNN’lerde standart bir teknik haline geldi.

Sebebi, RNN’lerin gradyanları zamana göre yayma şeklidir. Zamana göre geri yayılım, aynı ağırlık matrislerini birçok zaman adımı boyunca çarpar ve bu tekrarlı çarpmalar devasa değerlere bileşebilir. Uzun diziler sorunu daha da kötüleştirir.

LSTM ve GRU’lar kapı mekanizmalarıyla sorunu azalttı, ancak tamamen ortadan kaldırmadı. Her iki mimari de özellikle uzun dizilerde eğitim yaparken veya yüksek öğrenme oranlarıyla çalışırken kırpmadan faydalanır.

RNN eğitimi için, 1.0 ile 5.0 arasında bir eşikle norma göre kırpma tipik varsayılandır. PyTorch’un nn.LSTM veya nn.GRU sınıflarını kullanıyor ve kaybınız eğitim sırasında patlıyorsa, clip_grad_norm_ eklemek genellikle ilk denenecek şeydir.

Modern Derin Öğrenmede Gradyan Kırpma

Transformer’lar RNN’lerin yerini aldığında gradyan kırpma ortadan kaybolmadı.

GPT ve BERT gibi büyük dil modelleri, ön eğitim ve ince ayar sırasında kırpmayı kullanır. Aynısı görüş transformer’ları, difüzyon modelleri ve yüzlerce katmanlı çoğu derin mimari için de geçerlidir. Modern eğitimde baskın olan Adam ve AdamW optimizer’ları, çoğu zaman yaklaşık 1.0 eşiklerinde norm kırpmayla eşleştirilir.

Sebep RNN’lerdekiyle aynıdır. Derin ağlar, gradyanları birçok katman boyunca çarpar ve büyük yığın boyutlarıyla yüksek öğrenme oranlarının birleşimi ara sıra gradyan sıçramaları üretebilir. Kırpma, normal eğitim adımlarını etkilemeden bu sıçramaları yönetir.

Çoğu referans uygulama varsayılan olarak kırpmayı içerir. Hugging Face’in Trainer bileşeni, PyTorch Lightning ve DeepSpeed, kırpmayı standart bir yapılandırma seçeneği olarak sunar. Küçük bir oyuncak modelden daha büyük bir şeyi eğitiyorsanız, kırpma neredeyse kesinlikle hattın bir parçasıdır.

Neredeyse hiçbir maliyeti olmayan tek satırlık bir eklemedir ve saatlerce hesaplama sonrası eğitim çalıştırmalarının çökmesini engeller. Bu yüzden kalıcı oldu.

PyTorch’ta Gradyan Kırpma

PyTorch, gradyan kırpmayı tek bir yardımcı işleve bırakır: torch.nn.utils.clip_grad_norm_.

Kırpma çağrısı, loss.backward() ile optimizer.step() arasına gelir. Önce geri yayılımın gradyanları doldurması gerekir, ardından gerekirse kırpma onları küçültür ve son olarak optimizer güncellemeyi uygular. Çağrıyı başka bir yere koymak işe yaramaz.

İşte, gradyan kırpmanın etkin olduğu, sentetik regresyon verisi üzerinde küçük bir MLP’yi eğiten eksiksiz ve çalıştırılabilir bir eğitim betiği:

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 çıktısı

clip_grad_norm_ işlevi iki ana argüman alır:

• parameters: gradyanlarını kırpmak istediğiniz model parametreleri. Tüm modeli kapsamak için model.parameters() gönderin.

• max_norm: gradyan normu için eşik. 1.0 değeri yaygın bir başlangıç noktasıdır.

Varsayılanı L2 normu olan 2.0 olan isteğe bağlı bir norm_type argümanı vardır. Bunu nadiren değiştirmeniz gerekir.

clip_grad_norm_ adındaki sondaki alt çizgi, yerinde (in-place) bir işlemi ifade eder. İşlev, her parametrenin .grad özniteliği içindeki gradyanları doğrudan değiştirir; bu nedenle dönüş değerini takip etmeniz gerekmez. Kırpma öncesi toplam gradyan normunu döndürür; bu, kaydetmek isterseniz kullanışlıdır.

Değere göre kırpma için PyTorch’ta torch.nn.utils.clip_grad_value_ vardır:

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

Ancak daha önce tartıştığımız gibi, bu uygulamayı nadiren (hatta hiç) kullanırsınız.

Kurulumun tamamı bu kadar. Eğitim döngünüze iki satır eklediniz.

TensorFlow’da Gradyan Kırpma

TensorFlow, kırpmayı ayrı bir işlev çağrısı olarak değil, optimizer düzeyinde ele alır.

Bir optimizer oluşturduğunuzda, argüman olarak clipnorm veya clipvalue geçirirsiniz. Optimizer, her adımda kırpmayı dahili olarak uygular; bu nedenle eğitim döngünüzü hiç değiştirmeniz gerekmez.

İşte Keras API’sini kullanarak sentetik regresyon verisi üzerinde çalışan tam bir örnek:

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 çıktısı

İki argüman farklı işler yapar:

• clipnorm her bir gradyan tensörünü L2 normuna göre kırpar. Norm eşik değeri aşarsa tensör orantılı olarak küçültülür.

• clipvalue her gradyan öğesini tek tek kırpar. Eşik değerin üzerindeki herhangi bir değer eşik değerine, negatif eşik değerin altındaki herhangi bir değer negatif eşik değerine sıkıştırılır.

Norm kırpmadan değere göre kırpmaya geçmek için argümanı değiştirmeniz yeterlidir:

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

Her iki argüman da tüm Keras optimizer’larıyla çalışır: Adam, SGD, RMSprop, AdamW ve diğerleri. Ayrıca, tüm gradyanlar birlikte hesaplanan norma göre kırpma yapan bir global_clipnorm argümanı da vardır. Bu, PyTorch’un varsayılan davranışına daha yakındır.

tf.GradientTape ile özel bir eğitim döngüsü yazıyorsanız, apply_gradients çağrısı yaptığınızda kırpmayı yine optimizer halleder:

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

İki çerçeve arasındaki fark budur. PyTorch, kırpmayı döngünün içine sizin elinize verir. TensorFlow ise bunu doğrudan optimizer’a taşır. Temel mantık aynıdır.

Gradyan Kırpma ve Diğer Stabilizasyon Teknikleri

Gradyan kırpma eğitimi stabilize etmenin tek yolu değildir ve her zaman doğru araç da olmayabilir.

Diğer teknikler ilişkili ama farklı sorunları ele alır. Bazıları gradyanların baştan çok büyümesini engeller, bazıları sönmelerini engeller ve bazıları da kayıp yüzeyini optimize etmeyi kolaylaştırır. Size birkaç farklı tekniği göstereyim.

Batch normalization

Batch normalization, eğitim sırasında her mini yığın içindeki aktivasyonları normalize eder.

Katman çıktılarını istikrarlı bir aralıkta tutar; bu da gradyan büyüklüklerini daha öngörülebilir kılar. Batch norm ile eğitilen ağlar daha yüksek öğrenme oranlarını tolere eder ve daha hızlı yakınsar; ayrıca ağırlık başlatmaya daha az duyarlıdır.

Ancak batch norm gradyan patlamalarını doğrudan durdurmaz. Ne zaman meydana geldiklerinde ne yapılacağını değil, ne sıklıkla meydana geldiklerini azaltır. Bu nedenle birçok model batch normu gradyan kırpmayla birlikte kullanır.

Artık (residual) bağlantılar

Artık bağlantılar, bir veya daha fazla katmanı atlayan kısa yol yolları ekler; böylece gradyanların daha sonraki katmanlardan daha erken katmanlara doğrudan akmasına izin verir.

Bu, derin ağlardaki sönen gradyan sorununu çözer. Artık bağlantılar olmadan, 20–30’dan fazla katmana sahip ağları eğitmek zorlaşır; çünkü gradyanlar geri yayılırken sıfıra doğru küçülür. Onlarla birlikte, yüzlerce katmanlı ağlar sorunsuz eğitilir.

Artık bağlantılar, kırpmanın hedeflediği gradyan sorununun zıt ucunu ele alır. Kırpma, çok büyük gradyanları yönetir. Artık bağlantılar ise çok küçülen gradyanları.

Dikkatli ağırlık başlatma

Ağırlıklarınızın başlangıç değerleri, aktivasyonların ve gradyanların başlangıç büyüklüğünü belirler. Kötü bir başlatma, daha ilk adımdan gradyanların patlamasına veya sönmesine neden olabilir.

Xavier ve He başlatması gibi yöntemler, başlangıç ağırlıklarını katman boyutuna göre ölçekler. Bu, eğitim başlangıcında katmanlar arası aktivasyon varyanslarını istikrarlı tutar ve birçok gradyan sorununu daha ortaya çıkmadan önler.

İyi bir başlatma, kırpmaya ihtiyaç duyma olasılığınızı azaltır; ancak tamamen ortadan kaldırmaz. Özellikle yüksek öğrenme oranlarıyla veya alışılmadık yığınlarla çalışırken eğitimde daha sonra gradyan sıçramaları yine ortaya çıkabilir.

Birlikte nasıl konumlanırlar

Listelediğim bu teknikler alternatif değil. Aynı genel sorunun farklı parçalarını çözen tamamlayıcı araçlardır.

Tipik bir modern eğitim kurulumu; başlangıçta dikkatli başlatmayı, mimaride artık bağlantıları, ağ içinde batch veya katman normalizasyonunu ve optimizasyon sırasında bir güvenlik ağı olarak gradyan kırpmayı kullanır. Her biri belirli bir arıza modunu ele alır ve birlikte derin ağları eğitilebilir kılar.

Sonuç

Gradyan kırpma, derin öğrenmedeki en basit düzeltmelerden biridir ve tek bir adımda saatler süren eğitimi boşa çıkaran bir sorunu çözer.

İyi haber, model mimarinizi değiştirmeniz veya eğitim kodunuzu yeniden yazmanız gerekmez. PyTorch’ta tek satır, TensorFlow’da tek bir argüman, gradyan kırpmayı uygulamak için yeterlidir.

En iyi, daha büyük bir kurulumun parçası olarak çalışır. Bunu dikkatli ağırlık başlatma, artık bağlantılar ve batch ya da katman normu ile eşleştirin; böylece çok yönlü olarak istikrarsızlığı yöneten bir eğitim hattınız olur.

Kayıp değeriniz patlıyorsa, kırpmayla başlayın. Sönüyorsa, başka çözümlere bakın. Ve küçük bir modelden daha büyük bir şeyi eğitiyorsanız, kırpmayı varsayılan olarak hattınıza ekleyin ve unutun.

Gradyan kırpma, her makine öğrenimi mühendisinin bilmesi gereken birçok terimden yalnızca biridir. Diğerlerini öğrenmek ve 2026’da işe hazır olmak istiyorsanız, bugün Machine Learning Engineer öğrenim yolumuza kaydolun.