Machine Learning untuk Vision

Deep learning memberikan deteksi yang lebih robust dibanding metode tradisional, terutama dalam kondisi pencahayaan bervariasi. Namun ada trade-off: model lebih berat, butuh dataset, dan perlu tuning agar bisa berjalan real-time di robot.

CNN Fundamentals

CNN cocok untuk tugas klasifikasi sederhana (misalnya bola vs bukan bola). Ia belajar fitur tepi, tekstur, dan bentuk secara bertahap melalui lapisan konvolusi.

Convolutional Neural Network Architecture

Purpose: Visualisasi alur umum CNN untuk klasifikasi sederhana. Inputs: image 2D sebagai tensor. Outputs: skor kelas (ball vs not ball). Steps:

1. Conv + ReLU untuk ekstraksi fitur.
2. MaxPool untuk downsample.
3. Flatten dan Dense untuk klasifikasi. Pitfalls: input size tidak cocok dengan layer akhir. Validation: output shape sesuai jumlah kelas.

Input Image (640x480x3)
       │
       ▼
┌──────────────┐
│   Conv2D     │ ← Feature extraction
│   + ReLU     │
│   + MaxPool  │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│   Conv2D     │ ← More features
│   + ReLU     │
│   + MaxPool  │
└──────┬───────┘
       │
       ▼
┌──────────────┐
│   Flatten    │
│   + Dense    │ ← Classification
│   + Softmax  │
└──────────────┘
       │
       ▼
   Output (classes)

Simple CNN dengan PyTorch

Purpose: Contoh implementasi CNN sederhana untuk baseline. Inputs: batch tensor shape [B, 3, H, W]. Outputs: logits per kelas. Steps:

1. Tumpuk conv, ReLU, maxpool.
2. Flatten dan dense untuk output.
3. Return logits untuk loss function. Pitfalls: ukuran input harus cocok dengan Linear. Validation: forward pass berjalan tanpa error ukuran.

import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=2):
        super().__init__()

        self.features = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(32, 64, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),

            nn.Conv2d(64, 128, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
        )

        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(128 * 28 * 28, 256),
            nn.ReLU(),
            nn.Dropout(0.5),
            nn.Linear(256, num_classes),
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

YOLO untuk Object Detection

YOLO cocok untuk deteksi multi-objek (bola, robot, gawang) dalam satu frame. Kelebihannya adalah cepat; kekurangannya model perlu dilatih dengan dataset RoboCup agar tahan terhadap sudut kamera dan pencahayaan khas kompetisi.

Installation

Purpose: Menyiapkan library YOLO untuk training dan inference. Inputs: environment Python aktif. Outputs: paket ultralytics terpasang. Steps:

1. Aktifkan venv atau conda.
2. Install paket via pip. Pitfalls: versi Python tidak kompatibel. Validation: import YOLO berhasil.

pip install ultralytics

Quick Start

Purpose: Menjalankan inference cepat untuk cek model pretrained. Inputs: image uji. Outputs: hasil deteksi dan visualisasi. Steps:

1. Load model pretrained.
2. Jalankan inference.
3. Tampilkan hasil. Pitfalls: image path salah membuat inference gagal. Validation: bounding box terlihat di output.

from ultralytics import YOLO

# Load pretrained model
model = YOLO('yolov8n.pt')

# Inference
results = model('image.jpg')

# Show results
results[0].show()

Training Custom Model

Purpose: Melatih YOLO dengan dataset RoboCup. Inputs: dataset YAML, jumlah epoch, ukuran image. Outputs: weights hasil training. Steps:

1. Siapkan struktur dataset.
2. Panggil train dengan parameter. Pitfalls: label tidak sesuai format YOLO. Validation: training log menunjukkan loss menurun.

from ultralytics import YOLO

# Create dataset structure
# dataset/
# ├── images/
# │   ├── train/
# │   └── val/
# └── labels/
#     ├── train/
#     └── val/

# Train
model = YOLO('yolov8n.pt')
model.train(
    data='dataset.yaml',
    epochs=100,
    imgsz=640,
    batch=16,
    device='cuda'
)

Dataset YAML

Purpose: Menjelaskan konfigurasi dataset untuk training YOLO. Inputs: path dataset dan daftar kelas. Outputs: file YAML. Steps:

1. Isi path, train, val.
2. Set nc sesuai jumlah names. Pitfalls: nc tidak sesuai jumlah kelas. Validation: training berjalan tanpa error kelas.

# dataset.yaml
path: /path/to/dataset
train: images/train
val: images/val

nc: 3 # number of classes
names: ["ball", "goal", "robot"]

Transfer Learning

Transfer learning mempercepat training karena kita memanfaatkan model yang sudah belajar fitur dasar (tepi, tekstur). Biasanya hanya layer terakhir yang dilatih ulang untuk kelas RoboCup, sehingga butuh data lebih sedikit.

Using Pretrained Models

Purpose: Memanfaatkan model pretrained untuk transfer learning. Inputs: model pretrained dan jumlah kelas baru. Outputs: model dengan head baru. Steps:

1. Load ResNet pretrained.
2. Freeze parameter awal.
3. Ganti layer terakhir. Pitfalls: lupa requires_grad=False membuat training lambat. Validation: hanya layer akhir yang terupdate saat training.

import torchvision.models as models
import torch.nn as nn

def create_ball_classifier():
    # Load pretrained ResNet
    model = models.resnet18(pretrained=True)

    # Freeze early layers
    for param in model.parameters():
        param.requires_grad = False

    # Replace final layer
    model.fc = nn.Sequential(
        nn.Linear(512, 256),
        nn.ReLU(),
        nn.Dropout(0.3),
        nn.Linear(256, 2),  # ball / not_ball
    )

    return model

RoboCup Datasets

Performance Comparison

Resources

• Ultralytics YOLO
• PyTorch Tutorials
• RoboCup Vision Papers
• Papers With Code - Object Detection

Next Steps

• Camera Calibration - 3D projection