Computer vision dengan PyTorch telah menjadi pendekatan dominan untuk klasifikasi gambar, deteksi objek, dan tugas pengenalan visual di tahun 2026. Tutorial ini membahas pembangunan CNN dari awal, penerapan transfer learning dengan model pretrained, dan persiapan untuk pertanyaan interview teknis.

Performa PyTorch 2.4

PyTorch 2.4 memperkenalkan torch.compile() secara default untuk operasi CNN, memberikan peningkatan kecepatan 30-50% pada GPU modern tanpa perubahan kode. Semua contoh dalam artikel ini kompatibel dengan PyTorch 2.4+.

Memahami Convolutional Neural Networks untuk Klasifikasi Gambar

Convolutional Neural Networks mengekstrak fitur hierarkis dari gambar melalui filter yang dapat dipelajari. Berbeda dengan jaringan fully connected, CNN mempertahankan hubungan spasial antar piksel, menjadikannya ideal untuk tugas visual. Arsitektur terdiri dari lapisan konvolusi yang mendeteksi tepi dan pola, lapisan pooling yang mengurangi dimensi, dan lapisan fully connected yang melakukan klasifikasi.

Operasi konvolusi menggeser filter kecil (biasanya 3x3 atau 5x5) melintasi gambar input, menghitung dot product di setiap posisi. Proses ini menghasilkan feature map yang menyoroti pola tertentu seperti tepi, tekstur, atau bentuk. Lapisan yang lebih dalam menggabungkan fitur tingkat rendah ini menjadi representasi kompleks—wajah, objek, atau pemandangan.

python

# cnn_architecture.py
import torch
import torch.nn as nn

class SimpleCNN(nn.Module):
    """Basic CNN for CIFAR-10 classification (32x32 RGB images, 10 classes)"""
    
    def __init__(self, num_classes: int = 10):
        super().__init__()
        # First conv block: 3 input channels (RGB) -> 32 feature maps
        self.conv1 = nn.Sequential(
            nn.Conv2d(3, 32, kernel_size=3, padding=1),  # Output: 32x32x32
            nn.BatchNorm2d(32),  # Normalize activations for stable training
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2)  # Output: 16x16x32
        )
        # Second conv block: increase depth for richer features
        self.conv2 = nn.Sequential(
            nn.Conv2d(32, 64, kernel_size=3, padding=1),  # Output: 16x16x64
            nn.BatchNorm2d(64),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2)  # Output: 8x8x64
        )
        # Third conv block: capture high-level patterns
        self.conv3 = nn.Sequential(
            nn.Conv2d(64, 128, kernel_size=3, padding=1),  # Output: 8x8x128
            nn.BatchNorm2d(128),
            nn.ReLU(inplace=True),
            nn.MaxPool2d(2, 2)  # Output: 4x4x128
        )
        # Classifier head
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(128 * 4 * 4, 256),
            nn.ReLU(inplace=True),
            nn.Dropout(0.5),  # Prevent overfitting
            nn.Linear(256, num_classes)
        )
    
    def forward(self, x: torch.Tensor) -> torch.Tensor:
        x = self.conv1(x)
        x = self.conv2(x)
        x = self.conv3(x)
        return self.classifier(x)

Arsitektur ini secara progresif meningkatkan jumlah filter (32 → 64 → 128) sambil mengurangi dimensi spasial melalui pooling. BatchNorm menstabilkan pelatihan dengan menormalisasi output lapisan, sementara Dropout mencegah classifier menghafal sampel pelatihan.

Melatih CNN dengan PyTorch DataLoaders

Pemuatan data yang efisien sangat penting untuk pemanfaatan GPU selama pelatihan. DataLoader PyTorch menangani batching, shuffling, dan pemuatan data paralel secara otomatis. Augmentasi data yang tepat—random crop, flip, dan color jitter—secara signifikan meningkatkan generalisasi pada gambar yang belum pernah dilihat.

python

# train_cnn.py
import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from torchvision import datasets, transforms

# Data augmentation for training (reduces overfitting)
train_transform = transforms.Compose([
    transforms.RandomHorizontalFlip(p=0.5),
    transforms.RandomCrop(32, padding=4),  # Random crop with padding
    transforms.ColorJitter(brightness=0.2, contrast=0.2),
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465),  # CIFAR-10 mean
                         (0.2470, 0.2435, 0.2616))  # CIFAR-10 std
])

# No augmentation for validation (deterministic evaluation)
val_transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.4914, 0.4822, 0.4465),
                         (0.2470, 0.2435, 0.2616))
])

def train_model(model: nn.Module, epochs: int = 20) -> dict:
    """Train CNN with standard best practices"""
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    model = model.to(device)
    
    # Load CIFAR-10 dataset
    train_data = datasets.CIFAR10(root="./data", train=True, 
                                   download=True, transform=train_transform)
    val_data = datasets.CIFAR10(root="./data", train=False,
                                 transform=val_transform)
    
    # DataLoaders with num_workers for parallel loading
    train_loader = DataLoader(train_data, batch_size=128, shuffle=True,
                              num_workers=4, pin_memory=True)
    val_loader = DataLoader(val_data, batch_size=256, shuffle=False,
                            num_workers=4, pin_memory=True)
    
    criterion = nn.CrossEntropyLoss()
    optimizer = optim.AdamW(model.parameters(), lr=1e-3, weight_decay=1e-4)
    scheduler = optim.lr_scheduler.CosineAnnealingLR(optimizer, T_max=epochs)
    
    best_acc = 0.0
    for epoch in range(epochs):
        model.train()
        for images, labels in train_loader:
            images, labels = images.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(images)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()
        
        scheduler.step()
        
        # Validation
        model.eval()
        correct, total = 0, 0
        with torch.no_grad():
            for images, labels in val_loader:
                images, labels = images.to(device), labels.to(device)
                outputs = model(images)
                _, predicted = outputs.max(1)
                total += labels.size(0)
                correct += predicted.eq(labels).sum().item()
        
        acc = 100. * correct / total
        best_acc = max(best_acc, acc)
        print(f"Epoch {epoch+1}/{epochs} - Val Acc: {acc:.2f}%")
    
    return {"best_accuracy": best_acc}

Optimisasi pelatihan utama meliputi: pin_memory=True untuk transfer CPU-ke-GPU yang lebih cepat, num_workers untuk pemuatan data paralel, optimizer AdamW dengan weight decay untuk regularisasi, dan jadwal learning rate cosine annealing untuk konvergensi yang mulus.

Transfer Learning dengan Pretrained ResNet dan EfficientNet

Transfer learning memanfaatkan model yang telah dilatih pada ImageNet (1,2 juta gambar, 1000 kelas) dan mengadaptasinya ke dataset kustom. Pendekatan ini mencapai akurasi lebih tinggi dengan lebih sedikit data pelatihan dan waktu komputasi. torchvision.models PyTorch menyediakan arsitektur state-of-the-art dengan weight pretrained.

Pendekatan standar membekukan lapisan konvolusi awal (yang mendeteksi fitur universal seperti tepi) dan melakukan fine-tune pada lapisan akhir plus head klasifikasi baru untuk tugas target.

python

# transfer_learning.py
import torch
import torch.nn as nn
from torchvision import models
from torchvision.models import ResNet50_Weights, EfficientNet_B0_Weights

def create_transfer_model(
    model_name: str = "resnet50",
    num_classes: int = 10,
    freeze_backbone: bool = True
) -> nn.Module:
    """Create a pretrained model with custom classification head"""
    
    if model_name == "resnet50":
        # Load ResNet50 with ImageNet weights
        model = models.resnet50(weights=ResNet50_Weights.IMAGENET1K_V2)
        # Replace final fully connected layer
        in_features = model.fc.in_features  # 2048 for ResNet50
        model.fc = nn.Sequential(
            nn.Dropout(0.3),
            nn.Linear(in_features, num_classes)
        )
        
    elif model_name == "efficientnet_b0":
        # EfficientNet: better accuracy/compute tradeoff
        model = models.efficientnet_b0(weights=EfficientNet_B0_Weights.IMAGENET1K_V1)
        in_features = model.classifier[1].in_features  # 1280 for B0
        model.classifier = nn.Sequential(
            nn.Dropout(0.2),
            nn.Linear(in_features, num_classes)
        )
    
    if freeze_backbone:
        # Freeze all layers except classifier
        for name, param in model.named_parameters():
            if "fc" not in name and "classifier" not in name:
                param.requires_grad = False
    
    return model

def count_trainable_params(model: nn.Module) -> int:
    """Count parameters that will be updated during training"""
    return sum(p.numel() for p in model.parameters() if p.requires_grad)

# Example usage
model = create_transfer_model("resnet50", num_classes=5, freeze_backbone=True)
print(f"Trainable parameters: {count_trainable_params(model):,}")
# Output: ~10,245 (only classifier) vs ~25 million (full ResNet50)

Membekukan backbone mengurangi parameter yang dapat dilatih dari 25 juta menjadi sekitar 10.000, memungkinkan pelatihan pada dataset kecil tanpa overfitting. Untuk dataset yang lebih besar (10.000+ gambar), secara bertahap unfreeze lapisan akhir menggunakan differential learning rates—rate lebih rendah untuk lapisan pretrained, rate lebih tinggi untuk classifier baru.

Siap menguasai wawancara Data Science & ML Anda?

Berlatih dengan simulator interaktif, flashcards, dan tes teknis kami.

Jelajahi Data Science & ML

Strategi Augmentasi Data untuk Computer Vision

Augmentasi data secara artifisial memperluas set pelatihan dengan menerapkan transformasi yang mempertahankan konten semantik. Augmentasi modern melampaui flip dan rotasi dasar—teknik seperti MixUp dan CutOut membuat contoh pelatihan sintetis yang meningkatkan ketahanan model.

python

# augmentation_strategies.py
import torch
import torchvision.transforms.v2 as T
from torchvision.transforms.v2 import functional as F

# Modern augmentation pipeline using torchvision v2 transforms
advanced_augmentation = T.Compose([
    T.RandomResizedCrop(224, scale=(0.8, 1.0)),  # Random crop and resize
    T.RandomHorizontalFlip(p=0.5),
    T.RandomVerticalFlip(p=0.1),  # Less common but useful for some domains
    T.RandomRotation(degrees=15),
    T.ColorJitter(brightness=0.3, contrast=0.3, saturation=0.3, hue=0.1),
    T.RandomAffine(degrees=0, translate=(0.1, 0.1)),  # Small translations
    T.GaussianBlur(kernel_size=3, sigma=(0.1, 2.0)),
    T.ToImage(),
    T.ToDtype(torch.float32, scale=True),
    T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
])

class CutOut:
    """Randomly mask out square regions of the image"""
    def __init__(self, n_holes: int = 1, length: int = 16):
        self.n_holes = n_holes
        self.length = length
    
    def __call__(self, img: torch.Tensor) -> torch.Tensor:
        h, w = img.shape[1], img.shape[2]
        mask = torch.ones_like(img)
        
        for _ in range(self.n_holes):
            y = torch.randint(0, h, (1,)).item()
            x = torch.randint(0, w, (1,)).item()
            y1 = max(0, y - self.length // 2)
            y2 = min(h, y + self.length // 2)
            x1 = max(0, x - self.length // 2)
            x2 = min(w, x + self.length // 2)
            mask[:, y1:y2, x1:x2] = 0
        
        return img * mask

def mixup_data(
    x: torch.Tensor,
    y: torch.Tensor,
    alpha: float = 0.4
) -> tuple[torch.Tensor, torch.Tensor, torch.Tensor, float]:
    """MixUp: blend two images and their labels"""
    lam = torch.distributions.Beta(alpha, alpha).sample().item()
    batch_size = x.size(0)
    index = torch.randperm(batch_size)
    
    mixed_x = lam * x + (1 - lam) * x[index]
    y_a, y_b = y, y[index]
    
    return mixed_x, y_a, y_b, lam

CutOut memaksa model untuk mengandalkan beberapa petunjuk visual daripada satu wilayah diskriminatif tunggal. MixUp membuat kombinasi konveks dari pasangan pelatihan, menghasilkan batas keputusan yang lebih halus. Teknik-teknik ini secara konsisten meningkatkan akurasi sebesar 1-3% pada benchmark standar.

Pertanyaan Interview tentang CNN dan Computer Vision

Interview teknis untuk peran computer vision menguji pemahaman teoritis dan keterampilan implementasi praktis. Persiapkan untuk pertanyaan tentang desain arsitektur, tantangan optimisasi, dan pertimbangan deployment dunia nyata.

Topik Interview Umum

Pewawancara sering bertanya tentang perhitungan receptive field, tujuan batch normalization, mengapa konvolusi bekerja untuk gambar, dan cara mendiagnosis overfitting pada model vision.

T: Apa itu receptive field dan mengapa penting?

Receptive field adalah wilayah gambar input yang mempengaruhi lokasi feature map tertentu. Lapisan yang lebih dalam memiliki receptive field yang lebih besar, memungkinkan mereka menangkap konteks yang lebih luas. Untuk jaringan dengan n lapisan konvolusi menggunakan kernel 3x3, receptive field tumbuh sebagai (2n + 1) x (2n + 1). Merancang arsitektur memerlukan keseimbangan antara ukuran receptive field dan biaya komputasi—dilated convolution memperluas receptive field tanpa meningkatkan parameter.

T: Mengapa menggunakan batch normalization di CNN?

Batch normalization menormalisasi input lapisan ke mean nol dan varians unit, mengatasi internal covariate shift. Manfaatnya meliputi: konvergensi lebih cepat (learning rate yang lebih tinggi menjadi stabil), efek regularisasi (mengurangi kebutuhan dropout), dan peningkatan aliran gradien (mencegah vanishing gradient pada jaringan dalam). Selama inferensi, running statistics menggantikan batch statistics untuk output deterministik.

T: Jelaskan perbedaan antara same dan valid padding.

Same padding menambahkan nol di sekitar input untuk mempertahankan dimensi spasial setelah konvolusi—input 32x32 dengan kernel 3x3 menghasilkan output 32x32. Valid padding tidak menerapkan padding, mengurangi dimensi—operasi yang sama menghasilkan output 30x30. Same padding lebih disukai di jaringan dalam untuk menghindari pengurangan spasial yang agresif.

T: Bagaimana menangani ketidakseimbangan kelas dalam klasifikasi gambar?

Strategi meliputi: weighted cross-entropy loss (bobot lebih tinggi untuk kelas minoritas), oversampling kelas minoritas selama pelatihan, augmentasi data yang difokuskan pada kelas yang kurang terwakili, dan focal loss yang menurunkan bobot contoh mudah. Untuk ketidakseimbangan parah (>100:1), kombinasikan beberapa teknik dan pertimbangkan metrik selain akurasi—F1 score, precision-recall AUC, atau analisis confusion matrix.

Untuk persiapan interview deep learning lebih lanjut, jelajahi modul pertanyaan CNN & Image Classification dan Deep Learning Fundamentals.

Deploy Model Vision PyTorch dengan TorchScript

Deployment produksi memerlukan konversi model PyTorch ke format yang dioptimalkan. TorchScript mengkompilasi model ke representasi portabel yang berjalan tanpa Python, memungkinkan deployment di aplikasi C++, perangkat mobile, atau lingkungan serverless.

python

# deployment_export.py
import torch
from torchvision import models
from torchvision.models import ResNet18_Weights

def export_for_production(model: torch.nn.Module, save_path: str) -> None:
    """Export model to TorchScript for production deployment"""
    model.eval()  # Set to evaluation mode (disables dropout, uses running stats)
    
    # Create example input matching expected dimensions
    example_input = torch.randn(1, 3, 224, 224)
    
    # Method 1: Tracing (for models without control flow)
    traced_model = torch.jit.trace(model, example_input)
    traced_model.save(save_path.replace(".pt", "_traced.pt"))
    
    # Method 2: Scripting (handles if/else, loops)
    scripted_model = torch.jit.script(model)
    scripted_model.save(save_path.replace(".pt", "_scripted.pt"))
    
    # Verify outputs match
    with torch.no_grad():
        original_out = model(example_input)
        traced_out = traced_model(example_input)
        scripted_out = scripted_model(example_input)
    
    assert torch.allclose(original_out, traced_out, atol=1e-5)
    assert torch.allclose(original_out, scripted_out, atol=1e-5)
    print(f"Model exported successfully to {save_path}")

def optimize_for_inference(model_path: str) -> torch.jit.ScriptModule:
    """Load and optimize TorchScript model for inference"""
    model = torch.jit.load(model_path)
    
    # Optimize for inference (fuses operations, removes dropout)
    optimized = torch.jit.optimize_for_inference(model)
    
    return optimized

# Export ResNet18
model = models.resnet18(weights=ResNet18_Weights.IMAGENET1K_V1)
export_for_production(model, "resnet18_production.pt")

Untuk kecepatan inferensi maksimum, pertimbangkan ekspor ONNX untuk kompatibilitas lintas framework atau TensorRT untuk deployment GPU NVIDIA. Perbandingan PyTorch vs TensorFlow membahas tradeoff deployment antara framework.

Kesimpulan

Computer vision dengan PyTorch menggabungkan abstraksi yang kuat dengan tools yang siap produksi:

Arsitektur CNN mengekstrak fitur hierarkis melalui lapisan konvolusi, pooling, dan normalisasi
Transfer learning dengan model pretrained (ResNet, EfficientNet) mencapai akurasi tinggi pada data terbatas
Augmentasi data (MixUp, CutOut, transformasi geometris) meningkatkan generalisasi dan mencegah overfitting
Interview teknis menguji receptive field, batch normalization, strategi padding, dan penanganan ketidakseimbangan kelas
TorchScript memungkinkan deployment produksi tanpa dependensi Python