Gradient Clipping: Cara Mencegah Exploding Gradients

Berapa kali Anda melihat nilai loss NaN saat melatih jaringan saraf dalam (deep neural network)?

Setelah berjam-jam waktu pelatihan, kurva loss terlihat bagus, lalu tiba-tiba melonjak hingga tak terhingga tanpa alasan yang jelas. Penyebabnya biasanya exploding gradients — nilai gradien yang membesar begitu besar selama backpropagation sehingga pembaruan parameter menjadi tidak stabil dan model rusak. Masalah ini paling sering terjadi pada jaringan rekuren, tetapi juga muncul pada transformer dan jaringan feedforward yang dalam.

Gradient clipping mengatasinya dengan membatasi besaran gradien sebelum mencapai optimizer. Ini adalah satu baris tambahan di loop pelatihan Anda yang menjaga pembaruan tetap terbatas tanpa mengubah model apa pun.

Dalam artikel ini, saya akan membahas intuisi di balik gradient clipping, dua metode utamanya, cara memilih ambang batas, dan cara mengimplementasikannya di PyTorch dan TensorFlow.

Namun, apa sebenarnya loss dalam data science? Baca Loss Function in Machine Learning kami untuk mengetahuinya.

Apa Itu Gradient Clipping?

Gradient clipping adalah teknik yang membatasi magnitudo gradien selama pelatihan untuk mencegah pembaruan parameter yang tidak stabil.

Saat gradien menjadi terlalu besar, optimizer mengambil langkah sangat besar di ruang parameter dan mendorong bobot ke wilayah di mana loss meledak. Clipping membantu dengan membatasi ukuran langkah tersebut sebelum menimbulkan kerusakan.

Perlu dicatat bahwa gradient clipping tidak memengaruhi arsitektur model. Anda tidak menambahkan lapisan atau mengubah fungsi aktivasi. Ini hanya memodifikasi proses pelatihan dengan mencegat gradien di antara backpropagation dan langkah optimizer.

Ini membuatnya murah untuk dicoba dan mudah dihapus. Seperti yang akan Anda lihat nanti, hanya perlu satu baris kode.

Cara Kerja Gradient Clipping

Mekanismenya sederhana. Operasi clipping ditempatkan di antara backward pass dan langkah optimizer, dan mengikuti empat langkah yang sama di setiap iterasi.

1. Hitung gradien: Jalankan forward pass, hitung loss, dan lakukan backpropagation. Tidak ada yang berubah di sini, karena gradien mengalir melalui jaringan seperti biasa.
2. Periksa magnitudo gradien: Ukur seberapa besar gradiennya. Bergantung pada metode, ini berarti melihat nilai per elemen atau menghitung norma keseluruhan di seluruh parameter.
3. Kecilkan gradien jika melebihi ambang: Jika magnitudo melampaui batas yang Anda tetapkan, skalakan gradien ke bawah. Jika tidak, biarkan apa adanya.
4. Perbarui parameter model: Teruskan gradien yang sudah di-clip ke optimizer dan terapkan pembaruan bobot.

Sebagian besar waktu, gradien Anda tetap di bawahnya dan pelatihan berjalan seperti tanpa gradient clipping. Saat lonjakan terjadi, clipping menangkapnya sebelum optimizer bereaksi.

Selesai.

Metode Gradient Clipping yang Umum

Ada dua cara untuk melakukan clipping pada gradien, dan perbedaannya bergantung pada apa yang diukur dan apa yang diskalakan.

Clip by value

Clip by value membatasi setiap elemen gradien secara individual.

Anda memilih rentang, misalnya [-1.0, 1.0], dan nilai gradien apa pun di luar rentang itu akan dibulatkan ke batas terdekat. Gradien 2.5 menjadi 1.0. Gradien -2.5 menjadi -1.0. Nilai yang sudah berada di dalam rentang tetap tidak berubah.

Contoh clip by value

Daya tariknya adalah kesederhanaannya. Tidak ada matematika selain operasi min/maks, dan cepat dijalankan.

Namun pendekatan ini punya kelemahan. Melakukan clipping pada nilai individual mengubah arah vektor gradien. Jika satu komponen terkena clipping dan yang lain tidak, vektor yang diperbarui tidak lagi menunjuk ke arah yang dianjurkan backpropagation. Optimizer Anda akhirnya melangkah ke arah yang sedikit salah.

Itulah sebabnya clip by value lebih jarang digunakan dalam praktik.

Clip by norm

Clip by norm menskalakan seluruh vektor gradien ketika magnitudo keseluruhannya melebihi ambang batas.

Alih-alih melihat nilai per elemen, ia menghitung norma semua gradien bersama-sama (biasanya norma L2) dan membandingkannya dengan nilai maksimum. Jika normanya di bawah ambang, tidak ada yang terjadi. Jika di atas, setiap gradien dikalikan dengan faktor penskalaan yang sama untuk menurunkan kembali norma ke batasnya.

Contoh clip by norm

Keunggulannya adalah pelestarian arah. Karena setiap komponen menyusut dengan faktor yang sama, vektor gradien masih menunjuk ke arah semula. Anda hanya memperpendek langkahnya, bukan mengubah arahnya.

Inilah mengapa clip by norm menjadi standar. clip_grad_norm_ milik PyTorch dan clipnorm milik TensorFlow sama-sama menerapkan metode ini, dan sebagian besar pipeline pelatihan modern menggunakannya secara default.

Exploding Gradients vs Vanishing Gradients

Exploding dan vanishing gradients adalah masalah umum dalam deep learning, tetapi hanya salah satunya yang diatasi oleh gradient clipping.

Exploding gradients

Exploding gradients terjadi ketika nilai gradien membesar terlalu besar selama backpropagation.

Ini biasanya muncul pada jaringan yang dalam atau arsitektur rekuren, di mana gradien dikalikan di banyak lapisan atau langkah waktu. Jika perkalian tersebut terakumulasi ke arah yang salah, magnitudo gradien membesar. Optimizer kemudian membuat pembaruan parameter yang sangat besar, bobot melonjak ke nilai ekstrem, dan loss sering berubah menjadi NaN atau Inf.

Anda akan melihatnya sebagai lonjakan loss mendadak atau model yang tiba-tiba menyimpang.

Vanishing gradients

Vanishing gradients adalah kebalikan dari masalah tersebut. Nilai gradien menyusut menuju nol saat dipropagasikan ke belakang melalui jaringan.

Saat gradien terlalu kecil, pembaruan bobot menjadi sangat kecil. Lapisan awal berhenti belajar, lapisan lebih dalam belajar dengan lambat, dan pelatihan praktis terhenti. Kurva loss menjadi datar dan tidak membaik, bahkan setelah banyak epoch.

Ini adalah alasan utama RNN kesulitan dengan urutan panjang sebelum LSTM dan GRU hadir.

Posisi gradient clipping

Gradient clipping mengatasi exploding gradients, bukan vanishing gradients.

Clipping mengecilkan gradien yang terlalu besar, tetapi tidak melakukan apa-apa saat gradien terlalu kecil. Untuk vanishing gradients, Anda memerlukan inisialisasi bobot yang lebih baik, residual connection, batch normalization, atau arsitektur yang dirancang untuk menjaga aliran gradien.

Penjelasan Gradient Clipping by Norm

Clipping by norm adalah metode yang paling banyak dicari orang saat mereka mencari informasi tentang gradient clipping.

Prosesnya memiliki tiga langkah. Pertama, hitung norma dari semua gradien yang digabungkan. Kedua, bandingkan norma tersebut dengan ambang yang Anda pilih. Ketiga, reskalakan gradien jika normanya terlalu besar.

Norma yang digunakan biasanya norma L2, yang berarti Anda mempangkatkan dua setiap nilai gradien, menjumlahkannya, dan mengambil akar kuadratnya. Jika Anda memiliki gradien g_1, g_2, ..., g_n pada semua parameter model Anda, norma L2 adalah:

Rumus clipping by norm

Setelah Anda memiliki normanya, bandingkan dengan ambang c. Jika ||g|| <= c, gradien diteruskan tanpa perubahan. Jika ||g|| > c, setiap gradien dikalikan dengan faktor penskalaan c / ||g||. Ini menurunkan norma baru tepat menjadi c.

Ini penting karena setiap komponen menyusut dengan faktor yang sama. Proporsi relatif antar nilai gradien tetap tidak berubah, yang berarti vektor masih menunjuk ke arah semula. Anda memperpendek langkah yang diambil optimizer, bukan mengubah tujuannya.

Sifat pelestarian arah inilah yang membuat norm clipping menjadi pilihan default. Clip by value dapat memutar vektor gradien ke arah baru. Clip by norm hanya mengubah panjangnya.

clip_grad_norm_ milik PyTorch dan clipnorm milik TensorFlow melakukan hal yang persis sama. Saat seseorang berkata "Saya menggunakan gradient clipping," hampir selalu yang dimaksud adalah clipping by norm.

Memilih Ambang Gradient Clipping

Ambang adalah hiperparameter, yang berarti tidak ada nilai universal yang cocok untuk setiap model.

Jika Anda menetapkannya terlalu tinggi, clipping hampir tidak pernah aktif. Gradien Anda hampir selalu berada di bawah batas, sehingga jaring pengaman tidak menangkap apa pun. Pelatihan berjalan seolah-olah clipping tidak ada, dan Anda tetap akan melihat lonjakan loss saat gradien meledak.

Jika Anda menetapkannya terlalu rendah, Anda melakukan clipping terlalu agresif. Setiap batch mengalami pengecilan gradien, yang membuat pembaruan bobot lebih kecil daripada yang seharusnya. Pembelajaran melambat dan model Anda membutuhkan waktu lebih lama untuk konvergen, terkadang jauh lebih lama.

Titik awal yang umum adalah 1.0, yang bekerja baik untuk banyak arsitektur. Nilai antara 0.5 dan 5.0 mencakup sebagian besar kasus penggunaan praktis.

Pendekatan yang lebih baik adalah memantau norma gradien Anda selama pelatihan. Catat norma yang belum di-clip di setiap langkah dan lihat distribusinya. Jika sebagian besar norma berada di sekitar 0.3 dengan lonjakan sesekali hingga 50, tetapkan ambang di atas rentang tipikal tetapi jauh di bawah lonjakan — 2.0 atau 3.0 akan masuk akal di sini.

Perlakukan seperti hiperparameter lainnya. Mulai dari 1.0, amati apa yang terjadi, dan sesuaikan berdasarkan perilaku pelatihan.

Gradient Clipping pada Recurrent Neural Networks

RNN adalah tempat gradient clipping pertama kali menjadi teknik standar.

Alasannya adalah cara RNN mempropagasikan gradien melalui waktu. Backpropagation through time mengalikan matriks bobot yang sama di banyak langkah waktu, dan perkalian berulang tersebut dapat terakumulasi menjadi nilai yang sangat besar. Urutan yang panjang memperparah masalah.

LSTM dan GRU mengurangi masalah dengan mekanisme gating mereka, tetapi tidak menghilangkannya. Kedua arsitektur tersebut tetap diuntungkan dari clipping, terutama saat melatih pada urutan panjang atau dengan learning rate tinggi.

Untuk pelatihan RNN, clip by norm dengan ambang antara 1.0 dan 5.0 adalah default yang umum. Jika Anda menggunakan nn.LSTM atau nn.GRU milik PyTorch dan loss Anda meledak selama pelatihan, menambahkan clip_grad_norm_ biasanya hal pertama yang dicoba.

Gradient Clipping dalam Deep Learning Modern

Gradient clipping tidak lenyap ketika transformer menggantikan RNN.

Model bahasa besar seperti GPT dan BERT menggunakan clipping selama pretraining dan fine-tuning. Hal yang sama berlaku untuk vision transformer, diffusion model, dan sebagian besar arsitektur dalam dengan ratusan lapisan. Optimizer Adam dan AdamW, yang mendominasi pelatihan modern, sering dipasangkan dengan norm clipping pada ambang sekitar 1.0.

Alasannya sama seperti pada RNN. Jaringan yang dalam mengalikan gradien di banyak lapisan, dan ukuran batch yang besar dikombinasikan dengan learning rate tinggi dapat menghasilkan lonjakan gradien sesekali. Clipping menangani lonjakan tersebut tanpa memengaruhi langkah pelatihan normal.

Sebagian besar implementasi referensi menyertakan clipping secara default. Trainer dari Hugging Face, PyTorch Lightning, dan DeepSpeed semuanya menyediakan clipping sebagai opsi konfigurasi standar. Jika Anda melatih apa pun yang lebih besar dari model kecil mainan, clipping hampir pasti menjadi bagian dari pipeline.

Ini adalah tambahan satu baris yang nyaris tanpa biaya dan mencegah proses pelatihan mogok setelah berjam-jam komputasi. Itulah mengapa teknik ini tetap digunakan.

Gradient Clipping di PyTorch

PyTorch menangani gradient clipping dengan satu fungsi utilitas: torch.nn.utils.clip_grad_norm_.

Panggilan clipping ditempatkan di antara loss.backward() dan optimizer.step(). Backpropagation harus mengisi gradien terlebih dahulu, lalu clipping mengecilkannya jika perlu, kemudian optimizer menerapkan pembaruan. Menempatkan panggilan di tempat lain tidak akan berhasil.

Berikut skrip pelatihan lengkap yang dapat dijalankan untuk melatih MLP kecil pada data regresi sintetis dengan gradient clipping diaktifkan:

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

Keluaran PyTorch

Fungsi clip_grad_norm_ menerima dua argumen utama:

• parameters: parameter model yang gradiennya ingin Anda clip. Berikan model.parameters() untuk mencakup seluruh model.

• max_norm: ambang untuk norma gradien. Nilai 1.0 adalah titik awal yang umum.

Ada argumen opsional norm_type yang default-nya 2.0 untuk norma L2. Anda jarang perlu mengubahnya.

Garis bawah pada clip_grad_norm_ menandakan operasi in-place. Fungsi ini memodifikasi gradien langsung di atribut .grad setiap parameter, jadi Anda tidak perlu melacak nilai kembalinya. Fungsi ini memang mengembalikan norma total gradien sebelum clipping, yang berguna jika Anda ingin mencatatnya.

Untuk clip-by-value alih-alih clip-by-norm, PyTorch memiliki torch.nn.utils.clip_grad_value_:

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

Namun seperti dibahas sebelumnya, Anda jarang (kalau pun pernah) menggunakan implementasi ini.

Itulah seluruh pengaturannya. Dua baris ditambahkan ke loop pelatihan Anda.

Gradient Clipping di TensorFlow

TensorFlow menangani clipping di level optimizer, bukan sebagai panggilan fungsi terpisah.

Saat Anda membuat optimizer, Anda memberikan clipnorm atau clipvalue sebagai argumen. Optimizer menerapkan clipping secara internal pada setiap langkah, jadi Anda tidak perlu memodifikasi loop pelatihan sama sekali.

Berikut contoh lengkap yang berfungsi menggunakan API Keras pada data regresi sintetis:

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)

Keluaran TensorFlow

Kedua argumen melakukan hal yang berbeda:

• clipnorm melakukan clipping berdasarkan norma L2 dari setiap tensor gradien. Jika normanya melebihi ambang, tensor diskalakan turun secara proporsional.

• clipvalue melakukan clipping secara individual untuk setiap elemen gradien. Nilai apa pun di atas ambang akan dijepit ke ambang tersebut, dan nilai apa pun di bawah ambang negatif akan dijepit ke ambang negatif.

Untuk beralih dari norm clipping ke value clipping, cukup ganti argumennya:

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

Kedua argumen bekerja pada setiap optimizer Keras: Adam, SGD, RMSprop, AdamW, dan lainnya. Ada juga argumen global_clipnorm yang melakukan clipping berdasarkan norma yang dihitung di seluruh gradien gabungan, bukan per-tensor. Ini lebih sesuai dengan perilaku default PyTorch.

Jika Anda menulis loop pelatihan kustom dengan tf.GradientTape, optimizer tetap menangani clipping saat Anda memanggil 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))

Itulah perbedaan antara kedua framework. PyTorch menempatkan clipping di tangan Anda di dalam loop. TensorFlow mendorongnya ke dalam optimizer itu sendiri. Logika dasarnya sama.

Gradient Clipping vs Teknik Stabilisasi Lain

Gradient clipping bukan satu-satunya cara untuk menstabilkan pelatihan, dan tidak selalu menjadi alat yang tepat untuk setiap pekerjaan.

Teknik lain menangani masalah terkait tetapi berbeda. Beberapa mencegah gradien membesar sejak awal, yang lain mencegahnya menghilang, dan sebagian hanya membuat permukaan loss lebih mudah dioptimalkan. Berikut beberapa teknik yang berbeda.

Batch normalization

Batch normalization menormalkan aktivasi dalam setiap mini-batch selama pelatihan.

Ini menjaga keluaran lapisan dalam rentang yang stabil, sehingga magnitudo gradien lebih dapat diprediksi. Jaringan yang dilatih dengan batch norm mentoleransi learning rate yang lebih tinggi dan konvergen lebih cepat, serta kurang sensitif terhadap pilihan inisialisasi bobot.

Namun batch norm tidak secara langsung menghentikan ledakan gradien. Ini mengurangi frekuensi kejadiannya, bukan menangani saat kejadian itu muncul. Banyak model tetap memasangkan batch norm dengan gradient clipping karena alasan tersebut.

Residual connections

Residual connection menambahkan jalur pintas yang melewati satu atau lebih lapisan, memungkinkan gradien mengalir langsung dari lapisan belakangan ke lapisan lebih awal.

Ini menyelesaikan masalah vanishing gradient pada jaringan yang dalam. Tanpa residual connection, melatih jaringan dengan lebih dari 20–30 lapisan menjadi sulit karena gradien menyusut menuju nol saat dipropagasikan ke belakang. Dengan residual connection, jaringan dengan ratusan lapisan dapat dilatih tanpa masalah.

Residual connection menargetkan sisi berlawanan dari masalah gradien dibandingkan clipping. Clipping menangani gradien yang terlalu besar. Residual menangani gradien yang terlalu kecil.

Inisialisasi bobot yang cermat

Nilai awal bobot Anda menentukan magnitudo awal aktivasi dan gradien. Inisialisasi yang buruk dapat menyebabkan gradien meledak atau menghilang sejak langkah pertama.

Metode seperti inisialisasi Xavier dan He menskalakan bobot awal berdasarkan ukuran lapisan. Ini menjaga varians aktivasi tetap stabil di seluruh lapisan pada awal pelatihan, yang mencegah banyak masalah gradien sebelum terjadi.

Inisialisasi yang baik mengurangi kemungkinan Anda memerlukan clipping, tetapi tidak menghilangkannya. Lonjakan gradien masih dapat muncul di kemudian hari selama pelatihan, terutama dengan learning rate tinggi atau batch yang tidak biasa.

Kaitan antar teknik

Teknik-teknik yang saya sebutkan bukanlah alternatif. Ini adalah alat yang saling melengkapi yang menyelesaikan bagian-bagian berbeda dari masalah yang sama secara keseluruhan.

Pengaturan pelatihan modern yang khas menggunakan inisialisasi yang cermat di awal, residual connection dalam arsitektur, batch normalization (atau layer normalization) di dalam jaringan, dan gradient clipping sebagai jaring pengaman selama optimisasi. Masing-masing menangani mode kegagalan tertentu, dan bersama-sama membuat jaringan yang dalam dapat dilatih.

Kesimpulan

Gradient clipping adalah salah satu perbaikan tersederhana dalam deep learning, dan mengatasi masalah yang dapat merusak berjam-jam pelatihan hanya dalam satu langkah.

Kabar baiknya, Anda tidak perlu mengubah arsitektur model atau menulis ulang kode pelatihan. Satu baris di PyTorch atau satu argumen di TensorFlow sudah cukup untuk menerapkan gradient clipping.

Teknik ini bekerja paling baik sebagai bagian dari pengaturan yang lebih besar. Pasangkan dengan inisialisasi bobot yang cermat, residual connection, dan batch atau layer normalization, dan Anda akan memiliki pipeline pelatihan yang menangani ketidakstabilan dari berbagai sisi.

Jika loss Anda meledak, mulailah dengan clipping. Jika menghilang, cari solusi lain. Dan jika Anda melatih apa pun yang lebih besar dari model kecil, tambahkan clipping ke pipeline Anda secara default dan lupakan saja.

Gradient clipping hanyalah salah satu dari banyak istilah yang harus diketahui setiap engineer machine learning. Jika Anda ingin mempelajari yang lain dan siap kerja pada 2026, daftarlah ke Machine Learning Engineer track kami hari ini.