KAL
Menu

Autograd

Membiarkan PyTorch menghitung gradien secara otomatis dan memeriksanya.

Daftar isi

Autograd adalah mesin diferensiasi otomatis PyTorch yang merekam setiap operasi pada tensor yang memerlukannya, lalu menghitung gradien dengan satu panggilan backward(). Topik ini menjelaskan cara grafik komputasi dibangun, aturan-aturan yang sering mengejutkan pemula seperti akumulasi gradien, dan posisi autograd di dalam siklus pelatihan. Setelah selesai, mekanika yang pada topik sebelumnya dihitung tangan sepenuhnya diserahkan kepada pustaka tanpa kehilangan pemahaman.

Grafik komputasi yang direkam otomatis#

Setiap tensor di PyTorch membawa bendera requires_grad. Ketika operasi melibatkan tensor semacam itu, PyTorch mencatat operasinya ke dalam grafik komputasi yang simpulnya adalah tensor dan sisinya adalah fungsi. Tensor yang dibuat langsung oleh pengguna disebut daun (leaf), sedangkan tensor hasil operasi menjadi simpul antara. Panggilan backward() kemudian berjalan dari simpul loss ke daun, persis mengulang proses backpropagation.

Kode berikut membangun grafik kecil dan memeriksa sifat-sifat dasarnya, sehingga perbedaan daun dan simpul antara terlihat pada atributnya.

python Contoh: grafik komputasi dan sifat tensor 
import torch

w = torch.tensor(1.5, requires_grad=True)
b = torch.tensor(0.5, requires_grad=True)
x = torch.tensor(3.0)
y = w * x + b
loss = (y - 2.0) ** 2

print("w.requires_grad :", w.requires_grad)
print("y.requires_grad :", y.requires_grad)
print("y.grad_fn       :", type(y.grad_fn).__name__)
loss.backward()
print("dL/dw =", w.grad.item(), "| dL/db =", b.grad.item())
text Keluaran 
w.requires_grad : True
y.requires_grad : True
y.grad_fn       : AddBackward0
dL/dw = 18.0 | dL/db = 6.0

Keluarannya memperlihatkan bahwa x tanpa requires_grad tidak masuk perhitungan gradien, sedangkan y otomatis mewarisinya dan membawa grad_fn penanda operasinya. Angka gradien dapat diperiksa manual, yaitu dLdw=2(wx+b−2)⋅x=2⋅3⋅3=18 \frac{dL}{dw} = 2(w x + b - 2) \cdot x = 2 \cdot 3 \cdot 3 = 18 dan dLdb=6 \frac{dL}{db} = 6 , Dengan begitu, kepercayaan pada autograd dapat dibangun dari contoh kecil sebelum dipakai pada jaringan besar.

Tiga aturan yang sering mengejutkan pemula#

Aturan pertama adalah gradien terakumulasi. Setiap panggilan backward() menambahkan nilai baru ke .grad yang sudah ada, bukan menggantinya, karena desain itu dimaksudkan untuk kasus loss yang dijumlahkan dari beberapa bagian. Konsekuensinya, loop pelatihan wajib mengosongkan gradien setiap langkah dengan optimizer.zero_grad(), dan kelalaian inilah penyebab error paling klasik ketika loss tiba-tiba naik setelah beberapa langkah.

python Contoh: akumulasi gradien dan pengosongannya 
import torch

w = torch.tensor(2.0, requires_grad=True)

(w * 3.0).backward()
print("setelah backward 1:", w.grad.item())
(w * 3.0).backward()
print("setelah backward 2:", w.grad.item())

w.grad.zero_()
(w * 3.0).backward()
print("setelah zero_grad :", w.grad.item())
text Keluaran 
setelah backward 1: 3.0
setelah backward 2: 6.0
setelah zero_grad : 3.0

Aturan kedua adalah backward() mengharapkan loss skalar. Apabila keluarannya berbentuk tensor, argumen gradient harus diberikan, dan dalam praktik loss selalu direduksi menjadi skalar dengan rata-rata atau penjumlahan. Aturan ketiga menyatakan grafik dibongkar setelah backward() selesai, sehingga memanggil backward() kedua kali pada grafik yang sama menimbulkan error. Untuk kasus yang memang membutuhkannya, opsi retain_graph=True tersedia, sedangkan mode torch.no_grad() berperan sebaliknya, yaitu mencegah perekaman sama sekali pada inference dan evaluasi.

Autograd di dalam siklus pelatihan#

Siklus pelatihan standar terdiri atas tiga panggilan yang berulang, yaitu optimizer.zero_grad(), loss.backward(), dan optimizer.step(). Baris pertama mengosongkan gradien hasil langkah sebelumnya, baris kedua merekam serta menjalankan backpropagation pada loss batch saat ini, dan baris ketiga memperbarui parameter sejauh learning rate yang ditetapkan optimizer. Ketiganya akan muncul di hampir setiap loop pelatihan selanjutnya, dan setiap perannya kini diketahui asal-usulnya.

Satu kebiasaan evaluasi perlu ditetapkan sejak sekarang. Perhitungan metrik pada data validasi tidak membutuhkan gradien, sehingga seluruh blok evaluasi dibungkus with torch.no_grad(): untuk menghemat memori dan waktu. Kebiasaan ini terlihat pada topik Layer dan MLP saat menyalin bobot, dan akan berulang pada setiap evaluasi di modul Disiplin pelatihan.

Batas tanggung jawab autograd#

Autograd menghitung gradien dengan benar untuk apa pun yang dituliskan, tetapi ia tidak menilai apakah grafiknya benar. Kekeliruan seperti memakai detach() di tempat yang salah, membangun ulang tensor tanpa requires_grad, atau membungkus target yang seharusnya ikut belajar semuanya menghasilkan angka yang tampak wajar tanpa peringatan. Ritual debug pada modul Disiplin pelatihan, terutama overfit satu batch, adalah pemeriksaan yang menangkap kekeliruan semacam itu.

Dengan autograd, sisa mekanika pelatihan tinggal memilih cara memperbarui parameter dengan gradien yang sudah tersedia, dan itulah isi topik Varian SGD.

Ringkasan#

  • Autograd merekam grafik komputasi dari tensor berbendera requires_grad dan menghitung gradien daunnya lewat backward().
  • Gradien terakumulasi antar panggilan, sehingga zero_grad() wajib di awal setiap langkah pelatihan.
  • Loss harus berupa skalar, grafik dibongkar setelah backward(), dan no_grad() mencegah perekaman saat evaluasi.
  • Siklus zero_grad, backward, step adalah pola yang dipakai ulang di seluruh jalur.

Referensi#