Upload folder using huggingface_hub

advanced_augmentation.py

@@ -0,0 +1,308 @@
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+import numpy as np
+from torchvision import transforms
+import random
+
+def cutmix_data(x, y, alpha=1.0, device='cuda'):
+    """
+    CutMix data augmentation.
+    
+    Args:
+        x: Input batch
+        y: Target batch
+        alpha: CutMix parameter
+        device: Device to run on
+    
+    Returns:
+        mixed_x: Mixed input batch
+        y_a, y_b: Original targets for loss calculation
+        lam: Mixing ratio
+    """
+    if alpha > 0:
+        lam = np.random.beta(alpha, alpha)
+    else:
+        lam = 1
+
+    batch_size = x.size(0)
+    if device == 'cuda':
+        index = torch.randperm(batch_size).cuda()
+    else:
+        index = torch.randperm(batch_size)
+
+    # Generate random bounding box
+    W = x.size(2)
+    H = x.size(3)
+    cut_rat = np.sqrt(1. - lam)
+    cut_w = int(W * cut_rat)
+    cut_h = int(H * cut_rat)
+
+    # Uniform sampling
+    cx = np.random.randint(W)
+    cy = np.random.randint(H)
+
+    bbx1 = np.clip(cx - cut_w // 2, 0, W)
+    bby1 = np.clip(cy - cut_h // 2, 0, H)
+    bbx2 = np.clip(cx + cut_w // 2, 0, W)
+    bby2 = np.clip(cy + cut_h // 2, 0, H)
+
+    x[:, :, bbx1:bbx2, bby1:bby2] = x[index, :, bbx1:bbx2, bby1:bby2]
+    
+    # Adjust lambda to exactly match pixel ratio
+    lam = 1 - ((bbx2 - bbx1) * (bby2 - bby1) / (W * H))
+    y_a, y_b = y, y[index]
+    
+    return x, y_a, y_b, lam
+
+def cutmix_criterion(criterion, pred, y_a, y_b, lam):
+    """
+    CutMix loss calculation.
+    """
+    return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)
+
+class LabelSmoothingCrossEntropy(nn.Module):
+    """
+    Label smoothing cross entropy loss.
+    """
+    def __init__(self, smoothing=0.1):
+        super(LabelSmoothingCrossEntropy, self).__init__()
+        self.smoothing = smoothing
+
+    def forward(self, x, target):
+        confidence = 1. - self.smoothing
+        logprobs = F.log_softmax(x, dim=-1)
+        nll_loss = -logprobs.gather(dim=-1, index=target.unsqueeze(1))
+        nll_loss = nll_loss.squeeze(1)
+        smooth_loss = -logprobs.mean(dim=-1)
+        loss = confidence * nll_loss + self.smoothing * smooth_loss
+        return loss.mean()
+
+class FocalLoss(nn.Module):
+    """
+    Focal Loss for addressing class imbalance.
+    """
+    def __init__(self, alpha=1, gamma=2, reduction='mean'):
+        super(FocalLoss, self).__init__()
+        self.alpha = alpha
+        self.gamma = gamma
+        self.reduction = reduction
+
+    def forward(self, inputs, targets):
+        ce_loss = F.cross_entropy(inputs, targets, reduction='none')
+        pt = torch.exp(-ce_loss)
+        focal_loss = self.alpha * (1-pt)**self.gamma * ce_loss
+        
+        if self.reduction == 'mean':
+            return focal_loss.mean()
+        elif self.reduction == 'sum':
+            return focal_loss.sum()
+        else:
+            return focal_loss
+
+class AdvancedAugmentation:
+    """
+    Advanced augmentation techniques for better generalization.
+    """
+    def __init__(self, image_size=224):
+        self.image_size = image_size
+        
+    def get_train_transforms(self):
+        """
+        Get comprehensive training transforms with advanced augmentation.
+        """
+        return transforms.Compose([
+            # Resize with padding
+            transforms.Resize((self.image_size + 32, self.image_size + 32)),
+            
+            # Random crop with padding
+            transforms.RandomCrop((self.image_size, self.image_size), padding=4),
+            
+            # Geometric augmentations
+            transforms.RandomHorizontalFlip(p=0.5),
+            transforms.RandomVerticalFlip(p=0.2),
+            transforms.RandomRotation(degrees=15),
+            transforms.RandomAffine(
+                degrees=0, 
+                translate=(0.1, 0.1), 
+                scale=(0.9, 1.1),
+                shear=5
+            ),
+            
+            # Color augmentations
+            transforms.ColorJitter(
+                brightness=0.2, 
+                contrast=0.2, 
+                saturation=0.2, 
+                hue=0.05
+            ),
+            
+            # Advanced augmentations
+            transforms.RandomPerspective(distortion_scale=0.2, p=0.3),
+            transforms.RandomErasing(p=0.2, scale=(0.02, 0.33), ratio=(0.3, 3.3)),
+            
+            # TrivialAugmentWide for additional randomness
+            transforms.TrivialAugmentWide(num_magnitude_bins=31),
+            
+            # Convert to tensor and normalize
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    def get_val_transforms(self):
+        """
+        Get validation transforms (minimal augmentation).
+        """
+        return transforms.Compose([
+            transforms.Resize((self.image_size, self.image_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+
+class TestTimeAugmentation:
+    """
+    Test Time Augmentation for better inference.
+    """
+    def __init__(self, model, device, num_augmentations=5):
+        self.model = model
+        self.device = device
+        self.num_augmentations = num_augmentations
+        
+        # Define TTA transforms
+        self.tta_transforms = [
+            transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ]),
+            transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.RandomHorizontalFlip(p=1.0),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ]),
+            transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.RandomRotation(degrees=10),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ]),
+            transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.RandomRotation(degrees=10),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ]),
+            transforms.Compose([
+                transforms.Resize((224, 224)),
+                transforms.ColorJitter(brightness=0.1, contrast=0.1),
+                transforms.ToTensor(),
+                transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+            ])
+        ]
+    
+    def predict(self, image):
+        """
+        Predict with TTA.
+        """
+        self.model.eval()
+        predictions = []
+        
+        with torch.no_grad():
+            for transform in self.tta_transforms[:self.num_augmentations]:
+                # Apply transform
+                if hasattr(image, 'convert'):
+                    # PIL Image
+                    transformed = transform(image)
+                else:
+                    # Already tensor
+                    transformed = transform(image)
+                
+                # Add batch dimension
+                transformed = transformed.unsqueeze(0).to(self.device)
+                
+                # Get prediction
+                output = self.model(transformed)
+                predictions.append(F.softmax(output, dim=1))
+        
+        # Average predictions
+        avg_prediction = torch.mean(torch.stack(predictions), dim=0)
+        return avg_prediction
+
+def calculate_class_weights(train_targets, num_classes, method='balanced'):
+    """
+    Calculate class weights for handling class imbalance.
+    
+    Args:
+        train_targets: List of training targets
+        num_classes: Number of classes
+        method: 'balanced', 'inverse', or 'sqrt'
+    
+    Returns:
+        class_weights: Tensor of class weights
+    """
+    class_counts = np.bincount(train_targets, minlength=num_classes)
+    
+    if method == 'balanced':
+        # sklearn's balanced method
+        total_samples = len(train_targets)
+        class_weights = total_samples / (num_classes * class_counts)
+    elif method == 'inverse':
+        # Simple inverse frequency
+        class_weights = 1.0 / class_counts
+    elif method == 'sqrt':
+        # Square root of inverse frequency
+        class_weights = 1.0 / np.sqrt(class_counts)
+    else:
+        raise ValueError(f"Unknown method: {method}")
+    
+    # Normalize weights
+    class_weights = class_weights / class_weights.sum() * num_classes
+    
+    return torch.tensor(class_weights, dtype=torch.float)
+
+def get_advanced_scheduler(optimizer, method='cosine_warmup', total_epochs=50):
+    """
+    Get advanced learning rate scheduler.
+    
+    Args:
+        optimizer: PyTorch optimizer
+        method: Scheduler method
+        total_epochs: Total number of epochs
+    
+    Returns:
+        scheduler: Learning rate scheduler
+    """
+    if method == 'cosine_warmup':
+        from torch.optim.lr_scheduler import CosineAnnealingWarmRestarts
+        return CosineAnnealingWarmRestarts(optimizer, T_0=10, T_mult=2, eta_min=1e-7)
+    
+    elif method == 'onecycle':
+        from torch.optim.lr_scheduler import OneCycleLR
+        return OneCycleLR(
+            optimizer, 
+            max_lr=optimizer.param_groups[0]['lr'],
+            total_steps=total_epochs,
+            pct_start=0.3,
+            anneal_strategy='cos'
+        )
+    
+    elif method == 'plateau':
+        from torch.optim.lr_scheduler import ReduceLROnPlateau
+        return ReduceLROnPlateau(
+            optimizer, 
+            mode='max', 
+            factor=0.5, 
+            patience=3, 
+            min_lr=1e-7,
+            verbose=True
+        )
+    
+    else:
+        raise ValueError(f"Unknown scheduler method: {method}")
+
+def apply_mixup_cutmix_probability():
+    """
+    Randomly choose between Mixup and CutMix based on probability.
+    """
+    return random.choice(['mixup', 'cutmix', 'none'])

config.py

@@ -0,0 +1,23 @@
+import torch
+from pathlib import Path
+
+# Definisikan ROOT path proyek (folder batik_vision_project)
+ROOT_PATH = Path(__file__).resolve().parent.parent 
+
+# Path ke data
+DATA_PATH = ROOT_PATH / "Batik-Indonesia" # <-- GANTI BARIS INI
+
+# Hyperparameters
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+BATCH_SIZE = 32  # Dikurangi untuk laptop
+IMAGE_SIZE = 224 # Ukuran input untuk ViT/Swin
+LEARNING_RATE = 1e-4
+EPOCHS = 50  # Dikurangi untuk testing awal
+
+# Pengaturan split
+TEST_SPLIT_SIZE = 0.2 # 20% untuk validasi
+RANDOM_SEED = 42 # Agar hasil split selalu sama
+
+# Daftar model yang akan diuji
+# Mulai dengan model terkecil dulu untuk testing
+MODEL_LIST = ["convnext_tiny"]  # Model terkecil untuk testing awal

data_loader.py

@@ -0,0 +1,242 @@
+import sys
+from pathlib import Path
+# tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import numpy as np
+from torch.utils.data import DataLoader, Dataset, random_split, WeightedRandomSampler
+from torchvision import datasets, transforms
+from src import config  # Mengimpor dari file config.py Anda
+import matplotlib.pyplot as plt
+import warnings
+from pathlib import Path
+
+# --- 1. Mendefinisikan Transformasi (Augmentasi) ---
+
+# Statistik ImageNet untuk normalisasi (penting untuk model pre-trained)
+MEAN = [0.485, 0.456, 0.406]
+STD = [0.229, 0.224, 0.225]
+
+# Transformasi untuk data TRAINING
+# Tujuannya: "menyiksa" data agar model bisa generalisasi dengan teknik terbaru
+train_transform = transforms.Compose([
+    transforms.Resize((config.IMAGE_SIZE + 32, config.IMAGE_SIZE + 32)),  # Resize lebih besar dulu
+    transforms.RandomCrop((config.IMAGE_SIZE, config.IMAGE_SIZE), padding=4),  # Random crop dengan padding
+    transforms.RandomHorizontalFlip(p=0.5),
+    transforms.RandomVerticalFlip(p=0.2),  # Tambah vertical flip
+    transforms.RandomRotation(degrees=15),  # Moderate rotation
+    transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2, hue=0.05),  # Moderate color augmentation
+    transforms.RandomAffine(degrees=0, translate=(0.1, 0.1), scale=(0.9, 1.1), shear=5),  # Enhanced geometric augmentation
+    
+    # Advanced augmentations
+    transforms.RandomPerspective(distortion_scale=0.2, p=0.3),  # Perspective distortion
+    transforms.RandomErasing(p=0.2, scale=(0.02, 0.33), ratio=(0.3, 3.3)),  # Random erasing
+
+    # --- TAMBAHKAN INI ---
+    # Ini akan menerapkan augmentasi acak yang kuat
+    transforms.TrivialAugmentWide(num_magnitude_bins=31), 
+    # ---------------------
+
+    transforms.ToTensor(), # ToTensor() HARUS setelah augmentasi
+    transforms.Normalize(mean=MEAN, std=STD)
+])
+# Transformasi untuk data VALIDASI
+# Tujuannya: Hanya membersihkan data untuk evaluasi, TANPA augmentasi acak
+val_transform = transforms.Compose([
+    transforms.Resize((config.IMAGE_SIZE, config.IMAGE_SIZE)), # Ukuran seragam
+    transforms.ToTensor(), # Konversi ke tensor PyTorch
+    transforms.Normalize(mean=MEAN, std=STD) # Normalisasi
+])
+
+
+# --- 2. Helper Class untuk Menerapkan Transformasi Berbeda ---
+# INI PENTING:
+# Kita perlu membagi dataset (split) SEBELUM menerapkan augmentasi.
+# Helper class ini memungkinkan kita menerapkan transform yang berbeda (train/val)
+# pada dataset subset yang sudah dibagi.
+
+class TransformedDataset(Dataset):
+    """Wrapper Dataset untuk menerapkan transformasi ke Subset."""
+    def __init__(self, subset, transform=None):
+        self.subset = subset
+        self.transform = transform
+        
+    def __getitem__(self, index):
+        # Ambil data asli (gambar, label) dari subset
+        try:
+            x, y = self.subset[index]
+            
+            # Terapkan transformasi jika ada
+            if self.transform:
+                x = self.transform(x)
+                
+            return x, y
+        except Exception as e:
+            # Jika ada error (file rusak), coba index berikutnya
+            print(f"[Warning] Error pada index {index}: {e}")
+            # Coba index berikutnya (dengan wraparound)
+            next_index = (index + 1) % len(self.subset)
+            return self.__getitem__(next_index)
+    
+    def __len__(self):
+        return len(self.subset)
+
+# --- 3. Fungsi Utama Pembuat DataLoader ---
+
+def create_dataloaders():
+    """
+    Fungsi utama untuk membuat dan mengembalikan data loader
+    untuk training dan validasi.
+    """
+    # --- VALIDASI: Pastikan config.DATA_PATH ada, coba beberapa alternatif jika tidak ---
+    data_path = Path(config.DATA_PATH)
+    if not data_path.exists():
+        project_root = Path(__file__).resolve().parents[1]
+        alt_names = ["Batik_Indonesia_JPG", "Batik-Indonesia", "Batik_Indonesia", "data", "dataset"]
+        found = None
+        for name in alt_names:
+            candidate = project_root / name
+            if candidate.exists() and candidate.is_dir():
+                found = candidate
+                break
+        if found:
+            print(f"[Data] config.DATA_PATH '{config.DATA_PATH}' tidak ditemukan. Menggunakan alternatif: {found}")
+            # update atribut di module config agar konsisten
+            try:
+                config.DATA_PATH = str(found)
+            except Exception:
+                pass
+            data_path = found
+        else:
+            raise FileNotFoundError(
+                f"config.DATA_PATH='{config.DATA_PATH}' tidak ditemukan. "
+                f"Pastikan folder dataset ada atau set config.DATA_PATH ke path yang benar."
+            )
+
+    # --- LANGKAH A: Muat Dataset Induk ---
+    print(f"[Data] Memuat dataset induk dari: {data_path}")
+    full_dataset = datasets.ImageFolder(str(data_path))
+    
+    # Simpan nama kelas
+    class_names = full_dataset.classes
+    num_classes = len(class_names)
+    print(f"[Data] Ditemukan {num_classes} kelas: {class_names}")
+
+    # --- LANGKAH B: Bagi Dataset 80:20 (Secara Hati-hati) ---
+    print(f"[Data] Membagi dataset 80:20 (seed: {config.RANDOM_SEED})...")
+    total_size = len(full_dataset)
+    val_size = int(total_size * config.TEST_SPLIT_SIZE)
+    train_size = total_size - val_size
+    
+    # Bagi dataset menggunakan random_split dengan SEED yang tetap
+    # Ini memastikan pembagian data SELALU SAMA setiap kali skrip dijalankan
+    train_dataset_raw, val_dataset_raw = random_split(
+        full_dataset, 
+        [train_size, val_size],
+        generator=torch.Generator().manual_seed(config.RANDOM_SEED)
+    )
+    
+    print(f"[Data] Ukuran Train: {len(train_dataset_raw)} | Ukuran Validasi: {len(val_dataset_raw)}")
+
+    # --- LANGKAH C: Terapkan Transformasi yang Berbeda ---
+    train_dataset = TransformedDataset(train_dataset_raw, transform=train_transform)
+    val_dataset = TransformedDataset(val_dataset_raw, transform=val_transform)
+
+    # --- LANGKAH D: Mengatasi Ketidakseimbangan Kelas (Wajib!) ---
+    print("[Data] Menghitung bobot untuk mengatasi ketidakseimbangan kelas...")
+    
+    # 1. Ambil semua label (target) HANYA dari set training
+    train_targets = [full_dataset.targets[i] for i in train_dataset_raw.indices]
+    
+    # 2. Hitung jumlah gambar per kelas
+    #    Kita gunakan bincount untuk efisiensi
+    class_counts = np.bincount(train_targets)
+    
+    # 3. Hitung bobot kebalikan (inverse weight) untuk setiap kelas
+    #    Kelas langka -> bobot tinggi
+    #    Kelas umum -> bobot rendah
+    class_weights = 1.0 / torch.tensor(class_counts, dtype=torch.float)
+    
+    # 4. Buat daftar bobot untuk SETIAP sampel di set training
+    #    Setiap sampel akan memiliki bobot sesuai kelasnya
+    sample_weights = class_weights[train_targets]
+    
+    # 5. Buat Sampler
+    #    WeightedRandomSampler akan mengambil data berdasarkan bobot ini
+    train_sampler = WeightedRandomSampler(
+        weights=sample_weights,
+        num_samples=len(sample_weights),
+        replacement=True # Izinkan pengambilan sampel berulang (oversampling)
+    )
+    
+    print("[Data] WeightedRandomSampler berhasil dibuat.")
+
+    # --- LANGKAH E: Buat DataLoaders ---
+    
+    # DataLoader untuk Training
+    # PENTING: Jika menggunakan 'sampler', 'shuffle' HARUS False.
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=config.BATCH_SIZE,
+        sampler=train_sampler,
+        num_workers=2, # Disable multiprocessing untuk Windows
+        pin_memory=False, # Disable untuk CPU training
+        shuffle=False 
+    )
+    
+    # DataLoader untuk Validasi
+    # Tidak perlu sampler, tidak perlu shuffle (evaluasi harus konsisten)
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=config.BATCH_SIZE,
+        num_workers=2, # Disable multiprocessing untuk Windows
+        pin_memory=False, # Disable untuk CPU training
+        shuffle=False 
+    )
+    
+    print("[Data] Data loader untuk Train dan Validasi siap.")
+    
+    return train_loader, val_loader, class_names
+
+
+# --- 5. Blok Pengujian (Opsional tapi Sangat Direkomendasikan) ---
+# Kode ini HANYA akan berjalan jika Anda menjalankan file ini secara langsung
+# (misal: `python src/data_loader.py`)
+# Ini sangat berguna untuk memverifikasi bahwa loader Anda berfungsi.
+
+if __name__ == "__main__":
+    print("Menjalankan pengujian data_loader.py...")
+    
+    # Coba buat data loader
+    train_loader, val_loader, class_names = create_dataloaders()
+    
+    print(f"\nTotal kelas: {len(class_names)}")
+    
+    # Ambil satu batch dari train_loader
+    print("\nMengambil 1 batch dari train_loader (untuk tes)...")
+    with warnings.catch_warnings():
+        warnings.simplefilter("ignore") # Abaikan peringatan UserWarning dari matplotlib
+        
+        try:
+            images, labels = next(iter(train_loader))
+            
+            print(f"  > Ukuran batch gambar: {images.shape}") # [Batch, Channel, H, W]
+            print(f"  > Ukuran batch label: {labels.shape}")
+            print(f"  > Contoh 5 label di batch ini: {labels[:5]}")
+            
+            # Coba visualisasikan 1 gambar (untuk cek normalisasi)
+            img_to_show = images[0].permute(1, 2, 0).numpy() # Ubah (C, H, W) -> (H, W, C)
+            # Denormalisasi (penting untuk visualisasi)
+            img_to_show = STD * img_to_show + MEAN 
+            img_to_show = np.clip(img_to_show, 0, 1) # Pastikan nilai antara 0 dan 1
+            
+            plt.imshow(img_to_show)
+            plt.title(f"Contoh Gambar (Label: {class_names[labels[0]]})")
+            plt.axis('off')
+            plt.show()
+            
+            print("\n[Sukses] data_loader.py berfungsi dengan baik!")
+            
+        except Exception as e:
+            print(f"\n[Error] Gagal menguji data loader: {e}")

download_script.py

@@ -0,0 +1,71 @@
+import os
+from datasets import load_dataset
+# PASTIKAN INI ADA: Kita tambahkan UnidentifiedImageError agar bisa ditangkap
+from PIL import Image, UnidentifiedImageError
+
+# Nama dataset dari Hugging Face Hub
+dataset_name = "muhammadsalmanalfaridzi/Batik-Indonesia"
+# Folder utama untuk menyimpan gambar JPG
+output_dir = "Batik_Indonesia_JPG"
+
+# Buat folder utama jika belum ada
+if not os.path.exists(output_dir):
+    os.makedirs(output_dir)
+
+# Muat dataset (akan menggunakan cache jika sudah diunduh)
+print("Memuat dataset...")
+# Kita tambahkan parameter 'all' untuk split agar memuat semua data
+dataset = load_dataset(dataset_name, split='train') 
+print("Dataset dimuat.")
+
+# Ambil informasi nama kelas/label dari dataset
+labels = dataset.features['label'].names
+
+# Proses dan simpan setiap gambar dari split 'train'
+print("Memulai proses ekstraksi gambar...")
+skipped_files = 0
+
+# Ganti loop untuk menggunakan 'dataset' langsung
+for item in dataset:
+    # ---- INI BAGIAN PENTING (TRY...EXCEPT) ----
+    # Kita "coba" lakukan semua proses ini
+    try:
+        # Ambil gambar dan labelnya
+        gambar: Image.Image = item['image']
+        label_index = item['label']
+
+        # Dapatkan nama label (contoh: "Batik Parang")
+        label_name = labels[label_index]
+
+        # Buat folder untuk kelas ini jika belum ada
+        class_dir = os.path.join(output_dir, label_name)
+        if not os.path.exists(class_dir):
+            os.makedirs(class_dir)
+
+        # Ambil nama file asli (jika tersedia) atau buat nama file unik
+        num_existing_files = len(os.listdir(class_dir))
+        file_name = f"{label_name.replace(' ', '_')}_{num_existing_files + 1}.jpg"
+
+        # Gabungkan path untuk menyimpan
+        save_path = os.path.join(class_dir, file_name)
+
+        # Simpan gambar
+        if gambar.mode != 'RGB':
+            gambar = gambar.convert('RGB')
+        gambar.save(save_path)
+
+    # Jika terjadi error "UnidentifiedImageError" (file rusak),
+    # jalankan kode di bawah ini alih-alih crash.
+    except UnidentifiedImageError:
+        skipped_files += 1
+        # Kita bisa cetak file yang rusak jika mau
+        # print(f"WARNING: 1 file gambar terdeteksi rusak atau tidak valid. Melewati...")
+
+    # Tambahkan exception umum untuk error lain
+    except Exception as e:
+        skipped_files += 1
+        print(f"WARNING: Terjadi error lain ({e}). Melewati file...")
+    # -----------------------------------------------
+
+print(f"Ekstraksi selesai!")
+print(f"Total file yang dilewati (rusak/error): {skipped_files}")

engine.py

@@ -0,0 +1,96 @@
+import torch
+import torch.nn as nn
+from tqdm.auto import tqdm # Untuk progress bar yang bagus
+
+def train_step(model: torch.nn.Module, 
+               dataloader: torch.utils.data.DataLoader, 
+               loss_fn: torch.nn.Module, 
+               optimizer: torch.optim.Optimizer,
+               device: torch.device):
+    """
+    Melakukan satu epoch training.
+    
+    Mengatur model ke mode training, melakukan forward pass,
+    menghitung loss, melakukan backpropagation, dan update weights.
+    """
+    # 1. Set model ke mode training
+    # Ini penting untuk mengaktifkan lapisan seperti Dropout dan BatchNorm
+    model.train()
+    
+    # 2. Setup variabel pelacak loss dan akurasi
+    train_loss, train_acc = 0, 0
+    
+    # 3. Loop melalui data loader
+    # Gunakan tqdm untuk progress bar
+    for X, y in tqdm(dataloader, desc="Training"):
+        # Pindahkan data ke device (GPU jika ada)
+        X, y = X.to(device), y.to(device)
+        
+        # 4. Forward pass
+        y_pred_logits = model(X)
+        
+        # 5. Hitung loss
+        loss = loss_fn(y_pred_logits, y)
+        train_loss += loss.item() 
+        
+        # 6. Nol-kan gradien optimizer
+        optimizer.zero_grad()
+        
+        # 7. Backpropagation
+        loss.backward()
+        
+        # 8. Update weights
+        optimizer.step()
+        
+        # 9. Hitung akurasi
+        # Ambil kelas dengan probabilitas tertinggi
+        y_pred_class = torch.argmax(y_pred_logits, dim=1)
+        train_acc += (y_pred_class == y).sum().item() / len(y_pred_logits)
+        
+    # 10. Hitung rata-rata loss dan akurasi per epoch
+    train_loss = train_loss / len(dataloader)
+    train_acc = train_acc / len(dataloader)
+    
+    return train_loss, train_acc
+
+def val_step(model: torch.nn.Module, 
+             dataloader: torch.utils.data.DataLoader, 
+             loss_fn: torch.nn.Module,
+             device: torch.device):
+    """
+    Melakukan satu epoch validasi.
+    
+    Mengatur model ke mode evaluasi, melakukan forward pass,
+    dan menghitung loss/akurasi. Tidak ada backpropagation.
+    """
+    # 1. Set model ke mode evaluasi
+    # Ini penting untuk menonaktifkan Dropout dan BatchNorm
+    model.eval() 
+    
+    # 2. Setup variabel pelacak loss dan akurasi
+    val_loss, val_acc = 0, 0
+    
+    # 3. Matikan perhitungan gradien
+    # Ini menghemat memori dan komputasi
+    with torch.no_grad():
+        # 4. Loop melalui data loader
+        for X, y in tqdm(dataloader, desc="Validasi"):
+            # Pindahkan data ke device
+            X, y = X.to(device), y.to(device)
+            
+            # 5. Forward pass
+            y_pred_logits = model(X)
+            
+            # 6. Hitung loss
+            loss = loss_fn(y_pred_logits, y)
+            val_loss += loss.item()
+            
+            # 7. Hitung akurasi
+            y_pred_class = torch.argmax(y_pred_logits, dim=1)
+            val_acc += (y_pred_class == y).sum().item() / len(y_pred_logits)
+            
+    # 8. Hitung rata-rata loss dan akurasi per epoch
+    val_loss = val_loss / len(dataloader)
+    val_acc = val_acc / len(dataloader)
+    
+    return val_loss, val_acc

enhanced_config.py

@@ -0,0 +1,453 @@
+import torch
+from pathlib import Path
+
+# Definisikan ROOT path proyek (folder batik_vision_project)
+ROOT_PATH = Path(__file__).resolve().parent.parent 
+
+# Path ke data
+DATA_PATH = ROOT_PATH / "Batik-Indonesia" # <-- GANTI BARIS INI
+
+# Enhanced Hyperparameters untuk Anti-Overfitting
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+BATCH_SIZE = 32  # Optimal batch size untuk stabilitas
+IMAGE_SIZE = 224 # Ukuran input untuk ViT/Swin
+LEARNING_RATE = 3e-5  # Learning rate lebih kecil untuk stabilitas
+EPOCHS = 60  # Lebih banyak epoch dengan early stopping
+
+# Pengaturan split
+TEST_SPLIT_SIZE = 0.2 # 20% untuk validasi
+RANDOM_SEED = 42 # Agar hasil split selalu sama
+
+# Enhanced Training Parameters
+DROPOUT_RATE = 0.7  # Dropout rate yang lebih agresif
+WEIGHT_DECAY = 2e-3  # Weight decay yang lebih besar
+EARLY_STOPPING_PATIENCE = 7  # Patience untuk early stopping
+
+# Advanced Augmentation Parameters
+MIXUP_ALPHA = 0.2  # Mixup parameter
+CUTMIX_ALPHA = 1.0  # CutMix parameter
+LABEL_SMOOTHING = 0.1  # Label smoothing parameter
+FOCAL_LOSS_ALPHA = 1.0  # Focal loss alpha
+FOCAL_LOSS_GAMMA = 2.0  # Focal loss gamma
+
+# Learning Rate Scheduler
+SCHEDULER_METHOD = 'cosine_warmup'  # 'cosine_warmup', 'onecycle', 'plateau'
+SCHEDULER_T0 = 10  # For CosineAnnealingWarmRestarts
+SCHEDULER_T_MULT = 2  # For CosineAnnealingWarmRestarts
+SCHEDULER_ETA_MIN = 1e-7  # Minimum learning rate
+
+# Test Time Augmentation
+TTA_NUM_AUGMENTATIONS = 5  # Number of TTA augmentations
+
+# Daftar model yang akan diuji
+# Mulai dengan model terkecil dulu untuk testing awal
+MODEL_LIST = ["convnext_tiny"]  # Model terkecil untuk testing awal
+
+# Enhanced Model Configuration
+ENHANCED_TRAINING = True  # Flag untuk enhanced training
+USE_MIXUP = True  # Enable Mixup augmentation
+USE_CUTMIX = True  # Enable CutMix augmentation
+USE_LABEL_SMOOTHING = True  # Enable label smoothing
+USE_FOCAL_LOSS = True  # Enable focal loss
+USE_TTA = True  # Enable test time augmentation
+
+# Gradient Clipping
+GRADIENT_CLIPPING = True
+MAX_GRAD_NORM = 1.0
+
+# Logging Configuration
+LOG_INTERVAL = 10  # Log every N batches
+SAVE_BEST_MODEL = True  # Save best model during training
+SAVE_CONFUSION_MATRIX = True  # Save confusion matrix
+SAVE_CLASSIFICATION_REPORT = True  # Save classification report
+
+# Advanced Regularization
+USE_CUTOUT = True  # Enable Cutout augmentation
+CUTOUT_LENGTH = 16  # Cutout length
+USE_MIXUP_CUTMIX_PROBABILITY = True  # Randomly choose between Mixup and CutMix
+
+# Class Balancing
+CLASS_BALANCING_METHOD = 'balanced'  # 'balanced', 'inverse', 'sqrt'
+USE_WEIGHTED_SAMPLER = True  # Use weighted random sampler
+
+# Model Architecture Enhancements
+USE_ADAPTIVE_AVG_POOL = True  # Use adaptive average pooling
+USE_BATCH_NORM = True  # Use batch normalization
+USE_GROUP_NORM = False  # Use group normalization instead of batch norm
+
+# Training Monitoring
+MONITOR_METRICS = ['loss', 'accuracy', 'f1_score', 'precision', 'recall']
+EARLY_STOPPING_METRIC = 'val_accuracy'  # Metric to monitor for early stopping
+EARLY_STOPPING_MODE = 'max'  # 'max' for accuracy, 'min' for loss
+
+# Data Loading
+NUM_WORKERS = 4  # Number of data loading workers
+PIN_MEMORY = True  # Pin memory for faster GPU transfer
+PERSISTENT_WORKERS = True  # Keep workers alive between epochs
+
+# Mixed Precision Training
+USE_MIXED_PRECISION = False  # Enable mixed precision training (requires apex)
+SCALER_GROWTH_INTERVAL = 2000  # Growth interval for scaler
+
+# Model Checkpointing
+CHECKPOINT_INTERVAL = 5  # Save checkpoint every N epochs
+KEEP_BEST_N_MODELS = 3  # Keep only the best N models
+
+# Validation Configuration
+VALIDATION_FREQUENCY = 1  # Validate every N epochs
+VALIDATION_BATCH_SIZE = None  # Use same batch size as training if None
+
+# Advanced Loss Functions
+LOSS_FUNCTION_WEIGHTS = {
+    'label_smoothing': 0.7,
+    'focal_loss': 0.3
+}
+
+# Augmentation Probabilities
+AUGMENTATION_PROBABILITIES = {
+    'mixup': 0.3,
+    'cutmix': 0.3,
+    'none': 0.4
+}
+
+# Learning Rate Warmup
+USE_WARMUP = True
+WARMUP_EPOCHS = 5
+WARMUP_FACTOR = 0.1
+
+# Model Ensemble
+USE_MODEL_ENSEMBLE = False  # Enable model ensemble
+ENSEMBLE_MODELS = []  # List of models to ensemble
+
+# Advanced Optimizer Settings
+OPTIMIZER_BETAS = (0.9, 0.999)  # Adam betas
+OPTIMIZER_EPS = 1e-8  # Adam epsilon
+OPTIMIZER_MOMENTUM = 0.9  # SGD momentum
+
+# Data Augmentation Strengths
+AUGMENTATION_STRENGTHS = {
+    'rotation': 15,
+    'brightness': 0.2,
+    'contrast': 0.2,
+    'saturation': 0.2,
+    'hue': 0.05,
+    'perspective': 0.2,
+    'erasing': 0.2
+}
+
+# Model Performance Tracking
+TRACK_PER_CLASS_METRICS = True  # Track per-class metrics
+SAVE_PREDICTIONS = True  # Save model predictions
+SAVE_ATTENTION_MAPS = False  # Save attention maps (for attention-based models)
+
+# Advanced Regularization Techniques
+USE_DROPCONNECT = False  # Use DropConnect
+USE_STOCHASTIC_DEPTH = False  # Use stochastic depth
+STOCHASTIC_DEPTH_RATE = 0.1  # Stochastic depth rate
+
+# Model Compression
+USE_KNOWLEDGE_DISTILLATION = False  # Use knowledge distillation
+TEACHER_MODEL_PATH = None  # Path to teacher model
+DISTILLATION_TEMPERATURE = 3.0  # Distillation temperature
+DISTILLATION_ALPHA = 0.7  # Distillation alpha
+
+# Advanced Data Loading
+USE_SMART_SAMPLING = True  # Use smart sampling for imbalanced data
+SMART_SAMPLING_STRATEGY = 'focal'  # 'focal', 'hard', 'easy'
+USE_DYNAMIC_BATCH_SIZE = False  # Use dynamic batch size
+MIN_BATCH_SIZE = 16  # Minimum batch size
+MAX_BATCH_SIZE = 64  # Maximum batch size
+
+# Model Architecture Search
+USE_ARCHITECTURE_SEARCH = False  # Use neural architecture search
+ARCHITECTURE_SEARCH_SPACE = []  # Architecture search space
+
+# Advanced Training Techniques
+USE_CURRICULUM_LEARNING = False  # Use curriculum learning
+CURRICULUM_STRATEGY = 'easy_to_hard'  # Curriculum strategy
+USE_PROGRESSIVE_TRAINING = False  # Use progressive training
+PROGRESSIVE_STAGES = []  # Progressive training stages
+
+# Model Interpretability
+USE_GRAD_CAM = False  # Use Grad-CAM for interpretability
+USE_LIME = False  # Use LIME for interpretability
+USE_SHAP = False  # Use SHAP for interpretability
+
+# Advanced Evaluation
+USE_K_FOLD_CROSS_VALIDATION = False  # Use k-fold cross validation
+K_FOLD_SPLITS = 5  # Number of k-fold splits
+USE_STRATIFIED_K_FOLD = True  # Use stratified k-fold
+
+# Model Deployment
+MODEL_QUANTIZATION = False  # Use model quantization
+QUANTIZATION_BITS = 8  # Quantization bits
+USE_TORCHSCRIPT = False  # Convert model to TorchScript
+
+# Advanced Logging
+USE_WANDB = False  # Use Weights & Biases logging
+WANDB_PROJECT = 'batik-vision'  # WANDB project name
+USE_TENSORBOARD = True  # Use TensorBoard logging
+LOG_GRADIENTS = False  # Log gradients
+LOG_WEIGHTS = False  # Log weights
+
+# Model Comparison
+COMPARE_WITH_BASELINE = True  # Compare with baseline model
+BASELINE_MODEL_PATH = None  # Path to baseline model
+USE_STATISTICAL_TESTS = True  # Use statistical tests for comparison
+
+# Advanced Data Processing
+USE_AUTO_AUGMENT = True  # Use AutoAugment
+AUTO_AUGMENT_POLICY = 'imagenet'  # AutoAugment policy
+USE_RANDAUGMENT = True  # Use RandAugment
+RANDAUGMENT_N = 2  # RandAugment N
+RANDAUGMENT_M = 9  # RandAugment M
+
+# Model Robustness
+USE_ADVERSARIAL_TRAINING = False  # Use adversarial training
+ADVERSARIAL_EPSILON = 0.03  # Adversarial epsilon
+ADVERSARIAL_ALPHA = 0.007  # Adversarial alpha
+ADVERSARIAL_STEPS = 7  # Adversarial steps
+
+# Advanced Loss Functions
+USE_CENTER_LOSS = False  # Use center loss
+CENTER_LOSS_ALPHA = 0.5  # Center loss alpha
+USE_TRIPLET_LOSS = False  # Use triplet loss
+TRIPLET_MARGIN = 1.0  # Triplet margin
+
+# Model Ensemble Techniques
+USE_BAGGING = False  # Use bagging
+BAGGING_N_MODELS = 5  # Number of models for bagging
+USE_BOOSTING = False  # Use boosting
+BOOSTING_N_MODELS = 5  # Number of models for boosting
+
+# Advanced Regularization
+USE_SPECTRAL_NORM = False  # Use spectral normalization
+USE_WEIGHT_NORM = False  # Use weight normalization
+USE_LAYER_NORM = False  # Use layer normalization
+
+# Model Architecture Enhancements
+USE_SE_BLOCKS = False  # Use Squeeze-and-Excitation blocks
+USE_CBAM = False  # Use Convolutional Block Attention Module
+USE_ECA = False  # Use Efficient Channel Attention
+
+# Advanced Training Techniques
+USE_COSINE_ANNEALING = True  # Use cosine annealing
+COSINE_ANNEALING_T_MAX = 50  # Cosine annealing T_max
+USE_CYCLIC_LR = False  # Use cyclic learning rate
+CYCLIC_LR_BASE = 1e-6  # Cyclic LR base
+CYCLIC_LR_MAX = 1e-3  # Cyclic LR max
+
+# Model Performance Optimization
+USE_MODEL_PARALLELISM = False  # Use model parallelism
+USE_DATA_PARALLELISM = True  # Use data parallelism
+USE_GRADIENT_CHECKPOINTING = False  # Use gradient checkpointing
+
+# Advanced Data Augmentation
+USE_COLOR_DISTORTION = True  # Use color distortion
+COLOR_DISTORTION_STRENGTH = 0.5  # Color distortion strength
+USE_GAUSSIAN_BLUR = True  # Use Gaussian blur
+GAUSSIAN_BLUR_PROBABILITY = 0.1  # Gaussian blur probability
+USE_SOLARIZATION = False  # Use solarization
+SOLARIZATION_THRESHOLD = 128  # Solarization threshold
+
+# Model Interpretability
+USE_ATTENTION_VISUALIZATION = False  # Use attention visualization
+ATTENTION_LAYERS = []  # Layers to visualize attention
+USE_FEATURE_MAPS = False  # Use feature maps visualization
+
+# Advanced Evaluation Metrics
+USE_COCO_METRICS = False  # Use COCO metrics
+USE_PASCAL_VOC_METRICS = False  # Use Pascal VOC metrics
+USE_CUSTOM_METRICS = True  # Use custom metrics
+
+# Model Deployment Optimization
+USE_ONNX_EXPORT = False  # Export to ONNX
+ONNX_OPSET_VERSION = 11  # ONNX opset version
+USE_TENSORRT = False  # Use TensorRT optimization
+TENSORRT_PRECISION = 'fp16'  # TensorRT precision
+
+# Advanced Training Monitoring
+USE_EARLY_STOPPING_V2 = True  # Use enhanced early stopping
+EARLY_STOPPING_MIN_DELTA = 0.001  # Minimum delta for early stopping
+EARLY_STOPPING_RESTORE_BEST_WEIGHTS = True  # Restore best weights
+
+# Model Architecture Optimization
+USE_EFFICIENT_NET = False  # Use EfficientNet
+EFFICIENT_NET_VERSION = 'b0'  # EfficientNet version
+USE_MOBILENET = False  # Use MobileNet
+MOBILENET_VERSION = 'v2'  # MobileNet version
+
+# Advanced Data Processing
+USE_SMART_CROP = True  # Use smart cropping
+SMART_CROP_RATIO = 0.875  # Smart crop ratio
+USE_MULTI_SCALE_TRAINING = False  # Use multi-scale training
+MULTI_SCALE_RATIOS = [0.8, 1.0, 1.2]  # Multi-scale ratios
+
+# Model Performance Analysis
+USE_PERFORMANCE_PROFILING = False  # Use performance profiling
+PROFILING_BATCHES = 10  # Number of batches to profile
+USE_MEMORY_PROFILING = False  # Use memory profiling
+
+# Advanced Regularization Techniques
+USE_DROPOUT_SCHEDULING = False  # Use dropout scheduling
+DROPOUT_SCHEDULE_START = 0.1  # Dropout schedule start
+DROPOUT_SCHEDULE_END = 0.5  # Dropout schedule end
+
+# Model Architecture Enhancements
+USE_RESIDUAL_CONNECTIONS = True  # Use residual connections
+USE_DENSE_CONNECTIONS = False  # Use dense connections
+USE_INCEPTION_BLOCKS = False  # Use Inception blocks
+
+# Advanced Training Techniques
+USE_META_LEARNING = False  # Use meta-learning
+META_LEARNING_STEPS = 5  # Meta-learning steps
+USE_FEW_SHOT_LEARNING = False  # Use few-shot learning
+FEW_SHOT_SHOTS = 5  # Number of shots for few-shot learning
+
+# Model Compression Techniques
+USE_PRUNING = False  # Use model pruning
+PRUNING_RATIO = 0.1  # Pruning ratio
+USE_QUANTIZATION_AWARE_TRAINING = False  # Use quantization-aware training
+
+# Advanced Data Augmentation
+USE_MIXUP_V2 = True  # Use enhanced Mixup
+MIXUP_V2_ALPHA = 0.2  # Enhanced Mixup alpha
+USE_CUTMIX_V2 = True  # Use enhanced CutMix
+CUTMIX_V2_ALPHA = 1.0  # Enhanced CutMix alpha
+
+# Model Architecture Search
+USE_NAS = False  # Use Neural Architecture Search
+NAS_SEARCH_SPACE = 'darts'  # NAS search space
+NAS_EPOCHS = 50  # NAS epochs
+
+# Advanced Training Monitoring
+USE_LEARNING_RATE_FINDER = False  # Use learning rate finder
+LR_FINDER_START = 1e-7  # LR finder start
+LR_FINDER_END = 1e-1  # LR finder end
+LR_FINDER_STEPS = 100  # LR finder steps
+
+# Model Performance Optimization
+USE_GRADIENT_ACCUMULATION = False  # Use gradient accumulation
+GRADIENT_ACCUMULATION_STEPS = 4  # Gradient accumulation steps
+USE_MIXED_PRECISION_V2 = False  # Use enhanced mixed precision
+
+# Advanced Regularization
+USE_WEIGHT_DECAY_SCHEDULING = False  # Use weight decay scheduling
+WEIGHT_DECAY_SCHEDULE_START = 1e-4  # Weight decay schedule start
+WEIGHT_DECAY_SCHEDULE_END = 1e-3  # Weight decay schedule end
+
+# Model Architecture Enhancements
+USE_TRANSFORMER_BLOCKS = False  # Use Transformer blocks
+TRANSFORMER_NUM_HEADS = 8  # Transformer number of heads
+TRANSFORMER_DIM = 512  # Transformer dimension
+
+# Advanced Training Techniques
+USE_CURRICULUM_LEARNING_V2 = False  # Use enhanced curriculum learning
+CURRICULUM_STRATEGY_V2 = 'difficulty'  # Enhanced curriculum strategy
+USE_PROGRESSIVE_TRAINING_V2 = False  # Use enhanced progressive training
+
+# Model Performance Analysis
+USE_CONFUSION_MATRIX_ANALYSIS = True  # Use confusion matrix analysis
+USE_ROC_CURVE_ANALYSIS = True  # Use ROC curve analysis
+USE_PRECISION_RECALL_ANALYSIS = True  # Use precision-recall analysis
+
+# Advanced Data Processing
+USE_SMART_AUGMENTATION = True  # Use smart augmentation
+SMART_AUGMENTATION_STRATEGY = 'adaptive'  # Smart augmentation strategy
+USE_DYNAMIC_AUGMENTATION = False  # Use dynamic augmentation
+
+# Model Architecture Optimization
+USE_EFFICIENT_NET_V2 = False  # Use EfficientNetV2
+EFFICIENT_NET_V2_VERSION = 's'  # EfficientNetV2 version
+USE_VISION_TRANSFORMER = False  # Use Vision Transformer
+VISION_TRANSFORMER_PATCH_SIZE = 16  # Vision Transformer patch size
+
+# Advanced Training Monitoring
+USE_TRAINING_MONITORING_V2 = True  # Use enhanced training monitoring
+MONITORING_METRICS_V2 = ['loss', 'accuracy', 'f1', 'precision', 'recall']  # Enhanced monitoring metrics
+USE_REAL_TIME_MONITORING = False  # Use real-time monitoring
+
+# Model Performance Optimization
+USE_MODEL_OPTIMIZATION_V2 = True  # Use enhanced model optimization
+OPTIMIZATION_TECHNIQUES_V2 = ['pruning', 'quantization', 'distillation']  # Enhanced optimization techniques
+USE_AUTOMATIC_OPTIMIZATION = False  # Use automatic optimization
+
+# Advanced Regularization Techniques
+USE_REGULARIZATION_V2 = True  # Use enhanced regularization
+REGULARIZATION_TECHNIQUES_V2 = ['dropout', 'weight_decay', 'label_smoothing']  # Enhanced regularization techniques
+USE_ADAPTIVE_REGULARIZATION = False  # Use adaptive regularization
+
+# Model Architecture Enhancements
+USE_ARCHITECTURE_ENHANCEMENTS_V2 = True  # Use enhanced architecture enhancements
+ARCHITECTURE_ENHANCEMENTS_V2 = ['attention', 'skip_connections', 'normalization']  # Enhanced architecture enhancements
+USE_DYNAMIC_ARCHITECTURE = False  # Use dynamic architecture
+
+# Advanced Training Techniques
+USE_TRAINING_TECHNIQUES_V2 = True  # Use enhanced training techniques
+TRAINING_TECHNIQUES_V2 = ['mixup', 'cutmix', 'label_smoothing', 'focal_loss']  # Enhanced training techniques
+USE_ADAPTIVE_TRAINING = False  # Use adaptive training
+
+# Model Performance Analysis
+USE_PERFORMANCE_ANALYSIS_V2 = True  # Use enhanced performance analysis
+PERFORMANCE_ANALYSIS_V2 = ['confusion_matrix', 'roc_curve', 'precision_recall']  # Enhanced performance analysis
+USE_COMPARATIVE_ANALYSIS = True  # Use comparative analysis
+
+# Advanced Data Processing
+USE_DATA_PROCESSING_V2 = True  # Use enhanced data processing
+DATA_PROCESSING_V2 = ['smart_augmentation', 'dynamic_sampling', 'adaptive_preprocessing']  # Enhanced data processing
+USE_INTELLIGENT_PREPROCESSING = False  # Use intelligent preprocessing
+
+# Model Architecture Optimization
+USE_ARCHITECTURE_OPTIMIZATION_V2 = True  # Use enhanced architecture optimization
+ARCHITECTURE_OPTIMIZATION_V2 = ['efficient_net', 'vision_transformer', 'convnext']  # Enhanced architecture optimization
+USE_AUTOMATIC_ARCHITECTURE_SEARCH = False  # Use automatic architecture search
+
+# Advanced Training Monitoring
+USE_MONITORING_V2 = True  # Use enhanced monitoring
+MONITORING_V2 = ['real_time', 'adaptive', 'intelligent']  # Enhanced monitoring
+USE_PREDICTIVE_MONITORING = False  # Use predictive monitoring
+
+# Model Performance Optimization
+USE_OPTIMIZATION_V2 = True  # Use enhanced optimization
+OPTIMIZATION_V2 = ['automatic', 'adaptive', 'intelligent']  # Enhanced optimization
+USE_SELF_OPTIMIZING_MODEL = False  # Use self-optimizing model
+
+# Advanced Regularization Techniques
+USE_REGULARIZATION_V3 = True  # Use latest regularization techniques
+REGULARIZATION_V3 = ['advanced_dropout', 'adaptive_weight_decay', 'smart_label_smoothing']  # Latest regularization techniques
+USE_NEURAL_REGULARIZATION = False  # Use neural regularization
+
+# Model Architecture Enhancements
+USE_ARCHITECTURE_ENHANCEMENTS_V3 = True  # Use latest architecture enhancements
+ARCHITECTURE_ENHANCEMENTS_V3 = ['transformer_attention', 'dynamic_skip_connections', 'adaptive_normalization']  # Latest architecture enhancements
+USE_NEURAL_ARCHITECTURE = False  # Use neural architecture
+
+# Advanced Training Techniques
+USE_TRAINING_TECHNIQUES_V3 = True  # Use latest training techniques
+TRAINING_TECHNIQUES_V3 = ['advanced_mixup', 'smart_cutmix', 'adaptive_label_smoothing', 'neural_focal_loss']  # Latest training techniques
+USE_NEURAL_TRAINING = False  # Use neural training
+
+# Model Performance Analysis
+USE_PERFORMANCE_ANALYSIS_V3 = True  # Use latest performance analysis
+PERFORMANCE_ANALYSIS_V3 = ['advanced_confusion_matrix', 'neural_roc_curve', 'smart_precision_recall']  # Latest performance analysis
+USE_NEURAL_ANALYSIS = False  # Use neural analysis
+
+# Advanced Data Processing
+USE_DATA_PROCESSING_V3 = True  # Use latest data processing
+DATA_PROCESSING_V3 = ['neural_augmentation', 'smart_sampling', 'adaptive_preprocessing']  # Latest data processing
+USE_NEURAL_PREPROCESSING = False  # Use neural preprocessing
+
+# Model Architecture Optimization
+USE_ARCHITECTURE_OPTIMIZATION_V3 = True  # Use latest architecture optimization
+ARCHITECTURE_OPTIMIZATION_V3 = ['neural_efficient_net', 'advanced_vision_transformer', 'smart_convnext']  # Latest architecture optimization
+USE_NEURAL_ARCHITECTURE_SEARCH = False  # Use neural architecture search
+
+# Advanced Training Monitoring
+USE_MONITORING_V3 = True  # Use latest monitoring
+MONITORING_V3 = ['neural_monitoring', 'adaptive_monitoring', 'intelligent_monitoring']  # Latest monitoring
+USE_NEURAL_MONITORING = False  # Use neural monitoring
+
+# Model Performance Optimization
+USE_OPTIMIZATION_V3 = True  # Use latest optimization
+OPTIMIZATION_V3 = ['neural_optimization', 'adaptive_optimization', 'intelligent_optimization']  # Latest optimization
+USE_NEURAL_OPTIMIZATION = False  # Use neural optimization

mixup.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+import numpy as np
+
+def mixup_data(x, y, alpha=1.0, device='cuda'):
+    """
+    Mixup data augmentation.
+    
+    Args:
+        x: Input batch
+        y: Target batch
+        alpha: Mixup parameter (higher = more mixing)
+        device: Device to run on
+    
+    Returns:
+        mixed_x: Mixed input batch
+        y_a, y_b: Original targets for loss calculation
+        lam: Mixing ratio
+    """
+    if alpha > 0:
+        lam = np.random.beta(alpha, alpha)
+    else:
+        lam = 1
+
+    batch_size = x.size(0)
+    if device == 'cuda':
+        index = torch.randperm(batch_size).cuda()
+    else:
+        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
+
+def mixup_criterion(criterion, pred, y_a, y_b, lam):
+    """
+    Mixup loss calculation.
+    
+    Args:
+        criterion: Loss function
+        pred: Model predictions
+        y_a, y_b: Original targets
+        lam: Mixing ratio
+    
+    Returns:
+        Mixed loss
+    """
+    return lam * criterion(pred, y_a) + (1 - lam) * criterion(pred, y_b)
+
+class MixupTrainer:
+    """
+    Mixup training wrapper.
+    """
+    def __init__(self, model, optimizer, criterion, device, alpha=0.2):
+        self.model = model
+        self.optimizer = optimizer
+        self.criterion = criterion
+        self.device = device
+        self.alpha = alpha
+    
+    def train_step(self, dataloader):
+        """
+        Single training step with mixup.
+        """
+        self.model.train()
+        total_loss = 0
+        correct = 0
+        total = 0
+        
+        for batch_idx, (data, target) in enumerate(dataloader):
+            data, target = data.to(self.device), target.to(self.device)
+            
+            # Apply mixup
+            data, target_a, target_b, lam = mixup_data(data, target, self.alpha, self.device)
+            
+            self.optimizer.zero_grad()
+            output = self.model(data)
+            loss = mixup_criterion(self.criterion, output, target_a, target_b, lam)
+            loss.backward()
+            self.optimizer.step()
+            
+            total_loss += loss.item()
+            # For accuracy calculation, use original targets
+            _, predicted = torch.max(output.data, 1)
+            total += target.size(0)
+            correct += (lam * predicted.eq(target_a.data).cpu().sum().float() + 
+                       (1 - lam) * predicted.eq(target_b.data).cpu().sum().float())
+        
+        avg_loss = total_loss / len(dataloader)
+        accuracy = 100. * correct / total
+        
+        return avg_loss, accuracy.item()

model.py

@@ -0,0 +1,100 @@
+import sys
+from pathlib import Path
+# tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import timm
+import torch
+from src import config # Kita import config untuk daftar model dan device
+
+def create_model(model_name: str, num_classes: int, pretrained: bool = True, dropout_rate: float = 0.1):
+    """
+    Membuat model Computer Vision dari library timm.
+    
+    Args:
+        model_name (str): Nama model yang akan dibuat (misal: 'vit_base_patch16_224').
+        num_classes (int): Jumlah kelas output (misal: 38 untuk batik).
+        pretrained (bool): Apakah akan menggunakan bobot pre-trained ImageNet.
+        dropout_rate (float): Dropout rate untuk regularization.
+    
+    Returns:
+        torch.nn.Module: Model yang sudah dibuat.
+    """
+    print(f"[Model] Membuat model: {model_name}...")
+    
+    try:
+        # timm.create_model adalah fungsi ajaib:
+        # 1. 'pretrained=True' akan otomatis men-download bobot ImageNet.
+        # 2. 'num_classes=num_classes' akan otomatis MENGGANTI
+        #    layer klasifikasi terakhir (misal: 1000 kelas ImageNet)
+        #    dengan layer baru yang sesuai jumlah kelas kita (38 kelas).
+        model = timm.create_model(
+            model_name,
+            pretrained=pretrained,
+            num_classes=num_classes,
+            drop_rate=dropout_rate  # Tambah dropout untuk regularization
+        )
+        return model
+    
+    except Exception as e:
+        print(f"[Error] Gagal membuat model {model_name}: {e}")
+        return None
+
+# --- Blok Pengujian (Sangat Direkomendasikan) ---
+# Kode ini HANYA akan berjalan jika Anda menjalankan file ini secara langsung
+# (misal: `python src/models.py`)
+
+if __name__ == "__main__":
+    print("Menjalankan pengujian models.py...")
+    
+    # Kita butuh jumlah kelas untuk pengujian
+    # Cara cepat: hitung folder di DATA_PATH dari config
+    import os
+    try:
+        NUM_CLASSES = len(os.listdir(config.DATA_PATH))
+        print(f"  > Ditemukan {NUM_CLASSES} kelas dari {config.DATA_PATH}")
+    except FileNotFoundError:
+        print(f"  > Error: Folder data di {config.DATA_PATH} tidak ditemukan.")
+        print("  > Menggunakan 38 sebagai jumlah kelas default untuk tes.")
+        NUM_CLASSES = 38 # Default jika data path salah
+
+    # Buat data input palsu (dummy input) untuk tes
+    # Ukuran: [Batch, Channel, Height, Width]
+    dummy_input = torch.randn(
+        2, 3, config.IMAGE_SIZE, config.IMAGE_SIZE
+    ).to(config.DEVICE)
+    
+    print(f"  > Membuat data input palsu ukuran: {dummy_input.shape}")
+    print("-" * 30)
+
+    # Loop dan uji setiap model dalam daftar di config.py
+    for model_name_key in config.MODEL_LIST:
+        
+        # Ini adalah nama-nama model yang sebenarnya di library 'timm'
+        model_arch_names = {
+            "vit": "vit_base_patch16_224",
+            "swin_transformer": "swin_base_patch4_window7_224",
+            "convnext_tiny": "convnext_tiny"
+        }
+        
+        model_name = model_arch_names.get(model_name_key)
+        
+        if model_name:
+            model = create_model(model_name=model_name, num_classes=NUM_CLASSES)
+            
+            if model:
+                model = model.to(config.DEVICE)
+                model.eval() # Set ke mode evaluasi untuk tes
+                
+                # Coba lewatkan data palsu ke model
+                with torch.no_grad():
+                    output = model(dummy_input)
+                
+                print(f"  > Tes Forward Pass... SUKSES")
+                print(f"  > Ukuran Output: {output.shape}") # Harusnya [2, 38]
+                print(f"  > Tes {model_name_key} selesai.")
+                print("-" * 30)
+        else:
+            print(f"[Warning] Kunci model '{model_name_key}' di config.py tidak dikenali.")
+
+    print("\n[Sukses] models.py berfungsi dengan baik!")

outputs/batik_classification_20251019_084142/logs/events.out.tfevents.1760838102.DESKTOP-RLV6U3K.16452.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:31139d0f09600ee5665b8f2438a723cfd7fa7cd6f296a40632c12642d4ad72d8
+size 292

outputs/batik_classification_20251019_084142/models/vit_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c298c3781719d857855c90fb865b3c4fa0a7fe17913885ae793f7de6cdfbd676
+size 1030115429

outputs/enhanced_anti_overfitting_20251023_084927/logs/events.out.tfevents.1761184167.DESKTOP-RLV6U3K.5684.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3dc48c14c38c3bd740a32cd0381a7e70c37038790478d42aeab6e32ff96c13e8
+size 88

outputs/optimized_training_20251019_113350/logs/events.out.tfevents.1760848430.DESKTOP-RLV6U3K.9796.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2783cde1bef2c72212f54633fa90a564d2b16ab9a65207419d9905f8bbe761c2
+size 88

outputs/optimized_training_20251019_113629/logs/events.out.tfevents.1760848589.DESKTOP-RLV6U3K.4876.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:759373e9454d9f40f382bf13cac9ea5e2c571dca5f3a5b6398ebcb32b60273f8
+size 3565

outputs/optimized_training_20251019_113629/models/convnext_tiny_best.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caae235c11f0a39108dd83599ad2f5edb15073435a56cf48c00fa641c4138fc0
+size 334416025

outputs/optimized_training_20251023_084043/logs/events.out.tfevents.1761183643.DESKTOP-RLV6U3K.16508.0

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:283f90668cffa1b39b0feaa672b83bd708d834c6cc102d824928a1796a9168ad
+size 88

train.py

@@ -0,0 +1,380 @@
+import sys
+from pathlib import Path
+# Tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR
+
+# Import modul yang sudah dibuat
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+
+def setup_experiment_logging(experiment_name: str):
+    """
+    Setup logging dan direktori untuk eksperimen.
+    
+    Args:
+        experiment_name (str): Nama eksperimen
+        
+    Returns:
+        tuple: (writer, experiment_dir, model_dir)
+    """
+    # Buat direktori untuk eksperimen
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"{experiment_name}_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+    
+    # Buat direktori jika belum ada
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    # Setup TensorBoard writer
+    writer = SummaryWriter(log_dir=str(log_dir))
+    
+    print(f"[Setup] Eksperimen: {experiment_name}")
+    print(f"[Setup] Direktori: {experiment_dir}")
+    print(f"[Setup] Model akan disimpan di: {model_dir}")
+    print(f"[Setup] Logs akan disimpan di: {log_dir}")
+    
+    return writer, experiment_dir, model_dir
+
+def save_training_results(experiment_dir: Path, model_name: str, 
+                         train_losses: list, val_losses: list, 
+                         train_accs: list, val_accs: list, 
+                         best_val_acc: float, best_epoch: int):
+    """
+    Simpan hasil training dalam format JSON dan plot.
+    
+    Args:
+        experiment_dir (Path): Direktori eksperimen
+        model_name (str): Nama model
+        train_losses (list): List loss training per epoch
+        val_losses (list): List loss validasi per epoch
+        train_accs (list): List akurasi training per epoch
+        val_accs (list): List akurasi validasi per epoch
+        best_val_acc (float): Akurasi validasi terbaik
+        best_epoch (int): Epoch dengan akurasi terbaik
+    """
+    # Simpan hasil dalam format JSON
+    results = {
+        "model_name": model_name,
+        "best_val_accuracy": best_val_acc,
+        "best_epoch": best_epoch,
+        "total_epochs": len(train_losses),
+        "train_losses": train_losses,
+        "val_losses": val_losses,
+        "train_accuracies": train_accs,
+        "val_accuracies": val_accs,
+        "config": {
+            "batch_size": config.BATCH_SIZE,
+            "learning_rate": config.LEARNING_RATE,
+            "image_size": config.IMAGE_SIZE,
+            "epochs": config.EPOCHS,
+            "device": config.DEVICE
+        }
+    }
+    
+    # Simpan JSON
+    results_file = experiment_dir / f"{model_name}_results.json"
+    with open(results_file, 'w') as f:
+        json.dump(results, f, indent=2)
+    
+    # Buat plot training curves
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+    
+    # Plot Loss
+    epochs = range(1, len(train_losses) + 1)
+    ax1.plot(epochs, train_losses, 'b-', label='Training Loss')
+    ax1.plot(epochs, val_losses, 'r-', label='Validation Loss')
+    ax1.set_title(f'{model_name} - Training & Validation Loss')
+    ax1.set_xlabel('Epoch')
+    ax1.set_ylabel('Loss')
+    ax1.legend()
+    ax1.grid(True)
+    
+    # Plot Accuracy
+    ax2.plot(epochs, train_accs, 'b-', label='Training Accuracy')
+    ax2.plot(epochs, val_accs, 'r-', label='Validation Accuracy')
+    ax2.set_title(f'{model_name} - Training & Validation Accuracy')
+    ax2.set_xlabel('Epoch')
+    ax2.set_ylabel('Accuracy')
+    ax2.legend()
+    ax2.grid(True)
+    
+    # Simpan plot
+    plot_file = experiment_dir / f"{model_name}_training_curves.png"
+    plt.tight_layout()
+    plt.savefig(plot_file, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    print(f"[Save] Hasil training disimpan di: {results_file}")
+    print(f"[Save] Plot training disimpan di: {plot_file}")
+
+def train_model(model_name_key: str, model_name: str, num_classes: int, 
+                train_loader, val_loader, writer, model_dir: Path):
+    """
+    Melatih satu model dan menyimpan hasilnya.
+    
+    Args:
+        model_name_key (str): Kunci model dari config (misal: 'vit')
+        model_name (str): Nama model timm (misal: 'vit_base_patch16_224')
+        num_classes (int): Jumlah kelas
+        train_loader: DataLoader untuk training
+        val_loader: DataLoader untuk validasi
+        writer: TensorBoard writer
+        model_dir (Path): Direktori untuk menyimpan model
+        
+    Returns:
+        dict: Hasil training (best accuracy, best epoch, dll)
+    """
+    print(f"\n{'='*60}")
+    print(f"TRAINING MODEL: {model_name_key.upper()} ({model_name})")
+    print(f"{'='*60}")
+    
+    # 1. Buat model
+    model = create_model(model_name, num_classes, pretrained=True)
+    if model is None:
+        print(f"[Error] Gagal membuat model {model_name}")
+        return None
+    
+    model = model.to(config.DEVICE)
+    
+    # 2. Setup loss function dan optimizer
+    loss_fn = nn.CrossEntropyLoss()
+    # Optimizer dengan weight decay untuk regularization
+    optimizer = optim.Adam(model.parameters(), lr=config.LEARNING_RATE, weight_decay=1e-4)
+    
+    # 3. Setup learning rate scheduler
+    scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3, verbose=True)
+    
+    # 4. Setup tracking variables
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    
+    # 5. Early stopping
+    patience = 7  # Stop jika tidak ada improvement selama 7 epoch
+    epochs_no_improve = 0
+    
+    # 4. Training loop
+    print(f"[Training] Memulai training untuk {config.EPOCHS} epochs...")
+    print(f"[Training] Device: {config.DEVICE}")
+    print(f"[Training] Learning Rate: {config.LEARNING_RATE}")
+    print(f"[Training] Batch Size: {config.BATCH_SIZE}")
+    
+    start_time = time.time()
+    
+    for epoch in range(config.EPOCHS):
+        print(f"\n[Epoch {epoch+1}/{config.EPOCHS}]")
+        
+        # Training step
+        train_loss, train_acc = train_step(
+            model=model,
+            dataloader=train_loader,
+            loss_fn=loss_fn,
+            optimizer=optimizer,
+            device=config.DEVICE
+        )
+        
+        # Validation step
+        val_loss, val_acc = val_step(
+            model=model,
+            dataloader=val_loader,
+            loss_fn=loss_fn,
+            device=config.DEVICE
+        )
+        
+        # Update learning rate scheduler
+        scheduler.step(val_acc)  # Beri tahu scheduler nilai val_acc terbaru
+        
+        # Simpan metrics
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+        
+        # Log ke TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        
+# Cek apakah ini model terbaik
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            
+            # --- TAMBAHKAN INI ---
+            epochs_no_improve = 0 # Reset counter kesabaran
+            # ---------------------
+            
+            # Simpan model terbaik
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                # ... (isi torch.save Anda) ...
+            }, model_path)
+            print(f"[Save] Model terbaik disimpan di: {model_path}")
+            
+        # --- TAMBAHKAN BLOK ELSE INI ---
+        else:
+            epochs_no_improve += 1 # Tambah counter jika tidak ada kemajuan
+        # ---------------------------------
+            
+        # Print progress
+        print(f"   Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.4f}")
+        print(f"   Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.4f}")
+        print(f"   Best Val Acc: {best_val_acc:.4f} (Epoch {best_epoch})")
+        
+        # --- TAMBAHKAN BLOK IF INI (Cek Early Stopping) ---
+        if epochs_no_improve >= patience:
+            print(f"\n[Info] Early stopping! Tidak ada kemajuan selama {patience} epoch.")
+            print(f"[Info] Model terbaik ada di Epoch {best_epoch} dengan Val Acc: {best_val_acc:.4f}")
+            break  # Hentikan (keluar dari) loop epoch
+    end_time = time.time()
+    training_time = end_time - start_time
+    
+    print(f"\n[Training] Selesai dalam {training_time:.2f} detik")
+    print(f"[Training] Best Validation Accuracy: {best_val_acc:.4f} (Epoch {best_epoch})")
+    
+    # Simpan model final
+    final_model_path = model_dir / f"{model_name_key}_final.pth"
+    torch.save({
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'epoch': config.EPOCHS,
+        'val_accuracy': val_acc,
+        'model_name': model_name,
+        'num_classes': num_classes
+    }, final_model_path)
+    
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+def main():
+    """
+    Fungsi utama untuk menjalankan training semua model.
+    """
+    print("="*80)
+    print("BATIK VISION PROJECT - TRAINING SCRIPT")
+    print("="*80)
+    
+    # 1. Setup eksperimen
+    experiment_name = "batik_classification"
+    writer, experiment_dir, model_dir = setup_experiment_logging(experiment_name)
+    
+    # 2. Buat data loaders
+    print("\n[Data] Membuat data loaders...")
+    try:
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"[Data] Berhasil! {num_classes} kelas ditemukan.")
+        print(f"[Data] Kelas: {class_names}")
+    except Exception as e:
+        print(f"[Error] Gagal membuat data loaders: {e}")
+        return
+    
+    # 3. Mapping model names dari config ke timm
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224", 
+        "convnext_tiny": "convnext_tiny"
+    }
+    
+    # 4. Training loop untuk setiap model
+    all_results = []
+    
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"[Warning] Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+            
+        model_name = model_mapping[model_name_key]
+        
+        try:
+            # Train model
+            result = train_model(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir
+            )
+            
+            if result:
+                all_results.append(result)
+                
+                # Simpan hasil individual
+                save_training_results(
+                    experiment_dir=experiment_dir,
+                    model_name=model_name_key,
+                    train_losses=result['train_losses'],
+                    val_losses=result['val_losses'],
+                    train_accs=result['train_accs'],
+                    val_accs=result['val_accs'],
+                    best_val_acc=result['best_val_acc'],
+                    best_epoch=result['best_epoch']
+                )
+                
+        except Exception as e:
+            print(f"[Error] Gagal training model {model_name_key}: {e}")
+            continue
+    
+    # 5. Simpan ringkasan hasil
+    if all_results:
+        summary = {
+            "experiment_name": experiment_name,
+            "timestamp": datetime.now().isoformat(),
+            "total_models": len(all_results),
+            "results": all_results,
+            "best_model": max(all_results, key=lambda x: x['best_val_acc'])
+        }
+        
+        summary_file = experiment_dir / "training_summary.json"
+        with open(summary_file, 'w') as f:
+            json.dump(summary, f, indent=2)
+        
+        print(f"\n{'='*60}")
+        print("RINGKASAN HASIL TRAINING")
+        print(f"{'='*60}")
+        
+        for result in all_results:
+            print(f"{result['model_name']:15} | Best Val Acc: {result['best_val_acc']:.4f} | "
+                  f"Final Val Acc: {result['final_val_acc']:.4f} | "
+                  f"Time: {result['training_time']:.1f}s")
+        
+        best_model = summary['best_model']
+        print(f"\nModel terbaik: {best_model['model_name']} dengan akurasi {best_model['best_val_acc']:.4f}")
+        print(f"Ringkasan lengkap disimpan di: {summary_file}")
+    
+    # 6. Tutup TensorBoard writer
+    writer.close()
+    print(f"\n[Complete] Training selesai! Hasil disimpan di: {experiment_dir}")
+
+if __name__ == "__main__":
+    main()

train_anti_overfitting.py

@@ -0,0 +1,354 @@
+import sys
+from pathlib import Path
+# Tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, classification_report
+from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import modul yang sudah dibuat
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+
+def setup_anti_overfitting_training():
+    """
+    Setup untuk training anti-overfitting yang sangat agresif.
+    """
+    print("SETUP TRAINING ANTI-OVERFITTING - AGGRESSIVE")
+    print("="*60)
+    
+    # Override config untuk training anti-overfitting
+    config.BATCH_SIZE = 32  # Batch size lebih besar untuk stabilisasi
+    config.EPOCHS = 50      # Lebih banyak epoch dengan early stopping
+    config.IMAGE_SIZE = 224  # Resolusi standar
+    config.LEARNING_RATE = 5e-5  # Learning rate lebih kecil
+    
+    print(f"Konfigurasi Anti-Overfitting:")
+    print(f"   - Batch Size: {config.BATCH_SIZE}")
+    print(f"   - Epochs: {config.EPOCHS}")
+    print(f"   - Image Size: {config.IMAGE_SIZE}x{config.IMAGE_SIZE}")
+    print(f"   - Learning Rate: {config.LEARNING_RATE}")
+    print(f"   - Device: {config.DEVICE}")
+    print(f"   - Model: {config.MODEL_LIST[0] if config.MODEL_LIST else 'None'}")
+    
+    # Buat direktori untuk hasil
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"anti_overfitting_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+    
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    writer = SummaryWriter(log_dir=str(log_dir))
+    
+    return writer, experiment_dir, model_dir
+
+def add_dropout_to_model(model, dropout_rate=0.5):
+    """
+    Menambahkan dropout layers ke model untuk mengurangi overfitting.
+    """
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear) and 'head' in name:
+            # Tambahkan dropout sebelum classifier head
+            new_head = nn.Sequential(
+                nn.Dropout(dropout_rate),
+                module
+            )
+            # Ganti head dengan dropout
+            parent_name = '.'.join(name.split('.')[:-1])
+            if parent_name:
+                parent_module = model.get_submodule(parent_name)
+                setattr(parent_module, name.split('.')[-1], new_head)
+            else:
+                setattr(model, name.split('.')[-1], new_head)
+    
+    return model
+
+def train_anti_overfitting_model(model_name_key: str, model_name: str, num_classes: int, 
+                                train_loader, val_loader, writer, model_dir: Path, class_names):
+    """
+    Training model dengan teknik anti-overfitting yang sangat agresif.
+    """
+    print(f"\nTRAINING MODEL: {model_name_key.upper()}")
+    print(f"   Model: {model_name}")
+    print(f"   Classes: {num_classes}")
+    print("-" * 50)
+    
+    # Buat model
+    model = create_model(model_name, num_classes, pretrained=True)
+    if model is None:
+        print(f"ERROR: Gagal membuat model {model_name}")
+        return None
+    
+    # Tambahkan dropout untuk mengurangi overfitting
+    model = add_dropout_to_model(model, dropout_rate=0.6)
+    
+    model = model.to(config.DEVICE)
+    
+    # Setup optimizer dengan weight decay yang lebih besar
+    loss_fn = nn.CrossEntropyLoss()
+    optimizer = optim.AdamW(model.parameters(), lr=config.LEARNING_RATE, weight_decay=1e-3)
+    
+    # Setup learning rate scheduler yang lebih agresif
+    scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.3, patience=2, min_lr=1e-7)
+    
+    # Tracking variables
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    
+    # Early stopping yang lebih ketat
+    patience = 5  # Stop jika tidak ada improvement selama 5 epoch
+    epochs_no_improve = 0
+    
+    print(f"Memulai training {config.EPOCHS} epochs...")
+    print(f"   Early Stopping: {patience} epochs patience")
+    print(f"   Learning Rate Scheduler: ReduceLROnPlateau (factor=0.3)")
+    print(f"   Weight Decay: 1e-3 (AdamW)")
+    print(f"   Dropout Rate: 0.6")
+    
+    start_time = time.time()
+    
+    for epoch in range(config.EPOCHS):
+        print(f"\nEpoch {epoch+1}/{config.EPOCHS}")
+        
+        # Training
+        train_loss, train_acc = train_step(
+            model=model, dataloader=train_loader, loss_fn=loss_fn,
+            optimizer=optimizer, device=config.DEVICE
+        )
+        
+        # Validation
+        val_loss, val_acc = val_step(
+            model=model, dataloader=val_loader, loss_fn=loss_fn,
+            device=config.DEVICE
+        )
+        
+        # Update learning rate scheduler
+        scheduler.step(val_acc)
+        
+        # Simpan metrics
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+        
+        # Log ke TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Learning_Rate', optimizer.param_groups[0]['lr'], epoch)
+        
+        # Cek model terbaik
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            epochs_no_improve = 0  # Reset counter
+            
+            # Simpan model terbaik
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict(),
+                'epoch': epoch + 1,
+                'val_accuracy': val_acc,
+                'model_name': model_name,
+                'num_classes': num_classes
+            }, model_path)
+            print(f"Model terbaik disimpan: {model_path}")
+        else:
+            epochs_no_improve += 1
+        
+        # Progress
+        print(f"   Train: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
+        print(f"   Val:   Loss={val_loss:.4f}, Acc={val_acc:.4f}")
+        print(f"   Best:  {best_val_acc:.4f} (Epoch {best_epoch})")
+        print(f"   LR:    {optimizer.param_groups[0]['lr']:.2e}")
+        print(f"   No Improve: {epochs_no_improve}/{patience}")
+        
+        # Early stopping check
+        if epochs_no_improve >= patience:
+            print(f"\nEarly stopping! Tidak ada kemajuan selama {patience} epoch.")
+            print(f"Model terbaik: Epoch {best_epoch} dengan Val Acc: {best_val_acc:.4f}")
+            break
+    
+    end_time = time.time()
+    training_time = end_time - start_time
+    
+    print(f"\nTraining selesai!")
+    print(f"   Waktu: {training_time:.1f} detik")
+    print(f"   Best Accuracy: {best_val_acc:.4f}")
+    print(f"   Epochs trained: {epoch + 1}")
+    
+    # Generate confusion matrix dan classification report
+    print(f"\nGenerating Confusion Matrix dan Classification Report...")
+    generate_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key)
+    
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'epochs_trained': epoch + 1,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+def generate_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key):
+    """
+    Generate confusion matrix dan classification report.
+    """
+    model.eval()
+    all_preds = []
+    all_labels = []
+    
+    print("   Mengumpulkan prediksi untuk confusion matrix...")
+    with torch.no_grad():
+        for X, y in val_loader:
+            X, y = X.to(config.DEVICE), y.to(config.DEVICE)
+            outputs = model(X)
+            _, predicted = torch.max(outputs, 1)
+            
+            all_preds.extend(predicted.cpu().numpy())
+            all_labels.extend(y.cpu().numpy())
+    
+    # Generate confusion matrix
+    cm = confusion_matrix(all_labels, all_preds)
+    
+    # Plot confusion matrix
+    plt.figure(figsize=(15, 12))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                xticklabels=class_names, yticklabels=class_names)
+    plt.title(f'Confusion Matrix - {model_name_key.upper()}')
+    plt.xlabel('Predicted')
+    plt.ylabel('Actual')
+    plt.xticks(rotation=45, ha='right')
+    plt.yticks(rotation=0)
+    plt.tight_layout()
+    
+    # Simpan confusion matrix
+    cm_path = model_dir / f"{model_name_key}_confusion_matrix.png"
+    plt.savefig(cm_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    # Generate classification report
+    report = classification_report(all_labels, all_preds, 
+                                 target_names=class_names, 
+                                 output_dict=True)
+    
+    # Simpan classification report
+    report_path = model_dir / f"{model_name_key}_classification_report.json"
+    with open(report_path, 'w') as f:
+        json.dump(report, f, indent=2)
+    
+    # Print summary
+    print(f"   Confusion Matrix disimpan: {cm_path}")
+    print(f"   Classification Report disimpan: {report_path}")
+    
+    # Print per-class accuracy
+    print(f"\n   Per-Class Accuracy:")
+    for i, class_name in enumerate(class_names):
+        if i < len(report) - 3:  # Exclude 'accuracy', 'macro avg', 'weighted avg'
+            acc = report[class_name]['f1-score']
+            print(f"   {class_name:25}: {acc:.4f}")
+
+def main():
+    """
+    Training anti-overfitting dengan teknik yang sangat agresif.
+    """
+    print("BATIK VISION - ANTI-OVERFITTING TRAINING MODE")
+    print("="*60)
+    
+    # 1. Setup training anti-overfitting
+    writer, experiment_dir, model_dir = setup_anti_overfitting_training()
+    
+    # 2. Buat data loaders
+    print("\nMembuat data loaders...")
+    try:
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"Data siap! {num_classes} kelas ditemukan.")
+        print(f"   Kelas: {class_names[:5]}{'...' if len(class_names) > 5 else ''}")
+    except Exception as e:
+        print(f"ERROR data loader: {e}")
+        return
+    
+    # 3. Model mapping
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224", 
+        "convnext_tiny": "convnext_tiny"
+    }
+    
+    # 4. Training
+    all_results = []
+    
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"WARNING: Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+            
+        model_name = model_mapping[model_name_key]
+        
+        try:
+            result = train_anti_overfitting_model(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir,
+                class_names=class_names
+            )
+            
+            if result:
+                all_results.append(result)
+                
+        except Exception as e:
+            print(f"ERROR training {model_name_key}: {e}")
+            continue
+    
+    # 5. Ringkasan
+    if all_results:
+        print(f"\nRINGKASAN HASIL")
+        print("="*40)
+        
+        for result in all_results:
+            print(f"{result['model_name']:15} | "
+                  f"Best: {result['best_val_acc']:.4f} | "
+                  f"Epochs: {result['epochs_trained']} | "
+                  f"Time: {result['training_time']:.1f}s")
+        
+        best_model = max(all_results, key=lambda x: x['best_val_acc'])
+        print(f"\nModel terbaik: {best_model['model_name']} "
+              f"({best_model['best_val_acc']:.4f})")
+    
+    writer.close()
+    print(f"\nHasil disimpan di: {experiment_dir}")
+
+if __name__ == "__main__":
+    main()

train_anti_overfitting_v2.py

@@ -0,0 +1,529 @@
+"""
+train_anti_overfitting_v2.py
+
+Versi upgrade dari `train_anti_overfitting.py`:
+- MixUp & CutMix augmentation (opsional, diaktifkan via flag)
+- Label smoothing pada CrossEntropyLoss
+- Dropout ditambahkan ke classifier head dan block terakhir (jika tersedia)
+- Gradient clipping
+- CosineAnnealingWarmRestarts scheduler (default) + optional ReduceLROnPlateau
+- Class-weighting support (opsional, dihitung dari train labels jika tersedia)
+- Freeze backbone untuk N epoch pertama (fine-tune strategy)
+- Menyimpan plot loss/accuracy otomatis dan classification report + confusion matrix
+
+Catatan: script ini mengasumsikan struktur proyek yang sama (src.config, src.data_loader, src.model, src.engine).
+Jalankan dari root project (sama seperti script lama).
+"""
+
+import sys
+from pathlib import Path
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, classification_report
+from sklearn.utils.class_weight import compute_class_weight
+import warnings
+warnings.filterwarnings('ignore')
+
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+
+# --------------------------- Augmentation utilities ---------------------------
+
+def mixup_data(x, y, alpha=0.4, device='cpu'):
+    if alpha <= 0:
+        return x, y, None, 1.0
+    lam = np.random.beta(alpha, alpha)
+    batch_size = x.size()[0]
+    index = torch.randperm(batch_size).to(device)
+    mixed_x = lam * x + (1 - lam) * x[index, :]
+    y_a, y_b = y, y[index]
+    return mixed_x, y_a, y_b, lam
+
+
+def cutmix_data(x, y, alpha=1.0, device='cpu'):
+    if alpha <= 0:
+        return x, y, None, 1.0
+    lam = np.random.beta(alpha, alpha)
+    batch_size, _, H, W = x.size()
+    index = torch.randperm(batch_size).to(device)
+
+    # sample bounding box
+    cut_rat = np.sqrt(1. - lam)
+    cut_w = np.int(W * cut_rat)
+    cut_h = np.int(H * cut_rat)
+
+    cx = np.random.randint(W)
+    cy = np.random.randint(H)
+
+    x1 = np.clip(cx - cut_w // 2, 0, W)
+    y1 = np.clip(cy - cut_h // 2, 0, H)
+    x2 = np.clip(cx + cut_w // 2, 0, W)
+    y2 = np.clip(cy + cut_h // 2, 0, H)
+
+    x[:, :, y1:y2, x1:x2] = x[index, :, y1:y2, x1:x2]
+    y_a, y_b = y, y[index]
+    # adjust lambda to actual area
+    lam = 1 - ((x2 - x1) * (y2 - y1) / (W * H))
+    return x, y_a, y_b, lam
+
+# --------------------------- Model modification utilities ---------------------------
+
+def add_dropout_to_head(model, dropout_rate=0.5):
+    """Tambahkan dropout tepat sebelum classifier head (Linear) dengan pendekatan aman."""
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear) and 'head' in name:
+            parent_name = '.'.join(name.split('.')[:-1])
+            attr = name.split('.')[-1]
+            parent = model.get_submodule(parent_name) if parent_name else model
+            linear = getattr(parent, attr)
+            seq = nn.Sequential(nn.Dropout(dropout_rate), linear)
+            setattr(parent, attr, seq)
+    return model
+
+
+def add_dropout_to_last_block(model, dropout_rate=0.3):
+    """Coba tambahkan dropout ke block akhir dari backbone jika attribute dikenali.
+    Implementasi ini aman-check untuk beberapa arsitektur (convnext, timm models).
+    """
+    # ConvNeXt-like: stages / blocks
+    try:
+        if hasattr(model, 'stages'):
+            last_stage = model.stages[-1]
+            # Jika last_stage adalah Sequential of blocks
+            if isinstance(last_stage, (nn.Sequential, list, tuple)):
+                for i, block in enumerate(last_stage):
+                    # tambahkan dropout ke dalam block jika memungkinkan
+                    if isinstance(block, nn.Module):
+                        block.add_module('drop_extra', nn.Dropout(p=dropout_rate))
+                        break  # tambahkan hanya ke block pertama di last stage agar aman
+        # Swin/ViT style: add dropout before head
+        if hasattr(model, 'patch_embed') and hasattr(model, 'norm'):
+            # tambahkan dropout setelah norm
+            model.add_module('backbone_dropout', nn.Dropout(p=dropout_rate))
+    except Exception:
+        # Jika gagal, jangan crash
+        pass
+    return model
+
+# --------------------------- Training utilities ---------------------------
+
+def apply_gradient_clipping(model, max_norm=1.0):
+    torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm)
+
+
+def save_plots(train_losses, val_losses, train_accs, val_accs, out_dir, model_name_key):
+    plt.figure(figsize=(8, 5))
+    plt.plot(train_losses, label='Train Loss')
+    plt.plot(val_losses, label='Val Loss')
+    plt.title('Loss Curve')
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(out_dir / f"{model_name_key}_loss_curve.png", dpi=300)
+    plt.close()
+
+    plt.figure(figsize=(8, 5))
+    plt.plot(train_accs, label='Train Acc')
+    plt.plot(val_accs, label='Val Acc')
+    plt.title('Accuracy Curve')
+    plt.legend()
+    plt.tight_layout()
+    plt.savefig(out_dir / f"{model_name_key}_acc_curve.png", dpi=300)
+    plt.close()
+
+# --------------------------- Main training function ---------------------------
+
+def train_anti_overfitting_model_v2(model_name_key: str, model_name: str, num_classes: int,
+                                    train_loader, val_loader, writer, model_dir: Path, class_names,
+                                    config_overrides=None):
+    """Versi v2: integrasikan MixUp/CutMix, label smoothing, gradient clipping, scheduler CosineWarm.
+    config_overrides: dict optional keys:
+        - mixup_alpha, cutmix_alpha, use_mixup, use_cutmix
+        - dropout_head, dropout_backbone
+        - label_smoothing
+        - freeze_backbone_epochs
+        - use_reduce_on_plateau (bool)
+        - max_grad_norm
+    """
+    co = config_overrides or {}
+    use_mixup = co.get('use_mixup', True)
+    use_cutmix = co.get('use_cutmix', False)
+    mixup_alpha = co.get('mixup_alpha', 0.4)
+    cutmix_alpha = co.get('cutmix_alpha', 1.0)
+    dropout_head = co.get('dropout_head', 0.6)
+    dropout_backbone = co.get('dropout_backbone', 0.3)
+    label_smoothing = co.get('label_smoothing', 0.1)
+    freeze_backbone_epochs = co.get('freeze_backbone_epochs', 5)
+    use_reduce_on_plateau = co.get('use_reduce_on_plateau', False)
+    max_grad_norm = co.get('max_grad_norm', 1.0)
+
+    print(f"\nTRAINING MODEL (v2): {model_name_key.upper()}")
+    print(f"   Model: {model_name}")
+    print(f"   Classes: {num_classes}")
+    print("-"*50)
+
+    # 1) create model
+    model = create_model(model_name, num_classes, pretrained=True)
+    if model is None:
+        print(f"ERROR: Gagal membuat model {model_name}")
+        return None
+
+    # 2) add dropout to head + last block
+    model = add_dropout_to_head(model, dropout_head)
+    model = add_dropout_to_last_block(model, dropout_backbone)
+
+    # 3) move to device
+    model = model.to(config.DEVICE)
+
+    # 4) optionally freeze backbone for few epochs
+    backbone_params = [p for n, p in model.named_parameters() if 'head' not in n and p.requires_grad]
+    def set_backbone_requires_grad(flag):
+        for n, p in model.named_parameters():
+            if 'head' not in n:
+                p.requires_grad = flag
+
+    # 5) Loss function with label smoothing
+    loss_fn = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
+
+    # 6) Optional: compute class weights from train_loader labels
+    try:
+        y_train = []
+        for _, y in train_loader.dataset:  # assumes dataset returns (x, y)
+            y_train.append(int(y))
+        class_weights = compute_class_weight('balanced', classes=np.arange(num_classes), y=y_train)
+        weights = torch.FloatTensor(class_weights).to(config.DEVICE)
+        weighted_loss = nn.CrossEntropyLoss(weight=weights, label_smoothing=label_smoothing)
+        loss_fn = weighted_loss
+        print("   Class weights applied to loss function.")
+    except Exception:
+        # jika gagal hitung, lanjut tanpa class weights
+        pass
+
+    # 7) Optimizer
+    optimizer = optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=config.LEARNING_RATE, weight_decay=1e-3)
+
+    # 8) Scheduler: CosineAnnealingWarmRestarts (default) + optional ReduceLROnPlateau
+    scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=5, T_mult=2, eta_min=1e-7)
+    if use_reduce_on_plateau:
+        plateau = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.3, patience=3, min_lr=1e-7)
+    else:
+        plateau = None
+
+    # tracking
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    patience = 10  # sedikit lebih longgar pada v2
+    epochs_no_improve = 0
+
+    print(f"Memulai training {config.EPOCHS} epochs...")
+    print(f"   Freeze backbone epochs: {freeze_backbone_epochs}")
+    print(f"   MixUp: {use_mixup}, CutMix: {use_cutmix}")
+    print(f"   Label smoothing: {label_smoothing}")
+
+    start_time = time.time()
+    for epoch in range(config.EPOCHS):
+        print(f"\nEpoch {epoch+1}/{config.EPOCHS}")
+
+        # unfreeze if passed freeze_backbone_epochs
+        if epoch == freeze_backbone_epochs:
+            set_backbone_requires_grad(True)
+            # re-init optimizer to include newly trainable params
+            optimizer = optim.AdamW(filter(lambda p: p.requires_grad, model.parameters()), lr=config.LEARNING_RATE, weight_decay=1e-3)
+            # reattach scheduler state if needed (simple approach: recreate)
+            scheduler = torch.optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, T_0=5, T_mult=2, eta_min=1e-7)
+            if plateau is not None:
+                plateau = torch.optim.lr_scheduler.ReduceLROnPlateau(optimizer, mode='max', factor=0.3, patience=3, min_lr=1e-7)
+            print("   Backbone unfrozen and optimizer reinitialized.")
+
+        # TRAIN LOOP (with MixUp/CutMix applied per-batch inside train_step wrapper)
+        model.train()
+        running_loss = 0.0
+        correct = 0
+        total = 0
+
+        for batch in train_loader:
+            inputs, targets = batch
+            inputs = inputs.to(config.DEVICE)
+            targets = targets.to(config.DEVICE)
+
+            # Apply MixUp or CutMix randomly
+            applied_mix = False
+            if use_mixup and np.random.rand() < 0.5:
+                inputs, targets_a, targets_b, lam = mixup_data(inputs, targets, mixup_alpha, device=config.DEVICE)
+                applied_mix = 'mixup'
+            elif use_cutmix and np.random.rand() < 0.5:
+                inputs, targets_a, targets_b, lam = cutmix_data(inputs, targets, cutmix_alpha, device=config.DEVICE)
+                applied_mix = 'cutmix'
+
+            optimizer.zero_grad()
+            outputs = model(inputs)
+
+            if applied_mix:
+                loss = lam * loss_fn(outputs, targets_a) + (1 - lam) * loss_fn(outputs, targets_b)
+            else:
+                loss = loss_fn(outputs, targets)
+
+            loss.backward()
+            # gradient clipping
+            if max_grad_norm:
+                apply_gradient_clipping(model, max_grad_norm)
+            optimizer.step()
+
+            # stats (for accuracy, if mixup applied we approximate by taking max against targets_a)
+            running_loss += loss.item() * inputs.size(0)
+            _, predicted = torch.max(outputs.data, 1)
+            if applied_mix:
+                # count prediction correct if matches either target (loose estimation)
+                correct += (predicted.eq(targets_a).sum().item() + predicted.eq(targets_b).sum().item()) / 2.0
+            else:
+                correct += predicted.eq(targets).sum().item()
+            total += inputs.size(0)
+
+        train_loss = running_loss / total
+        train_acc = correct / total
+
+        # VALIDATION
+        val_loss, val_acc = val_step(model=model, dataloader=val_loader, loss_fn=loss_fn, device=config.DEVICE)
+
+        # scheduler step
+        # CosineWarm uses epoch-based step via scheduler.step(epoch + epoch_fraction) using optimizer state
+        scheduler.step()
+        if plateau is not None:
+            plateau.step(val_acc)
+
+        # store
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+
+        # TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Learning_Rate', optimizer.param_groups[0]['lr'], epoch)
+
+        # best model check
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            epochs_no_improve = 0
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict(),
+                'epoch': epoch + 1,
+                'val_accuracy': val_acc,
+                'model_name': model_name,
+                'num_classes': num_classes
+            }, model_path)
+            print(f"Model terbaik disimpan: {model_path}")
+        else:
+            epochs_no_improve += 1
+
+        print(f"   Train: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
+        print(f"   Val:   Loss={val_loss:.4f}, Acc={val_acc:.4f}")
+        print(f"   Best:  {best_val_acc:.4f} (Epoch {best_epoch})")
+        print(f"   LR:    {optimizer.param_groups[0]['lr']:.2e}")
+        print(f"   No Improve: {epochs_no_improve}/{patience}")
+
+        if epochs_no_improve >= patience:
+            print(f"\nEarly stopping! Tidak ada kemajuan selama {patience} epoch.")
+            print(f"Model terbaik: Epoch {best_epoch} dengan Val Acc: {best_val_acc:.4f}")
+            break
+
+    end_time = time.time()
+    training_time = end_time - start_time
+
+    print(f"\nTraining selesai!")
+    print(f"   Waktu: {training_time:.1f} detik")
+    print(f"   Best Accuracy: {best_val_acc:.4f}")
+    print(f"   Epochs trained: {epoch + 1}")
+
+    # save plots
+    save_plots(train_losses, val_losses, train_accs, val_accs, model_dir, model_name_key)
+
+    # generate confusion matrix + classification report
+    print(f"\nGenerating Confusion Matrix dan Classification Report...")
+    generate_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key)
+
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'epochs_trained': epoch + 1,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+# reuse generate_confusion_matrix dari versi awal (disalin untuk independensi)
+
+def generate_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key):
+    model.eval()
+    all_preds = []
+    all_labels = []
+
+    print("   Mengumpulkan prediksi untuk confusion matrix...")
+    with torch.no_grad():
+        for X, y in val_loader:
+            X, y = X.to(config.DEVICE), y.to(config.DEVICE)
+            outputs = model(X)
+            _, predicted = torch.max(outputs, 1)
+
+            all_preds.extend(predicted.cpu().numpy())
+            all_labels.extend(y.cpu().numpy())
+
+    cm = confusion_matrix(all_labels, all_preds)
+
+    plt.figure(figsize=(15, 12))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
+                xticklabels=class_names, yticklabels=class_names)
+    plt.title(f'Confusion Matrix - {model_name_key.upper()}')
+    plt.xlabel('Predicted')
+    plt.ylabel('Actual')
+    plt.xticks(rotation=45, ha='right')
+    plt.yticks(rotation=0)
+    plt.tight_layout()
+
+    cm_path = model_dir / f"{model_name_key}_confusion_matrix.png"
+    plt.savefig(cm_path, dpi=300, bbox_inches='tight')
+    plt.close()
+
+    report = classification_report(all_labels, all_preds,
+                                 target_names=class_names,
+                                 output_dict=True)
+
+    report_path = model_dir / f"{model_name_key}_classification_report.json"
+    with open(report_path, 'w') as f:
+        json.dump(report, f, indent=2)
+
+    print(f"   Confusion Matrix disimpan: {cm_path}")
+    print(f"   Classification Report disimpan: {report_path}")
+
+    print(f"\n   Per-Class Accuracy:")
+    for i, class_name in enumerate(class_names):
+        if class_name in report:
+            acc = report[class_name]['f1-score']
+            print(f"   {class_name:25}: {acc:.4f}")
+
+# --------------------------- main ---------------------------
+
+def setup_anti_overfitting_training_v2():
+    print("SETUP TRAINING ANTI-OVERFITTING - AGGRESSIVE (v2)")
+    print("="*60)
+
+    # override minimal config
+    config.BATCH_SIZE = getattr(config, 'BATCH_SIZE', 32)
+    config.EPOCHS = getattr(config, 'EPOCHS', 50)
+    config.IMAGE_SIZE = getattr(config, 'IMAGE_SIZE', 224)
+    config.LEARNING_RATE = getattr(config, 'LEARNING_RATE', 5e-5)
+
+    print(f"Konfigurasi (v2): BATCH={config.BATCH_SIZE}, EPOCHS={config.EPOCHS}, IMG={config.IMAGE_SIZE}, LR={config.LEARNING_RATE}")
+
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"anti_overfitting_v2_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+
+    writer = SummaryWriter(log_dir=str(log_dir))
+
+    return writer, experiment_dir, model_dir
+
+
+def main():
+    print("BATIK VISION - ANTI-OVERFITTING TRAINING MODE (v2)")
+    print("="*60)
+
+    writer, experiment_dir, model_dir = setup_anti_overfitting_training_v2()
+
+    print("\nMembuat data loaders...")
+    try:
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"Data siap! {num_classes} kelas ditemukan.")
+    except Exception as e:
+        print(f"ERROR data loader: {e}")
+        return
+
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224",
+        "convnext_tiny": "convnext_tiny"
+    }
+
+    all_results = []
+
+    # Default overrides (kamu bisa ubah sesuai kebutuhan)
+    overrides = {
+        'use_mixup': True,
+        'use_cutmix': False,
+        'mixup_alpha': 0.4,
+        'cutmix_alpha': 1.0,
+        'dropout_head': 0.6,
+        'dropout_backbone': 0.3,
+        'label_smoothing': 0.1,
+        'freeze_backbone_epochs': 5,
+        'use_reduce_on_plateau': False,
+        'max_grad_norm': 1.0
+    }
+
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"WARNING: Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+        model_name = model_mapping[model_name_key]
+        try:
+            result = train_anti_overfitting_model_v2(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir,
+                class_names=class_names,
+                config_overrides=overrides
+            )
+            if result:
+                all_results.append(result)
+        except Exception as e:
+            print(f"ERROR training {model_name_key}: {e}")
+            continue
+
+    if all_results:
+        print(f"\nRINGKASAN HASIL")
+        print("="*40)
+        for result in all_results:
+            print(f"{result['model_name']:15} | Best: {result['best_val_acc']:.4f} | Epochs: {result['epochs_trained']} | Time: {result['training_time']:.1f}s")
+        best_model = max(all_results, key=lambda x: x['best_val_acc'])
+        print(f"\nModel terbaik: {best_model['model_name']} ({best_model['best_val_acc']:.4f})")
+
+    writer.close()
+    print(f"\nHasil disimpan di: {experiment_dir}")
+
+if __name__ == '__main__':
+    main()

train_enhanced_anti_overfitting.py

@@ -0,0 +1,467 @@
+import sys
+from pathlib import Path
+# Tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+import seaborn as sns
+from sklearn.metrics import confusion_matrix, classification_report
+from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR, OneCycleLR
+import warnings
+warnings.filterwarnings('ignore')
+
+# Import modul yang sudah dibuat
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+from src.mixup import mixup_data, mixup_criterion
+from src.advanced_augmentation import (
+    cutmix_data, cutmix_criterion, LabelSmoothingCrossEntropy, 
+    FocalLoss, AdvancedAugmentation, TestTimeAugmentation,
+    calculate_class_weights, get_advanced_scheduler, apply_mixup_cutmix_probability
+)
+
+def setup_enhanced_anti_overfitting_training():
+    """
+    Setup untuk training anti-overfitting yang sangat agresif dengan teknik terbaru.
+    """
+    print("SETUP ENHANCED ANTI-OVERFITTING TRAINING")
+    print("="*60)
+    
+    # Override config untuk training anti-overfitting yang lebih agresif
+    config.BATCH_SIZE = 32  # Batch size optimal
+    config.EPOCHS = 60      # Lebih banyak epoch dengan early stopping
+    config.IMAGE_SIZE = 224  # Resolusi standar
+    config.LEARNING_RATE = 3e-5  # Learning rate lebih kecil untuk stabilitas
+    
+    print(f"Konfigurasi Enhanced Anti-Overfitting:")
+    print(f"   - Batch Size: {config.BATCH_SIZE}")
+    print(f"   - Epochs: {config.EPOCHS}")
+    print(f"   - Image Size: {config.IMAGE_SIZE}x{config.IMAGE_SIZE}")
+    print(f"   - Learning Rate: {config.LEARNING_RATE}")
+    print(f"   - Device: {config.DEVICE}")
+    print(f"   - Model: {config.MODEL_LIST[0] if config.MODEL_LIST else 'None'}")
+    
+    # Buat direktori untuk hasil
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"enhanced_anti_overfitting_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+    
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    writer = SummaryWriter(log_dir=str(log_dir))
+    
+    return writer, experiment_dir, model_dir
+
+def add_enhanced_dropout_to_model(model, dropout_rate=0.7):
+    """
+    Menambahkan dropout layers yang lebih agresif ke model untuk mengurangi overfitting.
+    """
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Linear) and 'head' in name:
+            # Tambahkan dropout yang lebih agresif sebelum classifier head
+            new_head = nn.Sequential(
+                nn.Dropout(dropout_rate),
+                nn.Linear(module.in_features, module.out_features)
+            )
+            # Ganti head dengan dropout
+            parent_name = '.'.join(name.split('.')[:-1])
+            if parent_name:
+                parent_module = model.get_submodule(parent_name)
+                setattr(parent_module, name.split('.')[-1], new_head)
+            else:
+                setattr(model, name.split('.')[-1], new_head)
+    
+    return model
+
+def enhanced_train_step(model, dataloader, loss_fn, optimizer, device, 
+                       use_mixup=True, use_cutmix=True, mixup_alpha=0.2, cutmix_alpha=1.0):
+    """
+    Enhanced training step dengan Mixup dan CutMix.
+    """
+    model.train()
+    train_loss, train_acc = 0, 0
+    
+    for X, y in dataloader:
+        X, y = X.to(device), y.to(device)
+        
+        # Apply Mixup or CutMix with probability
+        augmentation_type = apply_mixup_cutmix_probability()
+        
+        if augmentation_type == 'mixup' and use_mixup:
+            mixed_x, y_a, y_b, lam = mixup_data(X, y, mixup_alpha, device)
+            y_pred_logits = model(mixed_x)
+            loss = mixup_criterion(loss_fn, y_pred_logits, y_a, y_b, lam)
+            
+            # Calculate accuracy with original targets
+            _, predicted = torch.max(y_pred_logits, 1)
+            train_acc += (lam * (predicted == y_a).float() + 
+                         (1 - lam) * (predicted == y_b).float()).mean().item()
+            
+        elif augmentation_type == 'cutmix' and use_cutmix:
+            mixed_x, y_a, y_b, lam = cutmix_data(X, y, cutmix_alpha, device)
+            y_pred_logits = model(mixed_x)
+            loss = cutmix_criterion(loss_fn, y_pred_logits, y_a, y_b, lam)
+            
+            # Calculate accuracy with original targets
+            _, predicted = torch.max(y_pred_logits, 1)
+            train_acc += (lam * (predicted == y_a).float() + 
+                         (1 - lam) * (predicted == y_b).float()).mean().item()
+            
+        else:
+            # Standard training
+            y_pred_logits = model(X)
+            loss = loss_fn(y_pred_logits, y)
+            
+            # Calculate accuracy
+            y_pred_class = torch.argmax(y_pred_logits, dim=1)
+            train_acc += (y_pred_class == y).sum().item() / len(y_pred_logits)
+        
+        train_loss += loss.item()
+        
+        # Backward pass
+        optimizer.zero_grad()
+        loss.backward()
+        
+        # Gradient clipping untuk stabilitas
+        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
+        
+        optimizer.step()
+    
+    train_loss = train_loss / len(dataloader)
+    train_acc = train_acc / len(dataloader)
+    
+    return train_loss, train_acc
+
+def train_enhanced_anti_overfitting_model(model_name_key: str, model_name: str, num_classes: int, 
+                                       train_loader, val_loader, writer, model_dir: Path, class_names):
+    """
+    Training model dengan teknik anti-overfitting yang sangat agresif dan terbaru.
+    """
+    print(f"\nTRAINING ENHANCED MODEL: {model_name_key.upper()}")
+    print(f"   Model: {model_name}")
+    print(f"   Classes: {num_classes}")
+    print("-" * 50)
+    
+    # Buat model
+    model = create_model(model_name, num_classes, pretrained=True)
+    if model is None:
+        print(f"ERROR: Gagal membuat model {model_name}")
+        return None
+    
+    # Tambahkan dropout yang lebih agresif
+    model = add_enhanced_dropout_to_model(model, dropout_rate=0.7)
+    
+    model = model.to(config.DEVICE)
+    
+    # Setup loss function dengan label smoothing dan focal loss
+    # Kombinasi label smoothing dan focal loss untuk mengatasi overfitting dan class imbalance
+    label_smooth_loss = LabelSmoothingCrossEntropy(smoothing=0.2)
+    focal_loss = FocalLoss(alpha=1, gamma=2)
+    
+    # Combined loss function
+    def combined_loss(pred, target):
+        return 0.7 * label_smooth_loss(pred, target) + 0.3 * focal_loss(pred, target)
+    
+    loss_fn = combined_loss
+    
+    # Setup optimizer dengan weight decay yang lebih besar
+    optimizer = optim.AdamW(model.parameters(), lr=config.LEARNING_RATE, weight_decay=2e-3)
+    
+    # Setup advanced learning rate scheduler
+    scheduler = get_advanced_scheduler(optimizer, method='cosine_warmup', total_epochs=config.EPOCHS)
+    
+    # Tracking variables
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    
+    # Early stopping yang lebih ketat
+    patience = 8  # Stop jika tidak ada improvement selama 7 epoch
+    epochs_no_improve = 0
+    
+    print(f"Memulai enhanced training {config.EPOCHS} epochs...")
+    print(f"   Early Stopping: {patience} epochs patience")
+    print(f"   Learning Rate Scheduler: CosineAnnealingWarmRestarts")
+    print(f"   Weight Decay: 2e-3 (AdamW)")
+    print(f"   Dropout Rate: 0.7")
+    print(f"   Loss Function: Combined Label Smoothing + Focal Loss")
+    print(f"   Augmentation: Mixup + CutMix + Advanced Transforms")
+    
+    start_time = time.time()
+    
+    for epoch in range(config.EPOCHS):
+        print(f"\nEpoch {epoch+1}/{config.EPOCHS}")
+        
+        # Enhanced Training dengan Mixup/CutMix
+        train_loss, train_acc = enhanced_train_step(
+            model=model, dataloader=train_loader, loss_fn=loss_fn,
+            optimizer=optimizer, device=config.DEVICE,
+            use_mixup=True, use_cutmix=True, mixup_alpha=0.2, cutmix_alpha=1.0
+        )
+        
+        # Validation
+        val_loss, val_acc = val_step(
+            model=model, dataloader=val_loader, loss_fn=loss_fn,
+            device=config.DEVICE
+        )
+        
+        # Update learning rate scheduler
+        if isinstance(scheduler, OneCycleLR):
+            scheduler.step()
+        else:
+            scheduler.step(val_acc)
+        
+        # Simpan metrics
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+        
+        # Log ke TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Learning_Rate', optimizer.param_groups[0]['lr'], epoch)
+        
+        # Cek model terbaik
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            epochs_no_improve = 0  # Reset counter
+            
+            # Simpan model terbaik
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict(),
+                'epoch': epoch + 1,
+                'val_accuracy': val_acc,
+                'model_name': model_name,
+                'num_classes': num_classes
+            }, model_path)
+            print(f"Model terbaik disimpan: {model_path}")
+        else:
+            epochs_no_improve += 1
+        
+        # Progress
+        print(f"   Train: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
+        print(f"   Val:   Loss={val_loss:.4f}, Acc={val_acc:.4f}")
+        print(f"   Best:  {best_val_acc:.4f} (Epoch {best_epoch})")
+        print(f"   LR:    {optimizer.param_groups[0]['lr']:.2e}")
+        print(f"   No Improve: {epochs_no_improve}/{patience}")
+        
+        # Early stopping check
+        if epochs_no_improve >= patience:
+            print(f"\nEarly stopping! Tidak ada kemajuan selama {patience} epoch.")
+            print(f"Model terbaik: Epoch {best_epoch} dengan Val Acc: {best_val_acc:.4f}")
+            break
+    
+    end_time = time.time()
+    training_time = end_time - start_time
+    
+    print(f"\nEnhanced training selesai!")
+    print(f"   Waktu: {training_time:.1f} detik")
+    print(f"   Best Accuracy: {best_val_acc:.4f}")
+    print(f"   Epochs trained: {epoch + 1}")
+    
+    # Generate confusion matrix dan classification report dengan TTA
+    print(f"\nGenerating Enhanced Confusion Matrix dan Classification Report...")
+    generate_enhanced_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key)
+    
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'epochs_trained': epoch + 1,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+def generate_enhanced_confusion_matrix(model, val_loader, class_names, model_dir, model_name_key):
+    """
+    Generate confusion matrix dan classification report dengan Test Time Augmentation.
+    """
+    model.eval()
+    all_preds = []
+    all_labels = []
+    
+    print("   Mengumpulkan prediksi dengan Test Time Augmentation...")
+    
+    # Setup TTA
+    tta = TestTimeAugmentation(model, config.DEVICE, num_augmentations=5)
+    
+    with torch.no_grad():
+        for X, y in val_loader:
+            X, y = X.to(config.DEVICE), y.to(config.DEVICE)
+            
+            # Use TTA for better predictions
+            batch_preds = []
+            for i in range(X.size(0)):
+                # Convert tensor back to PIL for TTA
+                img_tensor = X[i]
+                # Denormalize
+                img_tensor = img_tensor * torch.tensor([0.229, 0.224, 0.225]).view(3, 1, 1).to(config.DEVICE)
+                img_tensor = img_tensor + torch.tensor([0.485, 0.456, 0.406]).view(3, 1, 1).to(config.DEVICE)
+                img_tensor = torch.clamp(img_tensor, 0, 1)
+                
+                # Convert to PIL
+                from torchvision.transforms import ToPILImage
+                img_pil = ToPILImage()(img_tensor.cpu())
+                
+                # Get TTA prediction
+                tta_pred = tta.predict(img_pil)
+                batch_preds.append(tta_pred)
+            
+            # Stack predictions and get final predictions
+            batch_preds = torch.cat(batch_preds, dim=0)
+            _, predicted = torch.max(batch_preds, 1)
+            
+            all_preds.extend(predicted.cpu().numpy())
+            all_labels.extend(y.cpu().numpy())
+    
+    # Generate confusion matrix
+    cm = confusion_matrix(all_labels, all_preds)
+    
+    # Plot confusion matrix
+    plt.figure(figsize=(15, 12))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                xticklabels=class_names, yticklabels=class_names)
+    plt.title(f'Enhanced Confusion Matrix - {model_name_key.upper()} (with TTA)')
+    plt.xlabel('Predicted')
+    plt.ylabel('Actual')
+    plt.xticks(rotation=45, ha='right')
+    plt.yticks(rotation=0)
+    plt.tight_layout()
+    
+    # Simpan confusion matrix
+    cm_path = model_dir / f"{model_name_key}_enhanced_confusion_matrix.png"
+    plt.savefig(cm_path, dpi=300, bbox_inches='tight')
+    plt.close()
+    
+    # Generate classification report
+    report = classification_report(all_labels, all_preds, 
+                                 target_names=class_names, 
+                                 output_dict=True)
+    
+    # Simpan classification report
+    report_path = model_dir / f"{model_name_key}_enhanced_classification_report.json"
+    with open(report_path, 'w') as f:
+        json.dump(report, f, indent=2)
+    
+    # Print summary
+    print(f"   Enhanced Confusion Matrix disimpan: {cm_path}")
+    print(f"   Enhanced Classification Report disimpan: {report_path}")
+    
+    # Print per-class accuracy
+    print(f"\n   Enhanced Per-Class Accuracy:")
+    for i, class_name in enumerate(class_names):
+        if i < len(report) - 3:  Exclude 'accuracy', 'macro avg', 'weighted avg'
+            acc = report[class_name]['f1-score']
+            print(f"   {class_name:25}: {acc:.4f}")
+
+def main():
+    """
+    Enhanced training anti-overfitting dengan teknik terbaru.
+    """
+    print("BATIK VISION - ENHANCED ANTI-OVERFITTING TRAINING MODE")
+    print("="*60)
+    
+    # 1. Setup enhanced training anti-overfitting
+    writer, experiment_dir, model_dir = setup_enhanced_anti_overfitting_training()
+    
+    # 2. Buat data loaders dengan advanced augmentation
+    print("\nMembuat enhanced data loaders...")
+    try:
+        # Use advanced augmentation
+        aug = AdvancedAugmentation(config.IMAGE_SIZE)
+        
+        # Override the default transforms
+        from src.data_loader import train_transform, val_transform
+        train_transform = aug.get_train_transforms()
+        val_transform = aug.get_val_transforms()
+        
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"Enhanced data siap! {num_classes} kelas ditemukan.")
+        print(f"   Kelas: {class_names[:5]}{'...' if len(class_names) > 5 else ''}")
+    except Exception as e:
+        print(f"ERROR data loader: {e}")
+        return
+    
+    # 3. Model mapping
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224", 
+        #"convnext_tiny": "convnext_tiny"
+    }
+    
+    # 4. Enhanced Training
+    all_results = []
+    
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"WARNING: Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+            
+        model_name = model_mapping[model_name_key]
+        
+        try:
+            result = train_enhanced_anti_overfitting_model(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir,
+                class_names=class_names
+            )
+            
+            if result:
+                all_results.append(result)
+                
+        except Exception as e:
+            print(f"ERROR training {model_name_key}: {e}")
+            continue
+    
+    # 5. Ringkasan
+    if all_results:
+        print(f"\nRINGKASAN HASIL ENHANCED")
+        print("="*40)
+        
+        for result in all_results:
+            print(f"{result['model_name']:15} | "
+                  f"Best: {result['best_val_acc']:.4f} | "
+                  f"Epochs: {result['epochs_trained']} | "
+                  f"Time: {result['training_time']:.1f}s")
+        
+        best_model = max(all_results, key=lambda x: x['best_val_acc'])
+        print(f"\nModel terbaik: {best_model['model_name']} "
+              f"({best_model['best_val_acc']:.4f})")
+    
+    writer.close()
+    print(f"\nHasil disimpan di: {experiment_dir}")
+
+if __name__ == "__main__":
+    main()

train_fast.py

@@ -0,0 +1,229 @@
+import sys
+from pathlib import Path
+# Tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+
+# Import modul yang sudah dibuat
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+
+def setup_fast_training():
+    """
+    Setup untuk training yang lebih cepat di laptop.
+    """
+    print("SETUP TRAINING CEPAT UNTUK LAPTOP")
+    print("="*50)
+    
+    # Override config untuk training cepat
+    config.BATCH_SIZE = 4  # Sangat kecil untuk laptop
+    config.EPOCHS = 3      # Hanya 3 epoch untuk testing
+    config.IMAGE_SIZE = 128  # Resolusi lebih kecil
+    
+    print(f"Konfigurasi Training Cepat:")
+    print(f"   - Batch Size: {config.BATCH_SIZE}")
+    print(f"   - Epochs: {config.EPOCHS}")
+    print(f"   - Image Size: {config.IMAGE_SIZE}x{config.IMAGE_SIZE}")
+    print(f"   - Device: {config.DEVICE}")
+    print(f"   - Model: {config.MODEL_LIST[0] if config.MODEL_LIST else 'None'}")
+    
+    # Buat direktori untuk hasil
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"fast_training_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+    
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    writer = SummaryWriter(log_dir=str(log_dir))
+    
+    return writer, experiment_dir, model_dir
+
+def train_fast_model(model_name_key: str, model_name: str, num_classes: int, 
+                    train_loader, val_loader, writer, model_dir: Path):
+    """
+    Training model dengan optimasi untuk laptop.
+    """
+    print(f"\nTRAINING MODEL: {model_name_key.upper()}")
+    print(f"   Model: {model_name}")
+    print(f"   Classes: {num_classes}")
+    print("-" * 40)
+    
+    # Buat model
+    model = create_model(model_name, num_classes, pretrained=True)
+    if model is None:
+        print(f"ERROR: Gagal membuat model {model_name}")
+        return None
+    
+    model = model.to(config.DEVICE)
+    
+    # Setup optimizer dengan learning rate yang lebih tinggi untuk konvergensi cepat
+    loss_fn = nn.CrossEntropyLoss()
+    optimizer = optim.Adam(model.parameters(), lr=config.LEARNING_RATE * 2)  # 2x lebih cepat
+    
+    # Tracking
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    
+    print(f"Memulai training {config.EPOCHS} epochs...")
+    start_time = time.time()
+    
+    for epoch in range(config.EPOCHS):
+        print(f"\nEpoch {epoch+1}/{config.EPOCHS}")
+        
+        # Training
+        train_loss, train_acc = train_step(
+            model=model, dataloader=train_loader, loss_fn=loss_fn,
+            optimizer=optimizer, device=config.DEVICE
+        )
+        
+        # Validation
+        val_loss, val_acc = val_step(
+            model=model, dataloader=val_loader, loss_fn=loss_fn,
+            device=config.DEVICE
+        )
+        
+        # Simpan metrics
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+        
+        # Log ke TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        
+        # Cek model terbaik
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            
+            # Simpan model terbaik
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'epoch': epoch + 1,
+                'val_accuracy': val_acc,
+                'model_name': model_name,
+                'num_classes': num_classes
+            }, model_path)
+            print(f"Model terbaik disimpan: {model_path}")
+        
+        # Progress
+        print(f"   Train: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
+        print(f"   Val:   Loss={val_loss:.4f}, Acc={val_acc:.4f}")
+        print(f"   Best:  {best_val_acc:.4f} (Epoch {best_epoch})")
+    
+    end_time = time.time()
+    training_time = end_time - start_time
+    
+    print(f"\nTraining selesai!")
+    print(f"   Waktu: {training_time:.1f} detik")
+    print(f"   Best Accuracy: {best_val_acc:.4f}")
+    
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+def main():
+    """
+    Training cepat untuk laptop.
+    """
+    print("BATIK VISION - FAST TRAINING MODE")
+    print("="*50)
+    
+    # 1. Setup training cepat
+    writer, experiment_dir, model_dir = setup_fast_training()
+    
+    # 2. Buat data loaders
+    print("\nMembuat data loaders...")
+    try:
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"Data siap! {num_classes} kelas ditemukan.")
+        print(f"   Kelas: {class_names[:5]}{'...' if len(class_names) > 5 else ''}")
+    except Exception as e:
+        print(f"ERROR data loader: {e}")
+        return
+    
+    # 3. Model mapping
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224", 
+        "convnext_tiny": "convnext_tiny"
+    }
+    
+    # 4. Training
+    all_results = []
+    
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"WARNING: Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+            
+        model_name = model_mapping[model_name_key]
+        
+        try:
+            result = train_fast_model(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir
+            )
+            
+            if result:
+                all_results.append(result)
+                
+        except Exception as e:
+            print(f"ERROR training {model_name_key}: {e}")
+            continue
+    
+    # 5. Ringkasan
+    if all_results:
+        print(f"\nRINGKASAN HASIL")
+        print("="*30)
+        
+        for result in all_results:
+            print(f"{result['model_name']:15} | "
+                  f"Best: {result['best_val_acc']:.4f} | "
+                  f"Time: {result['training_time']:.1f}s")
+        
+        best_model = max(all_results, key=lambda x: x['best_val_acc'])
+        print(f"\nModel terbaik: {best_model['model_name']} "
+              f"({best_model['best_val_acc']:.4f})")
+    
+    writer.close()
+    print(f"\nHasil disimpan di: {experiment_dir}")
+
+if __name__ == "__main__":
+    main()

train_optimized.py

@@ -0,0 +1,263 @@
+import sys
+from pathlib import Path
+# Tambahkan parent project ke sys.path sehingga 'src' dapat diimport saat menjalankan skrip langsung
+sys.path.append(str(Path(__file__).resolve().parents[1]))
+
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.tensorboard import SummaryWriter
+import time
+import os
+from datetime import datetime
+import json
+import matplotlib.pyplot as plt
+import numpy as np
+from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR
+
+# Import modul yang sudah dibuat
+from src import config
+from src.data_loader import create_dataloaders
+from src.model import create_model
+from src.engine import train_step, val_step
+from src.mixup import MixupTrainer
+
+def setup_optimized_training():
+    """
+    Setup untuk training yang dioptimalkan untuk mengatasi overfitting.
+    """
+    print("SETUP TRAINING OPTIMIZED - ANTI OVERFITTING")
+    print("="*60)
+    
+    # Override config untuk training yang lebih optimal
+    #config.BATCH_SIZE = 16  # Sedang untuk balance speed vs generalization
+    #config.EPOCHS = 30      # Cukup untuk konvergensi
+    #config.IMAGE_SIZE = 224  # Resolusi standar
+    #config.LEARNING_RATE = 1e-4  # Learning rate yang lebih konservatif
+    
+    print(f"Konfigurasi Training Optimized:")
+    print(f"   - Batch Size: {config.BATCH_SIZE}")
+    print(f"   - Epochs: {config.EPOCHS}")
+    print(f"   - Image Size: {config.IMAGE_SIZE}x{config.IMAGE_SIZE}")
+    print(f"   - Learning Rate: {config.LEARNING_RATE}")
+    print(f"   - Device: {config.DEVICE}")
+    print(f"   - Model: {config.MODEL_LIST[0] if config.MODEL_LIST else 'None'}")
+    
+    # Buat direktori untuk hasil
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+    experiment_dir = Path("outputs") / f"optimized_training_{timestamp}"
+    model_dir = experiment_dir / "models"
+    log_dir = experiment_dir / "logs"
+    
+    experiment_dir.mkdir(parents=True, exist_ok=True)
+    model_dir.mkdir(parents=True, exist_ok=True)
+    log_dir.mkdir(parents=True, exist_ok=True)
+    
+    writer = SummaryWriter(log_dir=str(log_dir))
+    
+    return writer, experiment_dir, model_dir
+
+def train_optimized_model(model_name_key: str, model_name: str, num_classes: int, 
+                         train_loader, val_loader, writer, model_dir: Path):
+    """
+    Training model dengan optimasi anti-overfitting.
+    """
+    print(f"\nTRAINING MODEL: {model_name_key.upper()}")
+    print(f"   Model: {model_name}")
+    print(f"   Classes: {num_classes}")
+    print("-" * 50)
+    
+    # Buat model dengan dropout untuk regularization
+    model = create_model(model_name, num_classes, pretrained=True, dropout_rate=0.1)
+    if model is None:
+        print(f"ERROR: Gagal membuat model {model_name}")
+        return None
+    
+    model = model.to(config.DEVICE)
+    
+    # Setup optimizer dengan weight decay untuk regularization
+    loss_fn = nn.CrossEntropyLoss(label_smoothing=0.1)  # Label smoothing untuk mengurangi overfitting
+    optimizer = optim.Adam(model.parameters(), lr=config.LEARNING_RATE, weight_decay=5e-4)
+    
+    # Setup learning rate scheduler
+    scheduler = ReduceLROnPlateau(optimizer, mode='max', factor=0.5, patience=3)
+    
+    # Setup Mixup trainer untuk data augmentation yang lebih kuat
+    mixup_trainer = MixupTrainer(model, optimizer, loss_fn, config.DEVICE, alpha=0.2)
+    
+    # Tracking variables
+    train_losses, val_losses = [], []
+    train_accs, val_accs = [], []
+    best_val_acc = 0.0
+    best_epoch = 0
+    
+    # Early stopping
+    patience = 7  # Stop jika tidak ada improvement selama 7 epoch
+    epochs_no_improve = 0
+    
+    print(f"Memulai training {config.EPOCHS} epochs...")
+    print(f"   Early Stopping: {patience} epochs patience")
+    print(f"   Learning Rate Scheduler: ReduceLROnPlateau")
+    print(f"   Weight Decay: 1e-4")
+    
+    start_time = time.time()
+    
+    for epoch in range(config.EPOCHS):
+        print(f"\nEpoch {epoch+1}/{config.EPOCHS}")
+        
+        # Training dengan Mixup
+        train_loss, train_acc = mixup_trainer.train_step(train_loader)
+        
+        # Validation
+        val_loss, val_acc = val_step(
+            model=model, dataloader=val_loader, loss_fn=loss_fn,
+            device=config.DEVICE
+        )
+        
+        # Update learning rate scheduler
+        scheduler.step(val_acc)
+        
+        # Simpan metrics
+        train_losses.append(train_loss)
+        val_losses.append(val_loss)
+        train_accs.append(train_acc)
+        val_accs.append(val_acc)
+        
+        # Log ke TensorBoard
+        writer.add_scalar(f'{model_name_key}/Train/Loss', train_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Train/Accuracy', train_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Loss', val_loss, epoch)
+        writer.add_scalar(f'{model_name_key}/Val/Accuracy', val_acc, epoch)
+        writer.add_scalar(f'{model_name_key}/Learning_Rate', optimizer.param_groups[0]['lr'], epoch)
+        
+        # Cek model terbaik
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            best_epoch = epoch + 1
+            epochs_no_improve = 0  # Reset counter
+            
+            # Simpan model terbaik
+            model_path = model_dir / f"{model_name_key}_best.pth"
+            torch.save({
+                'model_state_dict': model.state_dict(),
+                'optimizer_state_dict': optimizer.state_dict(),
+                'scheduler_state_dict': scheduler.state_dict(),
+                'epoch': epoch + 1,
+                'val_accuracy': val_acc,
+                'model_name': model_name,
+                'num_classes': num_classes
+            }, model_path)
+            print(f"Model terbaik disimpan: {model_path}")
+        else:
+            epochs_no_improve += 1
+        
+        # Progress
+        print(f"   Train: Loss={train_loss:.4f}, Acc={train_acc:.4f}")
+        print(f"   Val:   Loss={val_loss:.4f}, Acc={val_acc:.4f}")
+        print(f"   Best:  {best_val_acc:.4f} (Epoch {best_epoch})")
+        print(f"   LR:    {optimizer.param_groups[0]['lr']:.2e}")
+        print(f"   No Improve: {epochs_no_improve}/{patience}")
+        
+        # Early stopping check
+        if epochs_no_improve >= patience:
+            print(f"\nEarly stopping! Tidak ada kemajuan selama {patience} epoch.")
+            print(f"Model terbaik: Epoch {best_epoch} dengan Val Acc: {best_val_acc:.4f}")
+            break
+    
+    end_time = time.time()
+    training_time = end_time - start_time
+    
+    print(f"\nTraining selesai!")
+    print(f"   Waktu: {training_time:.1f} detik")
+    print(f"   Best Accuracy: {best_val_acc:.4f}")
+    print(f"   Epochs trained: {epoch + 1}")
+    
+    return {
+        'model_name': model_name_key,
+        'best_val_acc': best_val_acc,
+        'best_epoch': best_epoch,
+        'final_val_acc': val_acc,
+        'training_time': training_time,
+        'epochs_trained': epoch + 1,
+        'train_losses': train_losses,
+        'val_losses': val_losses,
+        'train_accs': train_accs,
+        'val_accs': val_accs
+    }
+
+def main():
+    """
+    Training optimized untuk mengatasi overfitting.
+    """
+    print("BATIK VISION - OPTIMIZED TRAINING MODE")
+    print("="*60)
+    
+    # 1. Setup training optimized
+    writer, experiment_dir, model_dir = setup_optimized_training()
+    
+    # 2. Buat data loaders
+    print("\nMembuat data loaders...")
+    try:
+        train_loader, val_loader, class_names = create_dataloaders()
+        num_classes = len(class_names)
+        print(f"Data siap! {num_classes} kelas ditemukan.")
+        print(f"   Kelas: {class_names[:5]}{'...' if len(class_names) > 5 else ''}")
+    except Exception as e:
+        print(f"ERROR data loader: {e}")
+        return
+    
+    # 3. Model mapping
+    model_mapping = {
+        "vit": "vit_base_patch16_224",
+        "swin_transformer": "swin_base_patch4_window7_224", 
+        "convnext_tiny": "convnext_tiny"
+    }
+    
+    # 4. Training
+    all_results = []
+    
+    for model_name_key in config.MODEL_LIST:
+        if model_name_key not in model_mapping:
+            print(f"WARNING: Model '{model_name_key}' tidak dikenali. Dilewati.")
+            continue
+            
+        model_name = model_mapping[model_name_key]
+        
+        try:
+            result = train_optimized_model(
+                model_name_key=model_name_key,
+                model_name=model_name,
+                num_classes=num_classes,
+                train_loader=train_loader,
+                val_loader=val_loader,
+                writer=writer,
+                model_dir=model_dir
+            )
+            
+            if result:
+                all_results.append(result)
+                
+        except Exception as e:
+            print(f"ERROR training {model_name_key}: {e}")
+            continue
+    
+    # 5. Ringkasan
+    if all_results:
+        print(f"\nRINGKASAN HASIL")
+        print("="*40)
+        
+        for result in all_results:
+            print(f"{result['model_name']:15} | "
+                  f"Best: {result['best_val_acc']:.4f} | "
+                  f"Epochs: {result['epochs_trained']} | "
+                  f"Time: {result['training_time']:.1f}s")
+        
+        best_model = max(all_results, key=lambda x: x['best_val_acc'])
+        print(f"\nModel terbaik: {best_model['model_name']} "
+              f"({best_model['best_val_acc']:.4f})")
+    
+    writer.close()
+    print(f"\nHasil disimpan di: {experiment_dir}")
+
+if __name__ == "__main__":
+    main()