Belajar YOLO - Arsitektur YOLO (Backbone, Neck, Head)

#Pendahuluan

Di episode 2 kita sudah menelusuri evolusi YOLO dari v1 hingga YOLO26. Sekarang saatnya membuka kap mesin: bagaimana arsitektur YOLO tersusun.

Kenapa perlu paham arsitektur? Karena hampir semua keputusan teknis kalian nanti berpijak di sini: memilih ukuran model (episode 7), memutuskan layer mana yang di-freeze saat fine-tuning (episode 13), debugging training yang tidak konvergen, sampai membaca changelog versi baru. Tanpa peta backbone-neck-head, kalian hanya akan menghafal flag CLI tanpa tahu apa yang terjadi di baliknya.

#Tiga Komponen Utama

Setiap detector modern — termasuk seluruh keluarga YOLO — punya tiga bagian besar:

Analoginya seperti tim investigasi:

• Backbone = mata dan otak visual: mengubah piksel mentah menjadi fitur bermakna ("di sini ada tepi", "ini tekstur roda").
• Neck = meja koordinasi: menyatukan informasi dari berbagai tingkat detail (detail halus vs konteks besar).
• Head = penyidik yang menulis laporan: mengubah fitur menjadi keputusan final — koordinat box, class, confidence.

#Backbone: Ekstraktor Fitur

Backbone adalah CNN klasik yang mengecilkan resolusi secara bertahap sambil memperdalam pemahaman semantik:

Trade-off fundamental CNN: makin dalam → makin pintar semantik tapi makin kehilangan detail spasial. Objek kecil hidup di feature map besar; objek besar hidup di feature map kecil. Masalah inilah yang dipecahkan oleh neck.

#Neck: Agregasi Multi-Skala dengan PAN-FPN

Dua ide digabung:

• FPN (Feature Pyramid Network): aliran top-down — informasi semantik kuat dari layer dalam "diteteskan" ke layer dangkal.
• PAN (Path Aggregation Network): aliran bottom-up tambahan — lokasi presisi dari layer dangkal naik lagi ke atas.

Hasilnya: setiap level pyramid akhirnya punya semantik kuat DAN lokasi presisi sekaligus. Head bisa mendeteksi objek kecil maupun besar dari fondasi yang sama.

#Head: Prediksi Anchor-Free

Head modern YOLO bersifat anchor-free: langsung memprediksi center offset dan ukuran box tanpa template anchor era lama. Pada YOLOv8+ head juga decoupled — cabang regression (box) dan classification dipisah agar tidak saling ganggu, dengan distribusi box pakai DFL (Distribution Focal Loss).

#Evolusi Blok Bangunan per Versi

Nama-nama blok ini akan sering kalian temui di file config dan hasil model.summary():

Perhatikan polanya: setiap generasi tidak menemukan ulang backbone-neck-head, hanya mengganti blok di dalamnya agar lebih efisien atau lebih fokus. Inilah kenapa skill membaca config lebih berharga daripada menghafal satu arsitektur.

#Praktik: Bedah yolo26n.yaml

Mari buktikan bahwa arsitektur YOLO hanyalah data. File config nano YOLO26 dapat dilihat langsung dari package Ultralytics:

Temukan file configLihat isi yolo26n.yaml

python -c "import ultralytics, pathlib; print(pathlib.Path(ultralytics.__file__).parent / 'cfg/models')"

cat $(python -c "import ultralytics, pathlib; print(pathlib.Path(ultralytics.__file__).parent)")/cfg/models/26/yolo26.yaml

Bentuk inti file tersebut kurang lebih seperti ini:

# Parameters
nc: 80 # number of classes
scales: # [depth, width, max_channels]
  n: [0.50, 0.25, 1024]
 
backbone:
  # [from, repeats, module, args]
  - [-1, 1, Conv, [64, 3, 2]] # 0-P1/2
  - [-1, 1, Conv, [128, 3, 2]] # 1-P2/4
  - [-1, 2, C3k2, [256, false, 0.25]]
  - [-1, 1, Conv, [256, 3, 2]] # 3-P3/8
  - [-1, 2, C3k2, [512, false, 0.25]]
  - [-1, 1, Conv, [512, 3, 2]] # 5-P4/16
  - [-1, 2, C3k2, [512, true]]
  - [-1, 1, Conv, [1024, 3, 2]] # 7-P5/32
  - [-1, 2, C3k2, [1024, true]]
  - [-1, 1, SPPF, [1024, 5]] # 9
 
head:
  - [-1, 1, nn.Upsample, [None, 2, "nearest"]]
  - [[-1, 6], 1, Concat, [1]] # cat backbone P4
  - [-1, 2, C3k2, [512, false]] # 12 (P4/16-small)
  # ... pola PAN top-down/bottom-up berlanjut ...
  - [[16, 19, 22], 1, Detect, [nc]] # Detect(P3, P4, P5)

Tiga hal yang perlu kalian baca dari file ini:

1. backbone: — deretan Conv dengan stride 2 yang mengecilkan resolusi (P1→P5), diselingi blok C3k2, ditutup SPPF.
2. head: — bagian pertamanya sebenarnya adalah neck: nn.Upsample + Concat adalah aliran FPN top-down yang menyambungkan layer dalam ke layer dangkal ([[-1, 6], ...] artinya gabungkan output layer 6).
3. Baris Detect — menerima tiga feature map (P3/P4/P5): inilah multi-scale prediction dari episode 2 dalam bentuk nyata.

Sekarang jalankan model dan bandingkan dengan config-nya:

from ultralytics import YOLO
 
model = YOLO("yolo26n.yaml") # bangun dari config (weight acak)
model.info() # cetak ringkasan layer & parameter
 
# bandingkan dengan versi lain
for size in ["yolo11n.yaml", "yolo26s.yaml"]:
    print(size, YOLO(size).info(detailed=False))

#Common Pitfalls Membaca Arsitektur

• Mengira head: di YAML hanya prediksi — separuh awalnya adalah neck. Batas keduanya konseptual.
• Lupa bahwa jumlah channel dikali width multiplier sesuai scale — jadi angka di YAML ≠ channel aktual untuk model n.
• Mengubah YAML untuk dataset custom tapi salah menulis indeks from — error shape akan muncul saat build model. Selalu validasi dengan model.info() setelah edit.

#Penutup

Rangkuman episode ini:

• Arsitektur YOLO = backbone (ekstraksi fitur bertingkat) + neck PAN-FPN (agregasi multi-skala) + head anchor-free decoupled (prediksi).
• Objek kecil butuh feature map besar, objek besar butuh semantik dalam — neck membuat keduanya tersedia di tiap level.
• Evolusi antar generasi = penggantian blok (CSP→C2f→C3k2, SPPF, C2PSA, R-ELAN) plus inovasi head NMS-free di YOLO26.
• Arsitektur tersimpan sebagai data di YAML; model.info() adalah cara cepat memverifikasi struktur.

Di episode 4 kita akhirnya menyalakan mesinnya: install Ultralytics secara benar, load weight pretrained yolo26n.pt, dan menjalankan inference pertama kalian — baik via CLI maupun Python API — pada gambar dan video. Pastikan environment kalian siap!