Belajar YOLO - Training Model dari Scratch

#Pendahuluan

Dataset custom sudah siap dari episode 8. Sekarang momen yang paling ditunggu: melatih model sendiri. Episode ini membedah model.train() — bukan sekadar menempelkan flag, tapi memahami apa yang terjadi di setiap epoch dan bagaimana membaca sinyal yang dilaporkan.

Kenapa mulai dari from scratch padahal episode 10 akan bicara fine-tuning? Karena kalian harus mengerti kedua jalurnya untuk memilih dengan sadar. From scratch jarang jadi jawaban terbaik di dunia nyata — tapi proses belajarnya memaksa kalian memahami seluruh pipeline training: data loading, augmentasi, loss, validasi, checkpoint. Paham ini dulu, fine-tuning nanti tinggal "training dengan bonus bobot awal".

#Cara Kerja model.train()

Satu panggilan menjalankan seluruh siklus:

from ultralytics import YOLO
 
model = YOLO("yolo26n.yaml") # YAML = arsitektur + bobot acak!
 
model.train(
    data="proyek-helm/data.yaml",
    epochs=100,
    imgsz=640,
    batch=-1, # auto: sesuaikan VRAM
    device=0, # GPU pertama; "cpu" jika tanpa GPU
)

Perhatikan detail krusial: yolo26n.**yaml** (bukan .pt) berarti bobot dimulai acak — inilah definisi from scratch. Bandingkan dengan episode 10 nanti yang memuat .pt pretrained.

Output training tersimpan rapi:

runs/detect/train/
├── weights/
│   ├── best.pt    # bobot dengan mAP val tertinggi ← pakai ini
│   └── last.pt    # snapshot epoch terakhir (untuk resume)
├── results.csv    # metrik per epoch
├── results.png    # grafik loss & mAP
├── confusion_matrix.png
├── train_batch0.jpg  # visualisasi augmented batch
└── args.yaml      # seluruh konfigurasi run ini

#Hyperparameters Inti

Empat parameter ini menentukan hampir semua hal di awal:

#Relasi Batch × Image Size × VRAM

Memori GPU dipakai kira-kira sebanding dengan batch × imgsz². Kombinasi umum:

GPU 4GB  : batch 4-8   @ imgsz 640  (n/s)
GPU 8GB  : batch 16    @ imgsz 640  (s/m)
GPU 16GB+: batch 32+   @ imgsz 960/1280 (m/l/x)

Kalau kena CUDA out of memory: turunkan batch dulu (paling aman), baru imgsz. Jangan takut batch kecil — Ultralytics menerapkan akumulasi gradien internal sehingga efektivitasnya tetap terjaga.

#Apa yang Terjadi di Balik Layar

Setiap epoch adalah loop besar seperti ini:

Tiga insight penting dari diagram itu:

1. Augmentasi terjadi on-the-fly — tiap epoch kalian melihat versi "beda" dari gambar sama. Inilah regularisasi gratis (dibahas tuntas episode 12).
2. Loss detection multi-komponen: box loss (posisi presisi via CIoU/DFL) + classification loss + distribution focal loss. Ketiganya dicetak terpisah di log — pola penurunannya memberi petunjuk diagnosis berbeda.
3. best.pt dipilih oleh mAP validasi, bukan loss training — karena itulah split val yang bersih dari episode 8 sangat penting.

#Membaca Log Per-Epoch

Epoch  gpu_mem  box_loss  cls_loss  dfl_loss  Instances  Size
12/100 2.5G     1.483     1.102     1.287     24         640
                 Class   Images  Instances  Box(P   R    mAP50  mAP50-95)
                   all       20        87     0.742  0.61  0.667  0.441
                  helm       20        45     0.801  0.72  0.784  0.551
                no-helm      20        42     0.683  0.50  0.550  0.331

Yang perlu kalian pantau:

• Loss menurun stabil? Naik-turun liar → LR terlalu besar atau data bermasalah.
• P/R gap besar (precision tinggi, recall rendah)? Model konservatif — sering pada data sedikit.
• mAP per kelas timpang? Kelas lemah butuh lebih banyak contoh atau lebih mudah dibedakan.

#Kapan From Scratch Masuk Akal?

Jujur saja: hampir tidak pernah — kecuali tiga kondisi spesifik:

1. Domain sangat jauh dari natural image: citra medis (MRI), satelit multispectral, radar, mikroskop — fitur COCO tidak transfer.
2. Kelas tidak beririsan sama sekali dengan COCO dan dataset kalian raksasa (ratusan ribu gambar).
3. Kebutuhan riset: membandingkan arsitektur secara adil tanpa pengaruh bobot awal.

Untuk semua kasus lain — helm, kendaraan, produk retail, cacat manufaktur — fine-tuning pretrained unggul mutlak: konvergensi puluhan kali lebih cepat dengan data jauh lebih sedikit. Itu topik utama episode 10.

#Praktik: Training Singkat untuk Memahami Pipeline

Latihan ini tujuannya memahami mekanik, bukan produksi. Pakai dataset mini episode 8:

from ultralytics import YOLO
 
model = YOLO("yolo26n.yaml") # from scratch, sengaja!
results = model.train(
    data="proyek-helm/data.yaml",
    epochs=30,
    imgsz=640,
    batch=-1,
    patience=10, # early stopping jika stagnan
)
 
# langsung validasi best.pt
metrics = YOLO("runs/detect/train/weights/best.pt").val()
print("mAP50:", metrics.box.map50, "| mAP50-95:", metrics.box.map)

Setelah selesai, lakukan tiga observasi wajib:

1. Buka results.png — apakah kurva loss turun monoton? Di epoch berapa mAP mulai plateau?
2. Buka train_batch0.jpg — lihat augmentasi mosaic yang benar-benar diterapkan pada data kalian.
3. Buka confusion_matrix.png — kelas mana yang saling tertukar?

Bandipkan durasi & mAP-nya dengan fine-tuning identik di episode 10 — angka perbandingannya akan membekas lebih dalam daripada teori apa pun.

#Penutup

Rangkuman episode ini:

• .yaml = from scratch (bobot acak); seluruh pipeline berjalan lewat satu model.train().
• Empat hyperparameter inti: epochs, imgsz, batch, optimizer=auto — hubungan batch×imgsz×VRAM wajib dipahami.
• Tiap epoch: augmentasi on-the-fly → forward → multi-loss → backward → validasi → checkpoint best.pt.
• Log per-epoch adalah alat diagnosis: loss curve, P/R gap, dan mAP per kelas.
• From scratch hanya masuk akal untuk domain non-natural-image atau riset; fine-tuning adalah default dunia nyata.

Di episode 10 kita ambil jalan pintas yang dipakai semua praktisi: fine-tuning pretrained model — bagaimana weight transfer bekerja otomatis saat jumlah kelas beda, best practice epochs & early stopping, dan fine-tune nyata pada dataset custom episode 8. Sampai jumpa!