KAL
Menu

Batch dan epoch

Pelatihan mini-batch, sifat stokastiknya, dan struktur satu epoch.

Daftar isi

Batch adalah sekumpulan contoh yang diproses bersama dalam satu langkah pelatihan, dan epoch adalah satu putaran lengkap melewati seluruh data pelatihan. Topik ini menjelaskan struktur pelatihan mini-batch, menuliskan loop epoch yang menjadi pola dasar seluruh pelatihan pada jalur ini, dan membahas sifat stokastiknya beserta pilihan ukuran batch. Setelah selesai, kerangka loop for epoch in range(...) dapat dibaca tanpa kejutan apa pun.

Mengapa pelatihan berjalan per batch#

Gradien yang dihitung pada satu contoh bising sekali, sedangkan gradien atas seluruh dataset terlalu mahal per langkah. Mini-batch mengambil jalan tengah, yaitu menghitung gradien rata-rata atas beberapa puluh contoh sekaligus. Ukuran itu masih cukup besar agar vektorisasi hardware bekerja, cukup kecil agar banyak langkah dilakukan dalam satu epoch, dan cukup bising untuk lolos dari titik pelana.

Pada PyTorch, pembagian data menjadi batch diurus DataLoader yang menerima objek Dataset dan ukuran batch, dengan opsi pengacakan yang berperan penting. Pengacakan urutan contoh pada setiap epoch memastikan batch-batch yang dilihat model berbeda komposisinya, dan tanpa pengacakan itu urutan data bisa menyusup ke dalam pelatihan.

Struktur satu epoch penuh#

Loop berikut merangkai seluruh unsur modul ini, yaitu data sintetis, DataLoader, model linier, fungsi loss MSE, dan optimizer Adam, kemudian mencetak loss rata-rata per epoch selama tiga epoch.

python latih_mini.py 
import torch
import torch.nn as nn
from torch.utils.data import TensorDataset, DataLoader

torch.manual_seed(0)
X = torch.randn(64, 2)
t = 3.0 * X[:, 0] - 1.5 * X[:, 1] + 0.5 + 0.05 * torch.randn(64)
loader = DataLoader(TensorDataset(X, t), batch_size=16, shuffle=True)

model = nn.Linear(2, 1)
opt = torch.optim.Adam(model.parameters(), lr=0.05)

for epoch in range(1, 4):
    total = 0.0
    for xb, tb in loader:
        opt.zero_grad()
        loss = ((model(xb).squeeze(1) - tb) ** 2).mean()
        loss.backward()
        opt.step()
        total += loss.item() * len(xb)
    print(f"epoch {epoch}: loss rata-rata = {total / len(X):.5f}")
text Keluaran 
epoch 1: loss rata-rata = 11.55763
epoch 2: loss rata-rata = 9.87590
epoch 3: loss rata-rata = 8.57653

Berkas dijalankan dengan python3 latih_mini.py, dan loss rata-rata menurun dari lebih dari sebelas menuju sekitar delapan dalam tiga epoch yang masing-masing hanya berisi empat langkah. Empat konvensi pada loop tersebut dipakai ulang sampai akhir jalur. Pertama, zero_grad() dibuka setiap batch sebagaimana aturan akumulasi gradien pada topik Autograd. Kedua, loss dijumlahkan tertimbang len(xb) lalu dibagi jumlah contoh, sehingga angka per epoch tidak dipengaruhi ukuran batch terakhir yang mungkin lebih kecil. Ketiga, gradien dihitung hanya pada data pelatihan. Keempat, jumlah langkah per epoch adalah len(dataset) / batch_size, yaitu empat langkah pada contoh di atas.

Sifat stokastik dan artefaknya#

Karena setiap batch memberi perkiraan gradien yang berbeda, kurva loss per langkah bergerigi dan tidak pernah turun mulus. Kegerigan ini normal dan bukan tanda kesalahan, sedangkan yang dipantau adalah kecenderungannya. Karena itu metrik per epoch atau per rentang langkah lebih andal dibaca daripada nilai satu batch, dan kebiasaan ini berlanjut pada modul Disiplin pelatihan ketika kurva pembelajaran digambar.

Sifat stokastiknya juga memengaruhi keputusan di sekitar learning rate. Batch yang kecil memberi gradien yang lebih bising, sehingga learning rate yang terlalu besar lebih mudah membuat langkah meledak, sedangkan batch besar menghasilkan perkiraan yang tenang dan menoleransi learning rate lebih tinggi. Hubungan ini yang menjelaskan mengapa pindah ke batch besar biasanya disertai penyesuaian learning rate, bukan hanya perubahan satu angka di DataLoader.

Memilih ukuran batch#

Ukuran batch adalah hyperparameter dengan konsekuensi berlapis. Batch 32 atau 64 menjadi titik awal yang lazim karena keseimbangan ketiganya sudah teruji pada banyak masalah. Aturan praktisnya dirangkum sebagai berikut.

  • Batch kecil, misalnya 8 sampai 32, memberi langkah bising yang dapat membantu generalisasi, tetapi memperlambat pemanfaatan hardware.
  • Batch besar, misalnya 256 ke atas, menghasilkan gradien tenang dan epoch yang singkat, tetapi menuntut memori lebih dan sering membutuhkan learning rate yang disesuaikan.
  • Jumlah langkah per epoch menurun seiring batch membesar, sehingga perbandingan antar konfigurasi paling adil dilakukan pada jumlah epoch yang sama.

Nilai yang bukan kelipatan pembagi data dibiarkan menghasilkan batch terakhir yang lebih kecil, dan perilaku itu normal pada DataLoader. Apabila batch terakhir yang kecil mengganggu pelatihan, opsi drop_last=True membuangnya, tetapi keputusan itu jarang diperlukan pada masalah-masalah jalur ini.

Ringkasan#

  • Mini-batch menyeimbangkan kebisingan contoh tunggal dan biaya gradien dataset penuh, dengan DataLoader mengurus pembagian dan pengacakannya.
  • Pola loop epoch, yaitu zero_grad, forward, loss, backward, step, adalah kerangka yang dipakai ulang pada seluruh pelatihan jalur ini.
  • Loss per langkah selalu bergerigi karena stokastik, sehingga metrik per epoch yang dibaca sebagai kecenderungan.
  • Batch 32 atau 64 menjadi titik awal, dan perubahan ukuran batch selalu disertai peninjauan learning rate.

Referensi#