Upload 4 files

art_trainer-mixup.py

@@ -0,0 +1,234 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import DataLoader, Dataset
+from torchvision import transforms as T
+from torchvision.transforms import v2
+from PIL import Image
+from pathlib import Path
+from tqdm.auto import tqdm
+import random
+import numpy as np
+
+# A.1. Check device availability and setup MPS optimizations
+device = torch.device("mps" if torch.backends.mps.is_available() else "cpu")
+torch.set_float32_matmul_precision('high')  # MPS performance optimization
+
+# Hyperparameters (Tested optimal values)
+CFG = {
+    'img_size': 224,
+    'batch_size': 32,
+    'lr': 3e-5,            # Lower learning rate
+    'weight_decay': 0.05,  # Stronger L2 regularization
+    'dropout': 0.5,        # Increased dropout
+    'epochs': 30,
+    'mixup_alpha': 0.4,
+    'cutmix_prob': 0.3,
+    'label_smoothing': 0.15,
+    'patience': 5          # For early stopping
+}
+
+# A.2.4. Define data transformations with advanced augmentation pipeline
+def create_transforms():
+    return {
+        'train': v2.Compose([
+            # A word on presizing:
+            # 1. Increase the size (item by item)
+            v2.RandomResizedCrop(CFG['img_size'], scale=(0.6, 1.0)),
+            # 2. Apply augmentation (batch by batch)
+            v2.RandomHorizontalFlip(p=0.7),
+            v2.RandomVerticalFlip(p=0.3),
+            v2.ColorJitter(brightness=0.4, contrast=0.4, saturation=0.3),
+            v2.RandomRotation(35),
+            v2.RandomAffine(degrees=0, translate=(0.2, 0.2)),
+            v2.RandomPerspective(distortion_scale=0.4, p=0.6),
+            v2.GaussianBlur(kernel_size=(5, 9)),
+            v2.RandomSolarize(threshold=0.3, p=0.2),
+            v2.ToTensor(),
+            # 3. Decrease the size (batch by batch)
+            v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]),
+            v2.RandomErasing(p=0.5, scale=(0.02, 0.2), value='random')
+        ]),
+        'val': v2.Compose([
+            v2.Resize(CFG['img_size'] + 32),
+            v2.CenterCrop(CFG['img_size']),
+            v2.ToTensor(),
+            v2.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    }
+
+# A.2.2. Define the means of getting data into DataBlock
+class ArtDataset(Dataset):
+    def __init__(self, data_dir, transform=None):
+        self.classes = sorted([d.name for d in Path(data_dir).iterdir() if d.is_dir()])
+        self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+        self.samples = []
+        for cls in self.classes:
+            cls_dir = Path(data_dir) / cls
+            for img_path in cls_dir.glob('*'):
+                self.samples.append((img_path, self.class_to_idx[cls]))
+        self.transform = transform
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, label = self.samples[idx]
+        img = Image.open(img_path).convert('RGB')
+        if self.transform:
+            img = self.transform(img)
+        return img, label
+
+# B.4. Implement mixup data augmentation - part of discriminative learning rates
+def mixup_data(x, y, alpha=1.0):
+    if alpha > 0:
+        lam = np.random.beta(alpha, alpha)
+    else:
+        lam = 1
+    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
+
+# A.4. Define training step
+def train_step(model, data_loader, criterion, optimizer):
+    model.train()
+    total_loss = 0
+    correct = 0
+    
+    for inputs, targets in tqdm(data_loader, desc='Training', leave=False):
+        inputs, targets = inputs.to(device), targets.to(device)
+        
+        # B.4. Advanced Mixup - part of discriminative learning rates
+        inputs, targets_a, targets_b, lam = mixup_data(inputs, targets, CFG['mixup_alpha'])
+        
+        optimizer.zero_grad()
+        outputs = model(inputs)
+        loss = criterion(outputs, targets_a) * lam + criterion(outputs, targets_b) * (1 - lam)
+        
+        loss.backward()
+        nn.utils.clip_grad_norm_(model.parameters(), 1.0)  # Gradient clipping
+        optimizer.step()
+        
+        total_loss += loss.item()
+        _, predicted = outputs.max(1)
+        correct += (lam * predicted.eq(targets_a).sum().item() + 
+                   (1 - lam) * predicted.eq(targets_b).sum().item())
+    
+    acc = 100. * correct / len(data_loader.dataset)
+    avg_loss = total_loss / len(data_loader)
+    return avg_loss, acc
+
+# A.3. Define validation step to inspect the DataBlock
+def validate(model, data_loader, criterion):
+    model.eval()
+    total_loss = 0
+    correct = 0
+    
+    with torch.no_grad():
+        for inputs, targets in tqdm(data_loader, desc='Validation', leave=False):
+            inputs, targets = inputs.to(device), targets.to(device)
+            outputs = model(inputs)
+            loss = criterion(outputs, targets)
+            
+            total_loss += loss.item()
+            _, predicted = outputs.max(1)
+            correct += predicted.eq(targets).sum().item()
+    
+    acc = 100. * correct / len(data_loader.dataset)
+    avg_loss = total_loss / len(data_loader)
+    return avg_loss, acc
+
+def main():
+    # A.1. Load data
+    transforms = create_transforms()
+    
+    # Set directory paths according to your structure
+    art_dataset_dir = 'Art Dataset'
+    
+    # A.2.1. Define the blocks (dataset creation)
+    train_dataset = ArtDataset(art_dataset_dir, transform=transforms['train'])
+    val_dataset = ArtDataset(art_dataset_dir, transform=transforms['val'])
+    
+    # A.2.2. Create data loaders
+    train_loader = DataLoader(train_dataset, batch_size=CFG['batch_size'], 
+                            shuffle=True, num_workers=4, pin_memory=True)
+    val_loader = DataLoader(val_dataset, batch_size=CFG['batch_size'], 
+                          num_workers=4, pin_memory=True)
+    
+    # B.3. Transfer Learning - Load model
+    model_path = 'models/model_final.pth'
+    
+    # Load model state dictionary
+    state_dict = torch.load(model_path)
+    
+    # Create ResNet34 model
+    from torchvision import models
+    model = models.resnet34(weights=None)
+    
+    # Number of classes
+    num_classes = len(train_dataset.classes)
+    
+    # B.3. Update the final fully-connected layer
+    model.fc = nn.Linear(512, num_classes)
+    
+    # Load state dictionary
+    model.load_state_dict(state_dict)
+    model = model.to(device)
+    
+    # B.6. Model Capacity - Measures to prevent overfitting
+    for name, module in model.named_modules():
+        if isinstance(module, nn.Dropout):
+            module.p = CFG['dropout']  # Increase dropout rate
+    
+    # B.1. Learning Rate Finder - Optimizer and Loss setup
+    optimizer = optim.AdamW(model.parameters(), lr=CFG['lr'], 
+                          weight_decay=CFG['weight_decay'])
+    criterion = nn.CrossEntropyLoss(label_smoothing=CFG['label_smoothing'])
+    scheduler = optim.lr_scheduler.CosineAnnealingWarmRestarts(optimizer, 
+                                                             T_0=10, T_mult=2)
+    
+    # Create results directory
+    results_dir = 'results'
+    os.makedirs(results_dir, exist_ok=True)
+    
+    # B.5. Early Stopping - Deciding the Number of Training Epochs
+    best_val_acc = 0
+    patience_counter = 0
+    
+    # A.4. Train a simple model
+    for epoch in range(CFG['epochs']):
+        print(f"\nEpoch {epoch+1}/{CFG['epochs']}")
+        
+        # Training
+        train_loss, train_acc = train_step(model, train_loader, criterion, optimizer)
+        # Validation
+        val_loss, val_acc = validate(model, val_loader, criterion)
+        
+        # Learning rate update
+        scheduler.step()
+        
+        # Monitor results
+        print(f"Train Loss: {train_loss:.4f} | Acc: {train_acc:.2f}%")
+        print(f"Val Loss: {val_loss:.4f} | Acc: {val_acc:.2f}%")
+        
+        # B.5. Early stopping check
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            patience_counter = 0
+            best_model_path = os.path.join(results_dir, 'best_model.pth')
+            torch.save(model.state_dict(), best_model_path)
+            print(f"New best model saved ({val_acc:.2f}%)")
+        else:
+            patience_counter += 1
+            if patience_counter >= CFG['patience']:
+                print(f"Early stopping! No improvement for {CFG['patience']} epochs.")
+                break
+
+if __name__ == "__main__":
+    main() 

model_evaluator.py

@@ -0,0 +1,325 @@
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, random_split
+from torchvision import models, transforms
+from pathlib import Path
+from PIL import Image
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report
+from tqdm import tqdm
+import pandas as pd
+import random
+from collections import defaultdict
+
+# MPS (Metal Performance Shaders) check - Apple GPU
+if torch.backends.mps.is_available():
+    DEVICE = torch.device("mps")
+    print(f"Using Metal GPU: {DEVICE}")
+else:
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Metal GPU not found, using device: {DEVICE}")
+
+# Constants
+IMG_SIZE = 224
+BATCH_SIZE = 64  # Batch size increased for GPU
+NUM_WORKERS = 6  # Number of threads increased
+MAX_SAMPLES_PER_CLASS = 30  # Maximum number of samples per class (for quick testing)
+
+# Transformation for test dataset
+test_transform = transforms.Compose([
+    transforms.Resize(IMG_SIZE + 32),
+    transforms.CenterCrop(IMG_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+class ArtDataset(Dataset):
+    def __init__(self, samples, transform=None, class_to_idx=None):
+        self.samples = samples
+        self.transform = transform
+        
+        if class_to_idx is None:
+            # Extract classes from samples
+            classes = set([Path(str(s[0])).parent.name for s in samples])
+            self.classes = sorted(list(classes))
+            self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+        else:
+            self.class_to_idx = class_to_idx
+            self.classes = sorted(class_to_idx.keys(), key=lambda x: class_to_idx[x])
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, class_name = self.samples[idx]
+        label = self.class_to_idx[class_name]
+        img = Image.open(img_path).convert('RGB')
+        if self.transform:
+            img = self.transform(img)
+        return img, label
+
+def create_test_set(data_dir, test_ratio=0.2, max_per_class=None):
+    """Create test set by taking a certain percentage of samples from each class"""
+    class_samples = defaultdict(list)
+    
+    # Collect all examples by their classes
+    for class_dir in Path(data_dir).iterdir():
+        if class_dir.is_dir():
+            class_name = class_dir.name
+            for img_path in class_dir.glob('*'):
+                class_samples[class_name].append((img_path, class_name))
+    
+    # Select a certain percentage and maximum number of examples from each class
+    test_samples = []
+    for class_name, samples in class_samples.items():
+        random.shuffle(samples)
+        n_test = max(1, int(len(samples) * test_ratio))
+        
+        # Limit the maximum number of examples
+        if max_per_class and n_test > max_per_class:
+            n_test = max_per_class
+            
+        test_samples.extend(samples[:n_test])
+    
+    print(f"Total of {len(test_samples)} test samples selected from {len(class_samples)} different art movements.")
+    
+    # Create class-index mapping
+    classes = sorted(class_samples.keys())
+    class_to_idx = {cls: i for i, cls in enumerate(classes)}
+    
+    return test_samples, class_to_idx
+
+def load_model(model_path, num_classes):
+    """Load model file"""
+    print(f"Loading model: {model_path}")
+    # Create ResNet34 model
+    model = models.resnet34(weights=None)
+    # Update the last fully-connected layer
+    model.fc = nn.Linear(512, num_classes)
+    
+    # Special loading for Metal GPU availability check
+    state_dict = torch.load(model_path, map_location=DEVICE)
+    model.load_state_dict(state_dict)
+    model = model.to(DEVICE)
+    model.eval()
+    
+    return model
+
+def evaluate_model(model, test_loader, classes):
+    """Evaluate model and return metrics"""
+    all_preds = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for inputs, labels in tqdm(test_loader, desc="Evaluation"):
+            inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
+            
+            # Run directly on MPS device (without using autocast)
+            outputs = model(inputs)
+            
+            _, preds = torch.max(outputs, 1)
+            
+            # Move results to CPU
+            all_preds.extend(preds.cpu().numpy())
+            all_labels.extend(labels.cpu().numpy())
+    
+    # Calculate metrics
+    accuracy = accuracy_score(all_labels, all_preds)
+    f1 = f1_score(all_labels, all_preds, average='weighted')
+    precision = precision_score(all_labels, all_preds, average='weighted')
+    recall = recall_score(all_labels, all_preds, average='weighted')
+    
+    # Class-based accuracy
+    class_accuracy = {}
+    conf_matrix = confusion_matrix(all_labels, all_preds)
+    
+    for i, class_name in enumerate(classes):
+        class_samples = np.sum(np.array(all_labels) == i)
+        class_correct = conf_matrix[i, i]
+        if class_samples > 0:
+            class_accuracy[class_name] = class_correct / class_samples
+    
+    results = {
+        'accuracy': accuracy,
+        'f1_score': f1,
+        'precision': precision,
+        'recall': recall,
+        'class_accuracy': class_accuracy,
+        'confusion_matrix': conf_matrix,
+        'predictions': all_preds,
+        'ground_truth': all_labels
+    }
+    
+    return results
+
+def plot_confusion_matrix(conf_matrix, classes, model_name, save_dir):
+    """Plot confusion matrix graph"""
+    plt.figure(figsize=(12, 10))
+    sns.heatmap(conf_matrix, annot=False, fmt='d', cmap='Blues',
+                xticklabels=classes, yticklabels=classes)
+    plt.xlabel('Predicted Class')
+    plt.ylabel('True Class')
+    plt.title(f'Confusion Matrix - {model_name}')
+    plt.tight_layout()
+    
+    # Save the graph
+    save_path = Path(save_dir) / f"conf_matrix_{Path(model_name).stem}.png"
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+def plot_class_accuracy(class_acc, model_name, save_dir):
+    """Plot class-based accuracy graph"""
+    plt.figure(figsize=(14, 8))
+    
+    # Sort classes by accuracy value
+    sorted_items = sorted(class_acc.items(), key=lambda x: x[1], reverse=True)
+    classes = [item[0] for item in sorted_items]
+    accuracies = [item[1] for item in sorted_items]
+    
+    bars = plt.bar(classes, accuracies)
+    plt.xlabel('Art Movement')
+    plt.ylabel('Accuracy')
+    plt.title(f'Class-Based Accuracy - {model_name}')
+    plt.xticks(rotation=90)
+    plt.ylim(0, 1.0)
+    
+    # Add values on top of bars
+    for bar in bars:
+        height = bar.get_height()
+        plt.text(bar.get_x() + bar.get_width()/2., height,
+                f'{height:.2f}', ha='center', va='bottom', rotation=0)
+    
+    plt.tight_layout()
+    
+    # Save the graph
+    save_path = Path(save_dir) / f"class_accuracy_{Path(model_name).stem}.png"
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+def plot_model_comparison(all_results, save_dir):
+    """Plot model comparison graph"""
+    model_names = list(all_results.keys())
+    metrics = ['accuracy', 'f1_score', 'precision', 'recall']
+    
+    # Collect metrics
+    metric_data = {metric: [all_results[model][metric] for model in model_names] for metric in metrics}
+    
+    # Compare metrics
+    plt.figure(figsize=(12, 7))
+    x = np.arange(len(model_names))
+    width = 0.2
+    multiplier = 0
+    
+    for metric, values in metric_data.items():
+        offset = width * multiplier
+        bars = plt.bar(x + offset, values, width, label=metric)
+        
+        # Add values on top of bars
+        for bar in bars:
+            height = bar.get_height()
+            plt.annotate(f'{height:.3f}',
+                        xy=(bar.get_x() + bar.get_width() / 2, height),
+                        xytext=(0, 3),  # 3 points vertical offset
+                        textcoords="offset points",
+                        ha='center', va='bottom')
+        
+        multiplier += 1
+    
+    plt.xlabel('Model')
+    plt.ylabel('Score')
+    plt.title('Model Performance Comparison')
+    plt.xticks(x + width, model_names)
+    plt.legend(loc='lower right')
+    plt.ylim(0, 1.0)
+    
+    plt.tight_layout()
+    
+    # Save the graph
+    save_path = Path(save_dir) / "model_comparison.png"
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+def main():
+    # Data directory and results directory
+    art_dataset_dir = 'Art Dataset'
+    models_dir = 'models'
+    results_dir = 'evaluation_results'
+    
+    # Create results directory
+    os.makedirs(results_dir, exist_ok=True)
+    
+    # Create test data - limit maximum number of examples from each class
+    test_samples, class_to_idx = create_test_set(art_dataset_dir, test_ratio=0.2, max_per_class=MAX_SAMPLES_PER_CLASS)
+    test_dataset = ArtDataset(test_samples, transform=test_transform, class_to_idx=class_to_idx)
+    test_loader = DataLoader(test_dataset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=True)
+    
+    classes = test_dataset.classes
+    num_classes = len(classes)
+    print(f"Art classes: {len(classes)}")
+    
+    # Find model files (exclude files like .DS_Store)
+    model_paths = [os.path.join(models_dir, f) for f in os.listdir(models_dir) 
+                 if f.endswith('.pth') and not f.startswith('.')]
+    
+    # Dictionary to store results
+    all_results = {}
+    
+    # Evaluate each model
+    for model_path in model_paths:
+        model_name = Path(model_path).name
+        print(f"\nEvaluating {model_name}...")
+        
+        # Load model
+        model = load_model(model_path, num_classes)
+        
+        # Evaluate model
+        results = evaluate_model(model, test_loader, classes)
+        all_results[model_name] = results
+        
+        print(f"Accuracy: {results['accuracy']:.4f}")
+        print(f"F1 Score: {results['f1_score']:.4f}")
+        print(f"Precision: {results['precision']:.4f}")
+        print(f"Recall: {results['recall']:.4f}")
+        
+        # Plot confusion matrix graph
+        plot_confusion_matrix(results['confusion_matrix'], classes, model_name, results_dir)
+        
+        # Plot class-based accuracy graph
+        plot_class_accuracy(results['class_accuracy'], model_name, results_dir)
+        
+        # Save detailed class report
+        report = classification_report(results['ground_truth'], results['predictions'], 
+                                     target_names=classes, output_dict=True)
+        report_df = pd.DataFrame(report).transpose()
+        report_df.to_csv(f"{results_dir}/classification_report_{Path(model_name).stem}.csv")
+    
+    # Compare models
+    if len(all_results) > 1:
+        plot_model_comparison(all_results, results_dir)
+    
+    # Save results to CSV file
+    results_summary = []
+    for model_name, results in all_results.items():
+        row = {
+            'model': model_name,
+            'accuracy': results['accuracy'],
+            'f1_score': results['f1_score'],
+            'precision': results['precision'],
+            'recall': results['recall']
+        }
+        results_summary.append(row)
+    
+    summary_df = pd.DataFrame(results_summary)
+    summary_df.to_csv(f"{results_dir}/model_comparison_summary.csv", index=False)
+    
+    print(f"\nEvaluation completed. Results are in '{results_dir}' directory.")
+
+if __name__ == "__main__":
+    # Set seed for reproducibility
+    random.seed(42)
+    np.random.seed(42)
+    torch.manual_seed(42)
+    main()

model_evaluator_kfold.py

@@ -0,0 +1,379 @@
+import os
+import numpy as np
+import torch
+import torch.nn as nn
+from torch.utils.data import Dataset, DataLoader, Subset
+from torchvision import models, transforms
+from pathlib import Path
+from PIL import Image
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score, confusion_matrix, classification_report
+from sklearn.model_selection import KFold
+from tqdm import tqdm
+import pandas as pd
+import random
+from collections import defaultdict
+
+# MPS (Metal Performance Shaders) kontrolü - Apple GPU
+if torch.backends.mps.is_available():
+    DEVICE = torch.device("mps")
+    print(f"Metal GPU kullanılıyor: {DEVICE}")
+else:
+    DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    print(f"Metal GPU bulunamadı, şu cihaz kullanılıyor: {DEVICE}")
+
+# Sabit değerler
+IMG_SIZE = 224
+BATCH_SIZE = 64
+NUM_WORKERS = 6
+MAX_SAMPLES_PER_CLASS = 20  # Her sınıftan maksimum örnek sayısı (hızlı test için)
+K_FOLDS = 5  # 5-fold cross validation
+
+# Test veri seti için dönüşüm
+test_transform = transforms.Compose([
+    transforms.Resize(IMG_SIZE + 32),
+    transforms.CenterCrop(IMG_SIZE),
+    transforms.ToTensor(),
+    transforms.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+])
+
+class ArtDataset(Dataset):
+    def __init__(self, samples, transform=None, class_to_idx=None):
+        self.samples = samples
+        self.transform = transform
+        
+        if class_to_idx is None:
+            # Sınıfları örneklerden çıkar
+            classes = set([Path(str(s[0])).parent.name for s in samples])
+            self.classes = sorted(list(classes))
+            self.class_to_idx = {cls: i for i, cls in enumerate(self.classes)}
+        else:
+            self.class_to_idx = class_to_idx
+            self.classes = sorted(class_to_idx.keys(), key=lambda x: class_to_idx[x])
+
+    def __len__(self):
+        return len(self.samples)
+
+    def __getitem__(self, idx):
+        img_path, class_name = self.samples[idx]
+        label = self.class_to_idx[class_name]
+        img = Image.open(img_path).convert('RGB')
+        if self.transform:
+            img = self.transform(img)
+        return img, label
+
+def create_balanced_dataset(data_dir, max_per_class=None):
+    """Her sınıftan eşit sayıda örnek içeren dengeli bir veri seti oluştur"""
+    class_samples = defaultdict(list)
+    
+    # Tüm örnekleri sınıflarına göre topla
+    for class_dir in Path(data_dir).iterdir():
+        if class_dir.is_dir():
+            class_name = class_dir.name
+            for img_path in class_dir.glob('*'):
+                class_samples[class_name].append((img_path, class_name))
+    
+    # Her sınıftan maksimum sayıda örnek seç
+    balanced_samples = []
+    for class_name, samples in class_samples.items():
+        random.shuffle(samples)
+        
+        # Maksimum örnek sayısını sınırla
+        if max_per_class and len(samples) > max_per_class:
+            samples = samples[:max_per_class]
+            
+        balanced_samples.extend(samples)
+    
+    print(f"Toplam {len(balanced_samples)} örnek, {len(class_samples)} farklı sanat akımından seçildi.")
+    
+    # Sınıf-indeks eşleştirmesini oluştur
+    classes = sorted(class_samples.keys())
+    class_to_idx = {cls: i for i, cls in enumerate(classes)}
+    
+    return balanced_samples, class_to_idx
+
+def load_model(model_path, num_classes):
+    """Model dosyasını yükle"""
+    print(f"Model yükleniyor: {model_path}")
+    # ResNet34 modelini oluştur
+    model = models.resnet34(weights=None)
+    # Son fully-connected katmanını güncelle
+    model.fc = nn.Linear(512, num_classes)
+    
+    # Metal GPU kullanılabilirliği kontrolü için özel yükleme
+    state_dict = torch.load(model_path, map_location=DEVICE)
+    model.load_state_dict(state_dict)
+    model = model.to(DEVICE)
+    model.eval()
+    
+    return model
+
+def evaluate_model(model, test_loader, classes):
+    """Modeli değerlendir ve metrikleri döndür"""
+    all_preds = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for inputs, labels in tqdm(test_loader, desc="Değerlendirme", leave=False):
+            inputs, labels = inputs.to(DEVICE), labels.to(DEVICE)
+            
+            # MPS cihazında çalıştır
+            outputs = model(inputs)
+            
+            _, preds = torch.max(outputs, 1)
+            
+            # Sonuçları CPU'ya taşı
+            all_preds.extend(preds.cpu().numpy())
+            all_labels.extend(labels.cpu().numpy())
+    
+    # Temel metrikleri hesapla - uyarıları engellemek için zero_division=1 parametresi eklendi
+    accuracy = accuracy_score(all_labels, all_preds)
+    f1 = f1_score(all_labels, all_preds, average='weighted', zero_division=1)
+    precision = precision_score(all_labels, all_preds, average='weighted', zero_division=1)
+    recall = recall_score(all_labels, all_preds, average='weighted', zero_division=1)
+    
+    # Sınıf bazında doğruluk
+    class_accuracy = {}
+    conf_matrix = confusion_matrix(all_labels, all_preds)
+    
+    for i, class_name in enumerate(classes):
+        class_samples = np.sum(np.array(all_labels) == i)
+        class_correct = conf_matrix[i, i] if i < len(conf_matrix) else 0
+        if class_samples > 0:
+            class_accuracy[class_name] = class_correct / class_samples
+    
+    results = {
+        'accuracy': accuracy,
+        'f1_score': f1,
+        'precision': precision,
+        'recall': recall,
+        'class_accuracy': class_accuracy,
+        'confusion_matrix': conf_matrix,
+        'predictions': all_preds,
+        'ground_truth': all_labels
+    }
+    
+    return results
+
+def k_fold_cross_validation(dataset, model_paths, num_classes, k=5):
+    """K-fold cross validation ile modelleri değerlendir"""
+    
+    # K-fold nesnesi oluştur
+    kfold = KFold(n_splits=k, shuffle=True, random_state=42)
+    
+    # Her model için sonuçları sakla
+    all_model_results = {}
+    for model_path in model_paths:
+        model_name = Path(model_path).name
+        all_model_results[model_name] = {
+            'fold_results': [],
+            'accuracy': [],
+            'f1_score': [],
+            'precision': [],
+            'recall': []
+        }
+    
+    # K-fold cross validation
+    for fold, (_, test_indices) in enumerate(kfold.split(dataset)):
+        print(f"\nFold {fold+1}/{k} değerlendiriliyor...")
+        
+        # Test veri setini oluştur
+        test_subset = Subset(dataset, test_indices)
+        test_loader = DataLoader(test_subset, batch_size=BATCH_SIZE, num_workers=NUM_WORKERS, pin_memory=True)
+        
+        # Her model için değerlendirme yap
+        for model_path in model_paths:
+            model_name = Path(model_path).name
+            print(f"  {model_name} değerlendiriliyor...")
+            
+            # Modeli yükle
+            model = load_model(model_path, num_classes)
+            
+            # Modeli değerlendir
+            results = evaluate_model(model, test_loader, dataset.classes)
+            
+            # Sonuçları kaydet
+            all_model_results[model_name]['fold_results'].append(results)
+            all_model_results[model_name]['accuracy'].append(results['accuracy'])
+            all_model_results[model_name]['f1_score'].append(results['f1_score'])
+            all_model_results[model_name]['precision'].append(results['precision'])
+            all_model_results[model_name]['recall'].append(results['recall'])
+            
+            print(f"    Fold {fold+1} - Doğruluk: {results['accuracy']:.4f}, F1: {results['f1_score']:.4f}")
+    
+    # Her model için ortalama sonuçları hesapla
+    summary_results = {}
+    for model_name, results in all_model_results.items():
+        summary_results[model_name] = {
+            'mean_accuracy': np.mean(results['accuracy']),
+            'std_accuracy': np.std(results['accuracy']),
+            'mean_f1': np.mean(results['f1_score']),
+            'std_f1': np.std(results['f1_score']),
+            'mean_precision': np.mean(results['precision']),
+            'std_precision': np.std(results['precision']),
+            'mean_recall': np.mean(results['recall']),
+            'std_recall': np.std(results['recall']),
+            'fold_accuracy': results['accuracy'],
+            'fold_f1': results['f1_score']
+        }
+    
+    return summary_results
+
+def plot_kfold_results(summary_results, save_dir):
+    """K-fold cross validation sonuçlarını gösteren grafikler oluştur"""
+    
+    # Accuracy ve F1 için ortalama değerleri çiz
+    plt.figure(figsize=(14, 7))
+    
+    # Model isimlerini ve ortalama değerleri çıkart
+    model_names = list(summary_results.keys())
+    model_names = [Path(name).stem for name in model_names]  # .pth uzantısını kaldır
+    
+    # Doğruluk ve F1 skorları
+    mean_accuracy = [summary_results[model]['mean_accuracy'] for model in summary_results]
+    std_accuracy = [summary_results[model]['std_accuracy'] for model in summary_results]
+    mean_f1 = [summary_results[model]['mean_f1'] for model in summary_results]
+    std_f1 = [summary_results[model]['std_f1'] for model in summary_results]
+    
+    # X ekseni konumları
+    x = np.arange(len(model_names))
+    width = 0.35
+    
+    # Çubuk grafikleri
+    fig, ax = plt.subplots(figsize=(12, 8))
+    rects1 = ax.bar(x - width/2, mean_accuracy, width, yerr=std_accuracy, 
+                    label='Accuracy', capsize=5, color='cornflowerblue')
+    rects2 = ax.bar(x + width/2, mean_f1, width, yerr=std_f1, 
+                    label='F1 Score', capsize=5, color='lightcoral')
+    
+    # Grafik özellikleri
+    ax.set_ylabel('Skor')
+    ax.set_title('5-Fold Cross Validation Ortalama Performans (Ortalama ± Std)')
+    ax.set_xticks(x)
+    ax.set_xticklabels(model_names)
+    ax.legend()
+    ax.set_ylim(0, 1.0)
+    
+    # Çubukların üstüne değerleri ekle
+    def add_labels(rects):
+        for rect in rects:
+            height = rect.get_height()
+            ax.annotate(f'{height:.3f}',
+                        xy=(rect.get_x() + rect.get_width() / 2, height),
+                        xytext=(0, 3),  # 3 points vertical offset
+                        textcoords="offset points",
+                        ha='center', va='bottom')
+    
+    add_labels(rects1)
+    add_labels(rects2)
+    
+    plt.tight_layout()
+    
+    # Grafiği kaydet
+    save_path = Path(save_dir) / "kfold_mean_performance.png"
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+    
+    # Her bir fold için performansı çiz
+    plt.figure(figsize=(18, 12))
+    
+    # Accuracy için
+    plt.subplot(2, 1, 1)
+    for model_name in summary_results:
+        model_stem = Path(model_name).stem
+        plt.plot(range(1, K_FOLDS + 1), summary_results[model_name]['fold_accuracy'], 
+                 marker='o', linestyle='-', label=model_stem)
+    
+    plt.title('Her Fold için Accuracy Değerleri')
+    plt.xlabel('Fold')
+    plt.ylabel('Accuracy')
+    plt.xticks(range(1, K_FOLDS + 1))
+    plt.ylim(0, 1.0)
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.legend()
+    
+    # F1 Skor için
+    plt.subplot(2, 1, 2)
+    for model_name in summary_results:
+        model_stem = Path(model_name).stem
+        plt.plot(range(1, K_FOLDS + 1), summary_results[model_name]['fold_f1'], 
+                 marker='o', linestyle='-', label=model_stem)
+    
+    plt.title('Her Fold için F1 Değerleri')
+    plt.xlabel('Fold')
+    plt.ylabel('F1 Score')
+    plt.xticks(range(1, K_FOLDS + 1))
+    plt.ylim(0, 1.0)
+    plt.grid(True, linestyle='--', alpha=0.7)
+    plt.legend()
+    
+    plt.tight_layout()
+    
+    # Grafiği kaydet
+    save_path = Path(save_dir) / "kfold_all_folds_performance.png"
+    plt.savefig(save_path, dpi=300)
+    plt.close()
+
+def main():
+    # Veri dizini ve sonuç dizini
+    art_dataset_dir = 'Art Dataset'
+    models_dir = 'models'
+    results_dir = 'kfold_evaluation_results'
+    
+    # Sonuç dizinini oluştur
+    os.makedirs(results_dir, exist_ok=True)
+    
+    # Dengeli veri setini oluştur - her sınıftan maksimum örnek sayısını sınırla
+    samples, class_to_idx = create_balanced_dataset(art_dataset_dir, max_per_class=MAX_SAMPLES_PER_CLASS)
+    dataset = ArtDataset(samples, transform=test_transform, class_to_idx=class_to_idx)
+    
+    num_classes = len(dataset.classes)
+    print(f"Sanat sınıfları: {len(dataset.classes)}")
+    
+    # Model dosyalarını bul (.DS_Store gibi dosyaları hariç tut)
+    model_paths = [os.path.join(models_dir, f) for f in os.listdir(models_dir) 
+                 if f.endswith('.pth') and not f.startswith('.')]
+    
+    # K-fold cross validation ile modelleri değerlendir
+    summary_results = k_fold_cross_validation(dataset, model_paths, num_classes, k=K_FOLDS)
+    
+    # Sonuçları görselleştir
+    plot_kfold_results(summary_results, results_dir)
+    
+    # Sonuçları yazdır
+    print("\n5-Fold Cross Validation Sonuçları:")
+    for model_name, results in summary_results.items():
+        print(f"\n{model_name}:")
+        print(f"  Ortalama Accuracy: {results['mean_accuracy']:.4f} ± {results['std_accuracy']:.4f}")
+        print(f"  Ortalama F1 Score: {results['mean_f1']:.4f} ± {results['std_f1']:.4f}")
+        print(f"  Ortalama Precision: {results['mean_precision']:.4f} ± {results['std_precision']:.4f}")
+        print(f"  Ortalama Recall: {results['mean_recall']:.4f} ± {results['std_recall']:.4f}")
+    
+    # Sonuçları CSV dosyasına kaydet
+    results_summary = []
+    for model_name, results in summary_results.items():
+        row = {
+            'model': model_name,
+            'mean_accuracy': results['mean_accuracy'],
+            'std_accuracy': results['std_accuracy'],
+            'mean_f1': results['mean_f1'],
+            'std_f1': results['std_f1'],
+            'mean_precision': results['mean_precision'],
+            'std_precision': results['std_precision'],
+            'mean_recall': results['mean_recall'],
+            'std_recall': results['std_recall']
+        }
+        results_summary.append(row)
+    
+    summary_df = pd.DataFrame(results_summary)
+    summary_df.to_csv(f"{results_dir}/kfold_model_comparison_summary.csv", index=False)
+    
+    print(f"\nDeğerlendirme tamamlandı. Sonuçlar '{results_dir}' dizininde.")
+
+if __name__ == "__main__":
+    # Tekrar üretilebilirlik için seed ayarla
+    random.seed(42)
+    np.random.seed(42)
+    torch.manual_seed(42)
+    main() 

trainer.py

@@ -0,0 +1,556 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+
+import os
+import random
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import time
+from tqdm.auto import tqdm
+from pathlib import Path
+from collections import Counter
+from PIL import Image
+
+import torch
+import torch.nn as nn
+from torch.utils.data import DataLoader, Dataset
+import torchvision
+import torchvision.transforms as T
+from torchvision.datasets import ImageFolder
+from torchvision.models import resnet34, ResNet34_Weights
+
+# A.1. Enable CPU fallback for MPS device
+os.environ["PYTORCH_ENABLE_MPS_FALLBACK"] = "1"
+
+# Enable MPS optimizations for PyTorch 2.2+
+if hasattr(torch.backends.mps, 'enable_workflow_compiling'):
+    print("Enabling MPS workflow compiling...")
+    torch.backends.mps.enable_workflow_compiling = True
+
+# A.1. Check Metal 3 / MPS support
+def setup_device():
+    """Checks Metal 3 / MPS support and returns appropriate device"""
+    print("PyTorch version:", torch.__version__)
+    
+    if torch.backends.mps.is_available() and torch.backends.mps.is_built():
+        print("Metal Performance Shaders (MPS) available.")
+        print("PYTORCH_ENABLE_MPS_FALLBACK=1 set - CPU will be used for unsupported operations.")
+        device = torch.device("mps")
+        
+        # Force GPU usage
+        dummy_tensor = torch.ones(1, device=device)
+        result = dummy_tensor + 1
+        is_mps_working = (result.device.type == 'mps')
+        
+        if is_mps_working:
+            print(f"MPS successfully tested: {result}")
+            print(f"Training device: {device}")
+            return device
+        else:
+            print("MPS is available but simple operation failed, using CPU.")
+            return torch.device("cpu")
+    else:
+        print("MPS not available, using CPU.")
+        device = torch.device("cpu")
+        print(f"Training device: {device}")
+        return device
+
+# A.1.1. Dataset analysis
+def analyze_dataset(data_path):
+    """Analyzes the dataset and calculates the number of samples per class"""
+    data_path = Path(data_path)
+    classes = [d.name for d in data_path.iterdir() if d.is_dir()]
+    class_counts = {}
+    
+    # Calculate the number of samples in each class
+    for cls in tqdm(classes, desc="Analyzing classes"):
+        class_path = data_path / cls
+        class_counts[cls] = len(list(class_path.glob('*.jpg')))
+    
+    # Display results
+    df = pd.DataFrame({'Class': list(class_counts.keys()), 
+                       'Number of Samples': list(class_counts.values())})
+    df = df.sort_values('Number of Samples', ascending=False).reset_index(drop=True)
+    
+    # Calculate statistics
+    total_samples = df['Number of Samples'].sum()
+    mean_samples = df['Number of Samples'].mean()
+    min_samples = df['Number of Samples'].min()
+    max_samples = df['Number of Samples'].max()
+    
+    print(f"Total number of samples: {total_samples}")
+    print(f"Average number of samples: {mean_samples:.1f}")
+    print(f"Minimum number of samples: {min_samples} ({df.iloc[-1]['Class']})")
+    print(f"Maximum number of samples: {max_samples} ({df.iloc[0]['Class']})")
+    
+    # Visualize class distribution
+    plt.figure(figsize=(14, 8))
+    plt.bar(df['Class'], df['Number of Samples'])
+    plt.xticks(rotation=90)
+    plt.title('Art Styles - Sample Distribution')
+    plt.xlabel('Class')
+    plt.ylabel('Number of Samples')
+    plt.tight_layout()
+    plt.savefig('results/class_distribution.png')
+    plt.close()
+    
+    return df, classes
+
+# A.2.2. Custom dataset class - Performs data augmentation on CPU
+class ArtStyleDataset(Dataset):
+    def __init__(self, root_dir, transform=None, target_transform=None, train=True, valid_pct=0.2, seed=42):
+        self.root_dir = Path(root_dir)
+        self.transform = transform
+        self.target_transform = target_transform
+        self.train = train
+        
+        # Get all images and labels
+        all_imgs = []
+        class_names = [d.name for d in self.root_dir.iterdir() if d.is_dir()]
+        self.class_to_idx = {cls_name: i for i, cls_name in enumerate(sorted(class_names))}
+        
+        # Collect images and labels for each class
+        for cls_name in class_names:
+            cls_path = self.root_dir / cls_name
+            cls_idx = self.class_to_idx[cls_name]
+            for img_path in cls_path.glob('*.jpg'):
+                all_imgs.append((str(img_path), cls_idx))
+                
+        # Shuffle data
+        random.seed(seed)
+        random.shuffle(all_imgs)
+        
+        # Split into training and validation sets
+        n_valid = int(len(all_imgs) * valid_pct)
+        if train:
+            self.imgs = all_imgs[n_valid:]
+        else:
+            self.imgs = all_imgs[:n_valid]
+        
+        self.classes = sorted(class_names)
+    
+    def __len__(self):
+        return len(self.imgs)
+    
+    def __getitem__(self, idx):
+        img_path, label = self.imgs[idx]
+        img = Image.open(img_path).convert('RGB')
+        
+        if self.transform:
+            img = self.transform(img)
+        
+        if self.target_transform:
+            label = self.target_transform(label)
+            
+        return img, label
+
+# A.2. Creating DataLoaders using PyTorch native structures
+def create_dataloaders(data_path, batch_size=32, img_size=224, augment=True, 
+                       balance_method='weighted', valid_pct=0.2, seed=42):
+    """Creates PyTorch DataLoaders"""
+    
+    # A.2.4. Define data transformations
+    # Transformations to run on CPU
+    if augment:
+        # A word on presizing:
+        # 1. Increase the size (item by item) - done by RandomResizedCrop
+        # 2. Apply augmentation (batch by batch) - done by various transforms
+        # 3. Decrease the size (batch by batch) - handled by normalization
+        # 4. Presizing avoids artifacts when applying augmentations (e.g., rotation)
+        train_transforms = T.Compose([
+            T.RandomResizedCrop(img_size, scale=(0.8, 1.0)),  # Increase size item by item
+            T.RandomHorizontalFlip(),
+            T.RandomRotation(10),  # Apply augmentation batch by batch
+            T.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),
+            T.ToTensor(),
+            T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])  # Decrease size batch by batch
+        ])
+    else:
+        train_transforms = T.Compose([
+            T.Resize(int(img_size*1.14)),
+            T.CenterCrop(img_size),
+            T.ToTensor(),
+            T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+        ])
+    
+    valid_transforms = T.Compose([
+        T.Resize(int(img_size*1.14)),
+        T.CenterCrop(img_size),
+        T.ToTensor(),
+        T.Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
+    ])
+    
+    # A.2.1. Define the blocks (dataset creation)
+    train_dataset = ArtStyleDataset(data_path, transform=train_transforms, train=True, valid_pct=valid_pct, seed=seed)
+    valid_dataset = ArtStyleDataset(data_path, transform=valid_transforms, train=False, valid_pct=valid_pct, seed=seed)
+    
+    # A.2.2. Define the means of getting data into DataBlock
+    # Calculate weights for weighted sampling
+    if balance_method == 'weighted' and train_dataset:
+        # Count classes
+        class_counts = Counter([label for _, label in train_dataset.imgs])
+        total = sum(class_counts.values())
+        
+        # Calculate weights (classes with fewer examples will get higher weights)
+        weights = [total / class_counts[train_dataset.imgs[i][1]] for i in range(len(train_dataset))]
+        sampler = torch.utils.data.WeightedRandomSampler(weights, len(weights))
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, sampler=sampler, num_workers=2, pin_memory=True)
+    else:
+        train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True, num_workers=2, pin_memory=True)
+    
+    valid_loader = DataLoader(valid_dataset, batch_size=batch_size, shuffle=False, num_workers=2, pin_memory=True)
+    
+    class_names = train_dataset.classes
+    
+    # Display data loader summary
+    print(f"Training dataset: {len(train_dataset)} images")
+    print(f"Validation dataset: {len(valid_dataset)} images")
+    print(f"Classes: {len(class_names)}")
+    
+    # Return the data loaders
+    return train_loader, valid_loader, class_names
+
+# PyTorch native training loop
+def train_epoch(model, dataloader, criterion, optimizer, device):
+    model.train()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+    batch_times = []
+    
+    # Show progress with tqdm
+    progress_bar = tqdm(dataloader, desc="Training", leave=False)
+    
+    # Monitor MPS memory usage
+    if device.type == 'mps':
+        print(f"MPS memory usage (start): {torch.mps.current_allocated_memory() / 1024**2:.2f} MB")
+    
+    start_time = time.time()
+    for inputs, labels in progress_bar:
+        batch_start = time.time()
+        
+        # Move data to device
+        inputs, labels = inputs.to(device), labels.to(device)
+        
+        # Verify training device
+        if total == 0:
+            print(f"Training tensor device: {inputs.device}, Model device: {next(model.parameters()).device}")
+        
+        # Zero gradients
+        optimizer.zero_grad()
+        
+        # Forward pass
+        outputs = model(inputs)
+        loss = criterion(outputs, labels)
+        
+        # Backward propagation
+        loss.backward()
+        optimizer.step()
+        
+        # Measure processing time
+        batch_end = time.time()
+        batch_time = batch_end - batch_start
+        batch_times.append(batch_time)
+        
+        # Update statistics
+        running_loss += loss.item() * inputs.size(0)
+        _, predicted = outputs.max(1)
+        total += labels.size(0)
+        correct += predicted.eq(labels).sum().item()
+        
+        # Update progress bar
+        progress_bar.set_postfix({'loss': loss.item(), 'acc': 100 * correct / total})
+    
+    # Calculate final statistics
+    avg_loss = running_loss / len(dataloader.dataset)
+    avg_acc = 100 * correct / total
+    avg_time = sum(batch_times) / len(batch_times)
+    total_time = time.time() - start_time
+    
+    # Monitoring memory usage
+    if device.type == 'mps':
+        print(f"MPS memory usage (end): {torch.mps.current_allocated_memory() / 1024**2:.2f} MB")
+        
+    # Print statistics
+    print(f"Training - Loss: {avg_loss:.4f}, Acc: {avg_acc:.2f}%, Time: {total_time:.1f}s, Avg batch: {avg_time:.3f}s")
+    
+    return avg_loss, avg_acc
+
+# A.3. Inspect the DataBlock via dataloader
+def validate_epoch(model, dataloader, criterion, device):
+    # Set model to evaluation mode
+    model.eval()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+    
+    # Disable gradient calculation
+    with torch.no_grad():
+        progress_bar = tqdm(dataloader, desc="Validation", leave=False)
+        
+        for inputs, labels in progress_bar:
+            # Move data to device
+            inputs, labels = inputs.to(device), labels.to(device)
+            
+            # Forward pass
+            outputs = model(inputs)
+            loss = criterion(outputs, labels)
+            
+            # Update statistics
+            running_loss += loss.item() * inputs.size(0)
+            _, predicted = outputs.max(1)
+            total += labels.size(0)
+            correct += predicted.eq(labels).sum().item()
+            
+            # Update progress bar
+            progress_bar.set_postfix({'loss': loss.item(), 'acc': 100 * correct / total})
+    
+    # Calculate final statistics
+    avg_loss = running_loss / len(dataloader.dataset)
+    avg_acc = 100 * correct / total
+    
+    # Print statistics
+    print(f"Validation - Loss: {avg_loss:.4f}, Acc: {avg_acc:.2f}%")
+    
+    return avg_loss, avg_acc
+
+# A.4. Train a simple model
+def train_model(train_loader, valid_loader, class_names, device, 
+                model_name="resnet34", lr=1e-3, epochs=10, 
+                freeze_epochs=3, unfreeze_epochs=7):
+    """Trains a model using transfer learning with discriminative learning rates"""
+    print(f"\nTraining {model_name} model for {epochs} epochs (freeze: {freeze_epochs}, unfreeze: {unfreeze_epochs})")
+    
+    # B.3. Transfer Learning setup
+    # Create ResNet34 model with pretrained weights
+    if model_name == "resnet34":
+        model = resnet34(weights=ResNet34_Weights.DEFAULT)
+        
+        # Replace the final layer with a new one for our classes
+        num_classes = len(class_names)
+        model.fc = nn.Linear(512, num_classes)
+    else:
+        raise ValueError(f"Unsupported model: {model_name}")
+    
+    # Move model to device
+    model = model.to(device)
+    
+    # B.3. Freeze all weights except the final layer
+    for param in model.parameters():
+        param.requires_grad = False
+    for param in model.fc.parameters():
+        param.requires_grad = True
+    
+    # Set up loss function
+    criterion = nn.CrossEntropyLoss()
+    
+    # Training history for plotting
+    history = {
+        'train_loss': [],
+        'train_acc': [],
+        'val_loss': [],
+        'val_acc': []
+    }
+    
+    # Training in two phases: first frozen, then unfrozen
+    total_start_time = time.time()
+    
+    # Phase 1: Train with frozen layers
+    if freeze_epochs > 0:
+        print("\n=== Phase 1: Training with frozen feature extractor ===")
+        optimizer = torch.optim.Adam(model.fc.parameters(), lr=lr)
+        
+        for epoch in range(freeze_epochs):
+            print(f"\nEpoch {epoch+1}/{freeze_epochs}")
+            train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device)
+            val_loss, val_acc = validate_epoch(model, valid_loader, criterion, device)
+            
+            # Record history
+            history['train_loss'].append(train_loss)
+            history['train_acc'].append(train_acc)
+            history['val_loss'].append(val_loss)
+            history['val_acc'].append(val_acc)
+    
+    # Phase 2: Unfreeze and train with discriminative learning rates
+    if unfreeze_epochs > 0:
+        print("\n=== Phase 2: Fine-tuning with discriminative learning rates ===")
+        
+        # B.3. Unfreeze all weights for fine-tuning
+        for param in model.parameters():
+            param.requires_grad = True
+        
+        # B.4. Discriminative learning rates
+        # Group parameters by layer to apply different learning rates
+        # Earlier layers get smaller learning rates (already well-trained)
+        # Later layers get higher learning rates (need more adaptation)
+        layer_params = [
+            {'params': model.layer1.parameters(), 'lr': lr/9},  # Earlier layers - smaller learning rate
+            {'params': model.layer2.parameters(), 'lr': lr/3},
+            {'params': model.layer3.parameters(), 'lr': lr/3},
+            {'params': model.layer4.parameters(), 'lr': lr},    # Later layers - higher learning rate
+            {'params': model.fc.parameters(), 'lr': lr*3}       # New classification layer - highest learning rate
+        ]
+        
+        optimizer = torch.optim.Adam(layer_params, lr=lr)
+        scheduler = torch.optim.lr_scheduler.OneCycleLR(
+            optimizer, max_lr=lr*3, total_steps=unfreeze_epochs * len(train_loader)
+        )
+        
+        for epoch in range(unfreeze_epochs):
+            print(f"\nEpoch {freeze_epochs+epoch+1}/{epochs}")
+            train_loss, train_acc = train_epoch(model, train_loader, criterion, optimizer, device)
+            val_loss, val_acc = validate_epoch(model, valid_loader, criterion, device)
+            
+            # Record history
+            history['train_loss'].append(train_loss)
+            history['train_acc'].append(train_acc)
+            history['val_loss'].append(val_loss)
+            history['val_acc'].append(val_acc)
+    
+    total_time = time.time() - total_start_time
+    print(f"\nTotal training time: {total_time:.1f} seconds ({total_time/60:.1f} minutes)")
+    
+    # Save model
+    os.makedirs('models', exist_ok=True)
+    torch.save(model.state_dict(), f'models/model_final.pth')
+    print(f"Model saved to models/model_final.pth")
+    
+    # A.4.2. Visualize training history
+    plt.figure(figsize=(12, 5))
+    plt.subplot(1, 2, 1)
+    plt.plot(history['train_loss'], label='Train')
+    plt.plot(history['val_loss'], label='Validation')
+    plt.title('Loss')
+    plt.xlabel('Epoch')
+    plt.legend()
+    
+    plt.subplot(1, 2, 2)
+    plt.plot(history['train_acc'], label='Train')
+    plt.plot(history['val_acc'], label='Validation')
+    plt.title('Accuracy')
+    plt.xlabel('Epoch')
+    plt.legend()
+    
+    plt.tight_layout()
+    plt.savefig('results/training_history.png')
+    plt.close()
+    
+    # A.4.3. Create confusion matrix
+    model.eval()
+    all_preds = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for inputs, labels in tqdm(valid_loader, desc="Creating confusion matrix"):
+            inputs, labels = inputs.to(device), labels.to(device)
+            outputs = model(inputs)
+            _, preds = outputs.max(1)
+            
+            all_preds.extend(preds.cpu().numpy())
+            all_labels.extend(labels.cpu().numpy())
+    
+    # Create and plot confusion matrix
+    from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
+    cm = confusion_matrix(all_labels, all_preds)
+    
+    plt.figure(figsize=(20, 20))
+    disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=class_names)
+    disp.plot(cmap='Blues', values_format='d')
+    plt.title('Confusion Matrix')
+    plt.xticks(rotation=90)
+    plt.tight_layout()
+    plt.savefig('results/confusion_matrix.png')
+    plt.close()
+    
+    return model, history
+
+def main():
+    # Setup environment
+    device = setup_device()
+    
+    # A.1. Download and analyze the data
+    data_path = "Art Dataset"
+    os.makedirs('results', exist_ok=True)
+    
+    # A.1.1. Inspect the data layout
+    print("\n===== A.1.1. Inspecting data layout =====")
+    df, classes = analyze_dataset(data_path)
+    
+    # A.2. Create the DataBlock and dataloaders
+    print("\n===== A.2. Creating DataLoaders =====")
+    train_loader, valid_loader, class_names = create_dataloaders(
+        data_path, batch_size=32, img_size=224, augment=True, 
+        balance_method='weighted', valid_pct=0.2
+    )
+    
+    # A.3. Inspect the DataBlock via dataloader
+    print("\n===== A.3. Inspecting DataBlock =====")
+    
+    # A.3.1. Show batch
+    def visualize_batch(dataloader, num_images=16):
+        """Display a batch of images from the dataloader"""
+        # Get a batch
+        images, labels = next(iter(dataloader))
+        images = images[:num_images]
+        labels = labels[:num_images]
+        
+        # Convert tensors back to images
+        # (unnormalize first)
+        mean = torch.tensor([0.485, 0.456, 0.406])
+        std = torch.tensor([0.229, 0.224, 0.225])
+        
+        # Create a grid of images
+        fig, axes = plt.subplots(nrows=4, ncols=4, figsize=(12, 12))
+        for i, (img, label) in enumerate(zip(images, labels)):
+            # Unnormalize
+            img = img.cpu() * std[:, None, None] + mean[:, None, None]
+            # Convert to numpy
+            img = img.permute(1, 2, 0).numpy()
+            # Clip values to valid range
+            img = np.clip(img, 0, 1)
+            
+            # Get class name
+            class_name = class_names[label]
+            class_name = class_name.replace('_', ' ')
+            
+            # Plot
+            row, col = i // 4, i % 4
+            axes[row, col].imshow(img)
+            axes[row, col].set_title(class_name)
+            axes[row, col].axis('off')
+        
+        plt.tight_layout()
+        plt.savefig('results/batch_preview.png')
+        plt.close()
+        print("Batch preview saved to results/batch_preview.png")
+    
+    # A.3.1. Show batch: dataloader.show_batch()
+    print("\n===== A.3.1. Showing batch =====")
+    visualize_batch(train_loader)
+    
+    # A.3.2. Check the labels
+    print("\n===== A.3.2. Checking labels =====")
+    print(f"Class names: {class_names}")
+    
+    # A.3.3. Summarize the DataBlock
+    print("\n===== A.3.3. Summarizing DataBlock =====")
+    print(f"Number of classes: {len(class_names)}")
+    print(f"Training batches: {len(train_loader)}")
+    print(f"Validation batches: {len(valid_loader)}")
+    print(f"Batch size: {train_loader.batch_size}")
+    print(f"Total training samples: {len(train_loader.dataset)}")
+    print(f"Total validation samples: {len(valid_loader.dataset)}")
+    
+    # A.4. Train a simple model
+    print("\n===== A.4. Training a simple model =====")
+    model, history = train_model(
+        train_loader, valid_loader, class_names, device,
+        model_name="resnet34", lr=1e-3, 
+        epochs=10, freeze_epochs=3, unfreeze_epochs=7
+    )
+    
+    print("\nTraining complete!")
+
+if __name__ == "__main__":
+    main()