Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,36 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+env/
+venv/
+.venv/
+*.egg-info/
+
+# Jupyter
+.ipynb_checkpoints/
+*.ipynb_checkpoints
+
+# Model weights
+*.pth
+*.pt
+best_model.pth
+
+# Data
+data/
+*.csv
+*.jpg
+*.png
+*.jpeg
+
+# IDE
+.vscode/
+.idea/
+*.swp
+*.swo
+
+# OS
+.DS_Store
+Thumbs.db

README.md

@@ -0,0 +1,210 @@
+---
+license: mit
+tags:
+- image-classification
+- pytorch
+- resnet
+- lora
+- computer-vision
+- smoking-detection
+datasets:
+- sujaykapadnis/smoking
+metrics:
+- accuracy
+- f1
+library_name: pytorch
+pipeline_tag: image-classification
+---
+
+# Smoker Detection with LoRA Fine-Tuning
+
+Fine-tuned ResNet34 model using LoRA (Low-Rank Adaptation) for binary smoking detection in images.
+
+## Model Description
+
+This model uses parameter-efficient fine-tuning with LoRA on a pretrained ResNet34 to classify images as "Smoker" or "Non-Smoker". By training only 2.14% of parameters, it achieves 89.73% test accuracy while preserving ImageNet knowledge.
+
+- **Model Type:** ResNet34 + LoRA adapters
+- **Task:** Binary Image Classification
+- **Framework:** PyTorch
+- **License:** MIT
+
+## Performance
+
+| Split | Accuracy | F1-Score (Smoking) |
+|-------|----------|-------------------|
+| Validation | 94.44% | - |
+| Test | 89.73% | 89.96% |
+
+**Efficiency:**
+- Trainable parameters: 465K (2.14% of model)
+- Training time: ~15 minutes on Kaggle T4 GPU
+
+## Usage
+
+### Installation
+```bash
+pip install torch torchvision pillow
+Load Model
+pythonimport torch
+import torch.nn as nn
+from torchvision import models
+from torchvision.models import ResNet34_Weights
+from PIL import Image
+import torchvision.transforms as transforms
+
+# Define LoRA Layer
+class LoRALayer(nn.Module):
+    def __init__(self, original_layer, rank=8):
+        super().__init__()
+        self.original_layer = original_layer
+        self.rank = rank
+        
+        out_channels = original_layer.out_channels
+        in_channels = original_layer.in_channels
+        kernel_size = original_layer.kernel_size
+        
+        self.lora_A = nn.Parameter(
+            torch.randn(rank, in_channels, *kernel_size) * 0.01
+        )
+        self.lora_B = nn.Parameter(
+            torch.zeros(out_channels, rank, 1, 1)
+        )
+        
+        self.original_layer.weight.requires_grad = False
+        if self.original_layer.bias is not None:
+            self.original_layer.bias.requires_grad = False
+    
+    def forward(self, x):
+        original_output = self.original_layer(x)
+        lora_output = nn.functional.conv2d(
+            x, self.lora_A,
+            stride=self.original_layer.stride,
+            padding=self.original_layer.padding
+        )
+        lora_output = nn.functional.conv2d(lora_output, self.lora_B)
+        return original_output + lora_output
+
+def apply_lora_to_model(model, rank=8):
+    for param in model.parameters():
+        param.requires_grad = False
+    
+    for param in model.fc.parameters():
+        param.requires_grad = True
+    
+    for block in model.layer3:
+        if hasattr(block, 'conv1'):
+            block.conv1 = LoRALayer(block.conv1, rank=rank)
+        if hasattr(block, 'conv2'):
+            block.conv2 = LoRALayer(block.conv2, rank=rank)
+    
+    for block in model.layer4:
+        if hasattr(block, 'conv1'):
+            block.conv1 = LoRALayer(block.conv1, rank=rank)
+        if hasattr(block, 'conv2'):
+            block.conv2 = LoRALayer(block.conv2, rank=rank)
+    
+    return model
+
+# Load model
+model = models.resnet34(weights=ResNet34_Weights.IMAGENET1K_V1)
+model.fc = nn.Linear(model.fc.in_features, 2)
+model = apply_lora_to_model(model, rank=8)
+
+# Load trained weights
+model.load_state_dict(torch.load('best_model.pth', map_location='cpu'))
+model.eval()
+
+# Preprocessing
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),
+    transforms.ToTensor(),
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],
+        std=[0.229, 0.224, 0.225]
+    )
+])
+
+# Inference
+def predict(image_path):
+    image = Image.open(image_path).convert('RGB')
+    image_tensor = transform(image).unsqueeze(0)
+    
+    with torch.no_grad():
+        outputs = model(image_tensor)
+        probs = torch.softmax(outputs, dim=1)
+        confidence, predicted = torch.max(probs, 1)
+    
+    classes = ['Non-Smoker', 'Smoker']
+    return classes[predicted.item()], confidence.item() * 100
+
+# Example
+prediction, confidence = predict('image.jpg')
+print(f"{prediction} ({confidence:.1f}% confidence)")
+Training Details
+Dataset: 1,120 images from Kaggle Smoking Detection Dataset
+
+Training: 716 images (64%)
+Validation: 180 images (16%)
+Test: 224 images (20%)
+
+Hyperparameters:
+
+Learning Rate: 1e-4
+Optimizer: AdamW (weight decay: 1e-4)
+Batch Size: 32
+Epochs: 15
+LoRA Rank: 8
+
+Data Augmentation:
+
+Random horizontal flip (p=0.5)
+Random rotation (±10°)
+Color jitter (brightness, contrast, saturation)
+
+What is LoRA?
+LoRA (Low-Rank Adaptation) adds small trainable matrices to frozen pretrained weights:
+Output = W_frozen × input + (B × A) × input
+Where A and B are low-rank matrices (rank=8), adding only 2.14% trainable parameters while maintaining model capacity.
+Benefits:
+
+Prevents overfitting on small datasets
+Preserves pretrained ImageNet features
+Faster training and lower memory usage
+Easier deployment (smaller checkpoint files)
+
+Model Architecture
+ResNet34 (21.7M parameters)
+├── Frozen Layers (21.3M - 97.86%)
+│   ├── conv1, layer1, layer2
+│   └── Pretrained ImageNet weights
+└── Trainable Layers (465K - 2.14%)
+    ├── LoRA adapters on layer3 (6 blocks)
+    ├── LoRA adapters on layer4 (3 blocks)
+    └── Classification head fc (512 → 2)
+Limitations
+
+Trained on limited dataset (1,120 images)
+Low resolution images (250×250)
+May not generalize to all smoking scenarios
+Best for frontal/profile views with visible cigarettes
+
+Citation
+bibtex@misc{smoker-detection-lora,
+  author = {Noel Triguero},
+  title = {Smoker Detection with LoRA Fine-Tuning},
+  year = {2025},
+  publisher = {Hugging Face},
+  howpublished = {\url{https://huggingface.co/notrito/smoker-detection}}
+}
+References
+
+LoRA Paper - Hu et al., 2021
+Dataset - Sujay Kapadnis
+Training Notebook
+
+Contact
+
+Author: Noel Triguero
+Email: noel.triguero@gmail.com
+Kaggle: notrito

config.json

@@ -0,0 +1,14 @@
+{
+  "model_type": "resnet34-lora",
+  "architecture": "ResNet34 with LoRA adapters",
+  "task": "image-classification",
+  "num_classes": 2,
+  "class_names": ["Non-Smoker", "Smoker"],
+  "lora_config": {
+    "rank": 8,
+    "target_layers": ["layer3", "layer4"]
+  },
+  "input_size": [224, 224],
+  "pretrained_weights": "ImageNet",
+  "framework": "PyTorch"
+}

main.py

@@ -0,0 +1,193 @@
+"""
+Main training script for Smoker Detection with LoRA.
+
+Usage:
+    python train.py --data_path /path/to/data --epochs 15 --lr 1e-4 --rank 8
+"""
+
+import argparse
+from pathlib import Path
+import torch
+
+from src.model import get_model, apply_lora_to_model, count_parameters
+from src.dataset import create_dataloaders
+from src.train import train_model, get_optimizer_and_criterion
+from src.evaluate import (
+    evaluate_model, 
+    print_classification_report, 
+    plot_confusion_matrix, 
+    plot_training_history
+)
+from src.utils import set_seed, get_device, create_directories, print_dataset_info
+
+
+def parse_args():
+    """Parse command line arguments."""
+    parser = argparse.ArgumentParser(description='Train Smoker Detection Model with LoRA')
+    
+    # Data arguments
+    parser.add_argument('--data_path', type=str, default='/kaggle/input/smoking',
+                        help='Path to dataset root directory')
+    
+    # Model arguments
+    parser.add_argument('--rank', type=int, default=8,
+                        help='LoRA rank (default: 8)')
+    parser.add_argument('--target_layers', nargs='+', default=['layer3', 'layer4'],
+                        help='Layers to apply LoRA to (default: layer3 layer4)')
+    
+    # Training arguments
+    parser.add_argument('--epochs', type=int, default=15,
+                        help='Number of training epochs (default: 15)')
+    parser.add_argument('--batch_size', type=int, default=32,
+                        help='Batch size (default: 32)')
+    parser.add_argument('--lr', type=float, default=1e-4,
+                        help='Learning rate (default: 1e-4)')
+    parser.add_argument('--weight_decay', type=float, default=1e-4,
+                        help='Weight decay (default: 1e-4)')
+    parser.add_argument('--img_size', type=int, default=224,
+                        help='Image size (default: 224)')
+    parser.add_argument('--num_workers', type=int, default=2,
+                        help='Number of data loading workers (default: 2)')
+    
+    # Output arguments
+    parser.add_argument('--output_dir', type=str, default='results',
+                        help='Directory to save outputs (default: results)')
+    parser.add_argument('--model_save_path', type=str, default='best_model.pth',
+                        help='Path to save best model (default: best_model.pth)')
+    
+    # Other arguments
+    parser.add_argument('--seed', type=int, default=42,
+                        help='Random seed (default: 42)')
+    parser.add_argument('--no_cuda', action='store_true',
+                        help='Disable CUDA even if available')
+    
+    return parser.parse_args()
+
+
+def main():
+    """Main training function."""
+    args = parse_args()
+    
+    # Setup
+    print("\n" + "="*60)
+    print("🚀 Smoker Detection Training with LoRA")
+    print("="*60 + "\n")
+    
+    # Set seed for reproducibility
+    set_seed(args.seed)
+    
+    # Create output directory
+    create_directories([args.output_dir])
+    
+    # Get device
+    device = get_device()
+    if args.no_cuda:
+        device = torch.device('cpu')
+        print("CUDA disabled by user, using CPU")
+    
+    # Data paths
+    data_path = Path(args.data_path)
+    train_path = data_path / 'Training' / 'Training'
+    val_path = data_path / 'Validation' / 'Validation'
+    test_path = data_path / 'Testing' / 'Testing'
+    
+    # Create dataloaders
+    print("\n📦 Loading data...")
+    train_loader, val_loader, test_loader = create_dataloaders(
+        train_path=train_path,
+        val_path=val_path,
+        test_path=test_path,
+        batch_size=args.batch_size,
+        img_size=args.img_size,
+        num_workers=args.num_workers
+    )
+    
+    # Print dataset info
+    print_dataset_info(train_loader, val_loader, test_loader)
+    
+    # Create model
+    print("\n🏗️  Building model...")
+    model = get_model(num_classes=2, pretrained=True)
+    model = model.to(device)
+    
+    # Apply LoRA
+    print(f"\n🔧 Applying LoRA (rank={args.rank})...")
+    num_lora_layers = apply_lora_to_model(
+        model, 
+        target_layers=args.target_layers, 
+        rank=args.rank
+    )
+    print(f"✅ LoRA applied to {num_lora_layers} convolutional layers")
+    
+    # Count parameters
+    total_params, trainable_params, trainable_pct = count_parameters(model)
+    print(f"\n📊 Parameter Count:")
+    print(f"   Total: {total_params:,}")
+    print(f"   Trainable: {trainable_params:,} ({trainable_pct:.2f}%)")
+    print(f"   Frozen: {total_params - trainable_params:,} ({100 - trainable_pct:.2f}%)")
+    
+    # Get optimizer and criterion
+    print("\n⚙️  Setting up training...")
+    optimizer, criterion = get_optimizer_and_criterion(
+        model, 
+        lr=args.lr, 
+        weight_decay=args.weight_decay
+    )
+    
+    # Train model
+    print("\n" + "="*60)
+    history = train_model(
+        model=model,
+        train_loader=train_loader,
+        val_loader=val_loader,
+        criterion=criterion,
+        optimizer=optimizer,
+        device=device,
+        num_epochs=args.epochs,
+        save_path=args.model_save_path
+    )
+    
+    # Plot training curves
+    print("\n📊 Plotting training history...")
+    fig = plot_training_history(
+        history, 
+        save_path=f'{args.output_dir}/training_curves.png'
+    )
+    
+    # Evaluate on test set
+    print("\n" + "="*60)
+    print("🧪 Testing on held-out test set...")
+    print("="*60)
+    
+    # Load best model
+    model.load_state_dict(torch.load(args.model_save_path))
+    
+    # Get predictions
+    predictions, labels, test_acc = evaluate_model(
+        model, test_loader, device
+    )
+    
+    # Print classification report
+    print_classification_report(predictions, labels)
+    
+    # Plot confusion matrix
+    print("\n📊 Plotting confusion matrix...")
+    fig = plot_confusion_matrix(
+        predictions, 
+        labels,
+        save_path=f'{args.output_dir}/confusion_matrix.png'
+    )
+    
+    # Final summary
+    print("\n" + "="*60)
+    print("✅ Training Complete!")
+    print("="*60)
+    print(f"\n📁 Outputs saved to: {args.output_dir}/")
+    print(f"   - Training curves: {args.output_dir}/training_curves.png")
+    print(f"   - Confusion matrix: {args.output_dir}/confusion_matrix.png")
+    print(f"   - Best model: {args.model_save_path}")
+    print(f"\n🎯 Final Test Accuracy: {test_acc:.2f}%\n")
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,27 @@
+# Deep Learning
+torch>=2.0.0
+torchvision>=0.15.0
+
+# Data Processing
+numpy>=1.24.0
+pandas>=2.0.0
+Pillow>=9.5.0
+
+# Visualization
+matplotlib>=3.7.0
+seaborn>=0.12.0
+
+# Metrics
+scikit-learn>=1.3.0
+
+# Progress bars
+tqdm>=4.65.0
+
+# Jupyter (optional, for notebooks)
+jupyter>=1.0.0
+ipywidgets>=8.0.0
+
+# Configuration (optional)
+pyyaml>=6.0
+
+huggingface_hub

src/__init__.py

@@ -0,0 +1,86 @@
+"""
+Smoker Detection with LoRA Fine-Tuning
+
+A parameter-efficient approach to binary image classification using 
+Low-Rank Adaptation (LoRA) on pretrained ResNet34.
+"""
+
+from .model import (
+    LoRALayer,
+    get_model,
+    apply_lora_to_model,
+    count_parameters
+)
+
+from .dataset import (
+    SmokerDataset,
+    get_transforms,
+    create_dataloaders
+)
+
+from .train import (
+    train_one_epoch,
+    validate,
+    train_model,
+    get_optimizer_and_criterion
+)
+
+from .evaluate import (
+    evaluate_model,
+    print_classification_report,
+    plot_confusion_matrix,
+    plot_training_history,
+    get_predictions_with_confidence,
+    analyze_errors
+)
+
+from .utils import (
+    set_seed,
+    get_device,
+    save_checkpoint,
+    load_checkpoint,
+    visualize_samples,
+    print_dataset_info,
+    create_directories,
+    count_dataset_images
+)
+
+__version__ = '1.0.0'
+__author__ = 'Your Name'
+
+__all__ = [
+    # Model
+    'LoRALayer',
+    'get_model',
+    'apply_lora_to_model',
+    'count_parameters',
+    
+    # Dataset
+    'SmokerDataset',
+    'get_transforms',
+    'create_dataloaders',
+    
+    # Training
+    'train_one_epoch',
+    'validate',
+    'train_model',
+    'get_optimizer_and_criterion',
+    
+    # Evaluation
+    'evaluate_model',
+    'print_classification_report',
+    'plot_confusion_matrix',
+    'plot_training_history',
+    'get_predictions_with_confidence',
+    'analyze_errors',
+    
+    # Utils
+    'set_seed',
+    'get_device',
+    'save_checkpoint',
+    'load_checkpoint',
+    'visualize_samples',
+    'print_dataset_info',
+    'create_directories',
+    'count_dataset_images',
+]

src/dataset.py

@@ -0,0 +1,183 @@
+"""
+Custom Dataset class for Smoker Detection.
+Handles loading images and labels from folder structure.
+"""
+
+import os
+from pathlib import Path
+from PIL import Image
+import torch
+from torch.utils.data import Dataset, DataLoader
+from torchvision import transforms
+
+
+class SmokerDataset(Dataset):
+    """
+    Custom Dataset for Smoker Detection.
+    
+    Expects folder structure with images named:
+    - smoking_XXX.jpg for positive class
+    - notsmoking_XXX.jpg for negative class
+    
+    Args:
+        folder_path: Path to folder containing images
+        transform: Optional torchvision transforms to apply
+    """
+    
+    def __init__(self, folder_path, transform=None):
+        self.folder_path = Path(folder_path)
+        self.transform = transform
+        
+        # Get all image paths and labels
+        self.image_paths = []
+        self.labels = []
+        
+        # Load smoking images (label = 1)
+        for img_path in self.folder_path.glob('smoking_*.jpg'):
+            self.image_paths.append(img_path)
+            self.labels.append(1)
+        
+        # Load not smoking images (label = 0)
+        for img_path in self.folder_path.glob('notsmoking_*.jpg'):
+            self.image_paths.append(img_path)
+            self.labels.append(0)
+        
+        # Verify dataset is not empty
+        if len(self.image_paths) == 0:
+            raise ValueError(f"No images found in {folder_path}")
+        
+        print(f"Loaded {len(self.image_paths)} images from {folder_path.name}")
+        print(f"  - Smoking: {sum(self.labels)}")
+        print(f"  - Not Smoking: {len(self.labels) - sum(self.labels)}")
+    
+    def __len__(self):
+        return len(self.image_paths)
+    
+    def __getitem__(self, idx):
+        # Load image
+        img_path = self.image_paths[idx]
+        image = Image.open(img_path).convert('RGB')
+        label = self.labels[idx]
+        
+        # Apply transforms
+        if self.transform:
+            image = self.transform(image)
+        
+        return image, label
+    
+    def get_class_distribution(self):
+        """
+        Get the distribution of classes in the dataset.
+        
+        Returns:
+            dict: {'smoking': count, 'not_smoking': count}
+        """
+        smoking_count = sum(self.labels)
+        not_smoking_count = len(self.labels) - smoking_count
+        
+        return {
+            'smoking': smoking_count,
+            'not_smoking': not_smoking_count,
+            'total': len(self.labels),
+            'balance': smoking_count / len(self.labels)
+        }
+
+
+def get_transforms(img_size=224, augment=True):
+    """
+    Get image transformations for training or validation.
+    
+    Args:
+        img_size: Target image size (default: 224 for ImageNet models)
+        augment: Whether to apply data augmentation
+    
+    Returns:
+        torchvision.transforms.Compose object
+    """
+    # ImageNet normalization (standard for pretrained models)
+    mean = [0.485, 0.456, 0.406]
+    std = [0.229, 0.224, 0.225]
+    
+    if augment:
+        # Training transforms with augmentation
+        transform = transforms.Compose([
+            transforms.Resize((img_size, img_size)),
+            transforms.RandomHorizontalFlip(p=0.5),      # Smoking can occur on either side
+            transforms.RandomRotation(degrees=10),       # Slight rotations for robustness
+            transforms.ColorJitter(                      # Lighting variations
+                brightness=0.2,
+                contrast=0.2,
+                saturation=0.2,
+                hue=0.1
+            ),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=mean, std=std)
+        ])
+    else:
+        # Validation/Test transforms (no augmentation)
+        transform = transforms.Compose([
+            transforms.Resize((img_size, img_size)),
+            transforms.ToTensor(),
+            transforms.Normalize(mean=mean, std=std)
+        ])
+    
+    return transform
+
+
+def create_dataloaders(train_path, val_path, test_path, batch_size=32, 
+                       img_size=224, num_workers=2):
+    """
+    Create DataLoaders for training, validation, and test sets.
+    
+    Args:
+        train_path: Path to training data folder
+        val_path: Path to validation data folder
+        test_path: Path to test data folder
+        batch_size: Batch size for DataLoader (default: 32)
+        img_size: Image size for resizing (default: 224)
+        num_workers: Number of parallel workers for data loading (default: 2)
+    
+    Returns:
+        tuple: (train_loader, val_loader, test_loader)
+    """
+    # Get transforms
+    train_transforms = get_transforms(img_size=img_size, augment=True)
+    val_transforms = get_transforms(img_size=img_size, augment=False)
+    
+    # Create datasets
+    train_dataset = SmokerDataset(train_path, transform=train_transforms)
+    val_dataset = SmokerDataset(val_path, transform=val_transforms)
+    test_dataset = SmokerDataset(test_path, transform=val_transforms)
+    
+    # Create dataloaders
+    train_loader = DataLoader(
+        train_dataset,
+        batch_size=batch_size,
+        shuffle=True,           # Randomize batch composition each epoch
+        num_workers=num_workers,
+        pin_memory=True         # Faster GPU transfer
+    )
+    
+    val_loader = DataLoader(
+        val_dataset,
+        batch_size=batch_size,
+        shuffle=False,          # Keep order for reproducible evaluation
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    
+    test_loader = DataLoader(
+        test_dataset,
+        batch_size=batch_size,
+        shuffle=False,
+        num_workers=num_workers,
+        pin_memory=True
+    )
+    
+    print("\n✅ DataLoaders created")
+    print(f"   Training batches: {len(train_loader)}")
+    print(f"   Validation batches: {len(val_loader)}")
+    print(f"   Test batches: {len(test_loader)}")
+    print(f"   Batch size: {batch_size}")
+    
+    return train_loader, val_loader, test_loader

src/evaluate.py

@@ -0,0 +1,211 @@
+"""
+Evaluation functions for model testing and visualization.
+"""
+
+import torch
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+from tqdm import tqdm
+from sklearn.metrics import classification_report, confusion_matrix
+
+
+def evaluate_model(model, test_loader, device, class_names=['Not Smoking', 'Smoking']):
+    """
+    Evaluate model on test set and return predictions and labels.
+    
+    Args:
+        model: PyTorch model
+        test_loader: DataLoader for test data
+        device: Device to evaluate on (cuda/cpu)
+        class_names: List of class names for reporting
+    
+    Returns:
+        tuple: (all_predictions, all_labels, test_accuracy)
+    """
+    model.eval()
+    all_preds = []
+    all_labels = []
+    
+    print("🧪 Evaluating on Test Set...")
+    print(f"   Test batches: {len(test_loader)}\n")
+    
+    with torch.no_grad():
+        for images, labels in tqdm(test_loader, desc="Testing"):
+            images = images.to(device)
+            outputs = model(images)
+            _, predicted = outputs.max(1)
+            
+            all_preds.extend(predicted.cpu().numpy())
+            all_labels.extend(labels.numpy())
+    
+    # Calculate accuracy
+    test_acc = 100. * sum(p == l for p, l in zip(all_preds, all_labels)) / len(all_labels)
+    
+    return all_preds, all_labels, test_acc
+
+
+def print_classification_report(predictions, labels, class_names=['Not Smoking', 'Smoking']):
+    """
+    Print detailed classification metrics.
+    
+    Args:
+        predictions: List of predicted labels
+        labels: List of true labels
+        class_names: List of class names
+    """
+    print(f"\n{'='*60}")
+    print(f"📊 TEST SET RESULTS")
+    print(f"{'='*60}")
+    
+    # Overall accuracy
+    test_acc = 100. * sum(p == l for p, l in zip(predictions, labels)) / len(labels)
+    print(f"\n   Overall Accuracy: {test_acc:.2f}%\n")
+    
+    # Detailed report
+    print("\nDetailed Classification Report:")
+    print(classification_report(labels, predictions, target_names=class_names, digits=4))
+    print(f"{'='*60}")
+
+
+def plot_confusion_matrix(predictions, labels, class_names=['Not Smoking', 'Smoking'], 
+                          save_path=None):
+    """
+    Plot confusion matrix.
+    
+    Args:
+        predictions: List of predicted labels
+        labels: List of true labels
+        class_names: List of class names
+        save_path: Optional path to save the figure
+    
+    Returns:
+        matplotlib figure
+    """
+    cm = confusion_matrix(labels, predictions)
+    
+    fig, ax = plt.subplots(figsize=(8, 6))
+    sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', 
+                xticklabels=class_names, yticklabels=class_names,
+                cbar_kws={'label': 'Count'}, ax=ax)
+    ax.set_title('Confusion Matrix - Test Set', fontsize=14, fontweight='bold')
+    ax.set_ylabel('True Label')
+    ax.set_xlabel('Predicted Label')
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Confusion matrix saved to {save_path}")
+    
+    return fig
+
+
+def plot_training_history(history, save_path=None):
+    """
+    Plot training and validation loss/accuracy curves.
+    
+    Args:
+        history: Dictionary with keys 'train_loss', 'val_loss', 'train_acc', 'val_acc'
+        save_path: Optional path to save the figure
+    
+    Returns:
+        matplotlib figure
+    """
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 5))
+    
+    # Loss curves
+    ax1.plot(history['train_loss'], label='Train Loss', marker='o', linewidth=2)
+    ax1.plot(history['val_loss'], label='Val Loss', marker='s', linewidth=2)
+    ax1.set_xlabel('Epoch', fontsize=12)
+    ax1.set_ylabel('Loss', fontsize=12)
+    ax1.set_title('Training and Validation Loss', fontsize=14, fontweight='bold')
+    ax1.legend(fontsize=11)
+    ax1.grid(True, alpha=0.3)
+    
+    # Accuracy curves
+    ax2.plot(history['train_acc'], label='Train Accuracy', marker='o', linewidth=2)
+    ax2.plot(history['val_acc'], label='Val Accuracy', marker='s', linewidth=2)
+    ax2.set_xlabel('Epoch', fontsize=12)
+    ax2.set_ylabel('Accuracy (%)', fontsize=12)
+    ax2.set_title('Training and Validation Accuracy', fontsize=14, fontweight='bold')
+    ax2.legend(fontsize=11)
+    ax2.grid(True, alpha=0.3)
+    
+    plt.tight_layout()
+    
+    if save_path:
+        plt.savefig(save_path, dpi=300, bbox_inches='tight')
+        print(f"Training history saved to {save_path}")
+    
+    return fig
+
+
+def get_predictions_with_confidence(model, dataloader, device):
+    """
+    Get predictions along with confidence scores.
+    
+    Args:
+        model: PyTorch model
+        dataloader: DataLoader for data
+        device: Device to run inference on
+    
+    Returns:
+        tuple: (predictions, confidences, labels)
+    """
+    model.eval()
+    all_preds = []
+    all_confidences = []
+    all_labels = []
+    
+    with torch.no_grad():
+        for images, labels in dataloader:
+            images = images.to(device)
+            outputs = model(images)
+            
+            # Get softmax probabilities
+            probs = torch.softmax(outputs, dim=1)
+            confidences, predicted = probs.max(1)
+            
+            all_preds.extend(predicted.cpu().numpy())
+            all_confidences.extend(confidences.cpu().numpy())
+            all_labels.extend(labels.numpy())
+    
+    return np.array(all_preds), np.array(all_confidences), np.array(all_labels)
+
+
+def analyze_errors(model, dataloader, device, dataset, num_samples=10):
+    """
+    Analyze misclassified samples.
+    
+    Args:
+        model: PyTorch model
+        dataloader: DataLoader for data
+        device: Device to run inference on
+        dataset: Original dataset to access images
+        num_samples: Number of error samples to display
+    
+    Returns:
+        List of dictionaries with error information
+    """
+    predictions, confidences, labels = get_predictions_with_confidence(model, dataloader, device)
+    
+    # Find misclassified samples
+    errors = []
+    for idx, (pred, conf, label) in enumerate(zip(predictions, confidences, labels)):
+        if pred != label:
+            errors.append({
+                'index': idx,
+                'true_label': label,
+                'predicted_label': pred,
+                'confidence': conf,
+                'image_path': dataset.image_paths[idx]
+            })
+    
+    print(f"\n🔍 Error Analysis:")
+    print(f"   Total errors: {len(errors)}")
+    print(f"   Error rate: {100 * len(errors) / len(labels):.2f}%")
+    
+    # Sort by confidence (highest confidence errors are most interesting)
+    errors.sort(key=lambda x: x['confidence'], reverse=True)
+    
+    return errors[:num_samples]

src/model.py

@@ -0,0 +1,179 @@
+"""
+LoRA (Low-Rank Adaptation) implementation for convolutional layers.
+"""
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from torchvision import models
+
+
+class LoRALayer(nn.Module):
+    """
+    LoRA (Low-Rank Adaptation) wrapper for convolutional layers.
+    
+    Args:
+        original_layer: The Conv2d layer to adapt
+        rank: LoRA rank (default=8)
+              - Lower rank (4): Fewer parameters, less overfitting risk, less capacity
+              - Medium rank (8-16): Balanced trade-off (recommended for most tasks)
+              - Higher rank (32+): More capacity but approaches full fine-tuning
+              
+              For small datasets (<1000 images), rank=8 provides sufficient
+              adaptation capacity while keeping parameters low (~2% of original layer).
+    """
+    
+    def __init__(self, original_layer, rank=8):
+        super().__init__()
+        self.original_layer = original_layer
+        self.rank = rank
+        
+        # Get dimensions from original layer
+        out_channels = original_layer.out_channels
+        in_channels = original_layer.in_channels
+        kernel_size = original_layer.kernel_size
+        
+        # LoRA matrices: A (down-projection) and B (up-projection)
+        # A reduces dimensions: in_channels -> rank
+        # Initialized with small random values to break symmetry
+        self.lora_A = nn.Parameter(
+            torch.randn(rank, in_channels, *kernel_size) * 0.01
+        )
+        
+        # B expands dimensions: rank -> out_channels
+        # Initialized to zeros so LoRA starts as identity (preserves pretrained weights)
+        # This initialization strategy follows the original LoRA paper
+        self.lora_B = nn.Parameter(
+            torch.zeros(out_channels, rank, 1, 1)
+        )
+        
+        # Freeze original weights (preserve ImageNet knowledge)
+        self.original_layer.weight.requires_grad = False
+        if self.original_layer.bias is not None:
+            self.original_layer.bias.requires_grad = False
+    
+    def forward(self, x):
+        """
+        Forward pass combining original frozen weights with LoRA adaptation.
+        
+        Mathematical formulation:
+        output = W_frozen * x + (B * (A * x))
+        
+        where * denotes convolution operation.
+        """
+        # Original forward pass (frozen pretrained weights)
+        original_output = self.original_layer(x)
+        
+        # LoRA adaptation pathway (low-rank decomposition)
+        # Step 1: Down-project with A (in_channels → rank)
+        lora_output = F.conv2d(
+            x,
+            self.lora_A,
+            stride=self.original_layer.stride,
+            padding=self.original_layer.padding
+        )
+        
+        # Step 2: Up-project with B (rank → out_channels)
+        # These two sequential convolutions approximate a low-rank adaptation
+        lora_output = F.conv2d(lora_output, self.lora_B)
+        
+        # Combine: W*x + (B*(A*x)) where * denotes convolution
+        return original_output + lora_output
+
+
+def get_model(num_classes=2, pretrained=True):
+    """
+    Load ResNet34 with optional pretrained weights.
+    
+    Args:
+        num_classes: Number of output classes
+        pretrained: Whether to load ImageNet pretrained weights
+    
+    Returns:
+        ResNet34 model
+    """
+    if pretrained:
+        model = models.resnet34(weights=models.ResNet34_Weights.IMAGENET1K_V1)
+    else:
+        model = models.resnet34(weights=None)
+    
+    # Modify last layer for classification
+    num_features = model.fc.in_features
+    model.fc = nn.Linear(num_features, num_classes)
+    
+    return model
+
+
+def apply_lora_to_model(model, target_layers=['layer3', 'layer4'], rank=8):
+    """
+    Apply LoRA adapters to specific layers in ResNet34.
+    
+    Strategy: We target layer3 and layer4 (high-level feature extractors) because:
+    - layer1 & layer2: Extract low-level features (edges, textures) that are 
+      universal across tasks → keep frozen, no adaptation needed
+    - layer3 & layer4: Extract high-level semantic features (objects, contexts)
+      that are task-specific → need slight adaptation for smoking detection
+    - fc: Brand new classifier head → fully trainable
+    
+    This approach gives us the sweet spot:
+    - Full fine-tuning: 21.8M params (overfitting risk with small datasets)
+    - Only fc training: ~1K params (may underfit, features not adapted)
+    - LoRA on layer3+layer4: ~465K params (2.14% of model, balanced approach)
+    
+    Args:
+        model: ResNet34 model
+        target_layers: List of layer names to apply LoRA to
+        rank: LoRA rank (default=8, adds ~2% params per adapted layer)
+    
+    Returns:
+        Number of convolutional layers where LoRA was applied
+    """
+    # Freeze ALL layers first (preserve ImageNet features)
+    for param in model.parameters():
+        param.requires_grad = False
+    
+    # Unfreeze only the new classification head
+    for param in model.fc.parameters():
+        param.requires_grad = True
+    
+    lora_count = 0
+    
+    for layer_name in target_layers:
+        # Get the layer dynamically (e.g., model.layer3)
+        layer = getattr(model, layer_name)
+        
+        # Iterate through all blocks in this layer
+        for block in layer:
+            # Find all Conv2d layers in this block dynamically
+            for name, module in block.named_modules():
+                if isinstance(module, nn.Conv2d):
+                    # Get parent module and attribute name to replace it
+                    parent = block
+                    attr_names = name.split('.')
+                    
+                    # Navigate to parent of the conv layer
+                    for attr in attr_names[:-1]:
+                        parent = getattr(parent, attr)
+                    
+                    # Check if not already wrapped
+                    current_module = getattr(parent, attr_names[-1])
+                    if not isinstance(current_module, LoRALayer):
+                        # Replace with LoRA-wrapped version
+                        setattr(parent, attr_names[-1], LoRALayer(current_module, rank=rank))
+                        lora_count += 1
+    
+    return lora_count
+
+
+def count_parameters(model):
+    """
+    Count total and trainable parameters in the model.
+    
+    Returns:
+        tuple: (total_params, trainable_params, trainable_percentage)
+    """
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    trainable_pct = 100. * trainable_params / total_params
+    
+    return total_params, trainable_params, trainable_pct

src/train.py

@@ -0,0 +1,195 @@
+"""
+Training and validation functions for the smoker detection model.
+"""
+
+import torch
+import torch.nn as nn
+from tqdm import tqdm
+
+
+def train_one_epoch(model, train_loader, criterion, optimizer, device):
+    """
+    Train the model for one epoch.
+    
+    Args:
+        model: PyTorch model
+        train_loader: DataLoader for training data
+        criterion: Loss function
+        optimizer: Optimizer
+        device: Device to train on (cuda/cpu)
+    
+    Returns:
+        tuple: (epoch_loss, epoch_accuracy)
+    """
+    model.train()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+    
+    for images, labels in tqdm(train_loader, desc="Training", leave=False):
+        images, labels = images.to(device), labels.to(device)
+        
+        # Zero gradients
+        optimizer.zero_grad()
+        
+        # Forward pass
+        outputs = model(images)
+        loss = criterion(outputs, labels)
+        
+        # Backward pass and optimization
+        loss.backward()
+        optimizer.step()
+        
+        # Statistics
+        running_loss += loss.item()
+        _, predicted = outputs.max(1)
+        total += labels.size(0)
+        correct += predicted.eq(labels).sum().item()
+    
+    epoch_loss = running_loss / len(train_loader)
+    epoch_acc = 100. * correct / total
+    
+    return epoch_loss, epoch_acc
+
+
+def validate(model, val_loader, criterion, device):
+    """
+    Validate the model.
+    
+    Args:
+        model: PyTorch model
+        val_loader: DataLoader for validation data
+        criterion: Loss function
+        device: Device to validate on (cuda/cpu)
+    
+    Returns:
+        tuple: (epoch_loss, epoch_accuracy)
+    """
+    model.eval()
+    running_loss = 0.0
+    correct = 0
+    total = 0
+    
+    with torch.no_grad():
+        for images, labels in tqdm(val_loader, desc="Validation", leave=False):
+            images, labels = images.to(device), labels.to(device)
+            
+            # Forward pass
+            outputs = model(images)
+            loss = criterion(outputs, labels)
+            
+            # Statistics
+            running_loss += loss.item()
+            _, predicted = outputs.max(1)
+            total += labels.size(0)
+            correct += predicted.eq(labels).sum().item()
+    
+    epoch_loss = running_loss / len(val_loader)
+    epoch_acc = 100. * correct / total
+    
+    return epoch_loss, epoch_acc
+
+
+def train_model(model, train_loader, val_loader, criterion, optimizer, 
+                device, num_epochs=15, save_path='best_model.pth'):
+    """
+    Complete training loop with validation and model checkpointing.
+    
+    Args:
+        model: PyTorch model
+        train_loader: DataLoader for training data
+        val_loader: DataLoader for validation data
+        criterion: Loss function
+        optimizer: Optimizer
+        device: Device to train on (cuda/cpu)
+        num_epochs: Number of training epochs (default: 15)
+        save_path: Path to save best model (default: 'best_model.pth')
+    
+    Returns:
+        dict: Training history with losses and accuracies
+    """
+    best_val_acc = 0.0
+    history = {
+        'train_loss': [],
+        'train_acc': [],
+        'val_loss': [],
+        'val_acc': []
+    }
+    
+    print("🚀 Starting training...")
+    print(f"   Epochs: {num_epochs}")
+    print(f"   Device: {device}")
+    print(f"   Training batches: {len(train_loader)}")
+    print(f"   Validation batches: {len(val_loader)}\n")
+    
+    for epoch in range(num_epochs):
+        print(f"\nEpoch {epoch+1}/{num_epochs}")
+        print("-" * 60)
+        
+        # Train
+        train_loss, train_acc = train_one_epoch(
+            model, train_loader, criterion, optimizer, device
+        )
+        
+        # Validate
+        val_loss, val_acc = validate(
+            model, val_loader, criterion, device
+        )
+        
+        # Save 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)
+        
+        # Print results
+        print(f"\nResults:")
+        print(f"   Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}%")
+        print(f"   Val Loss:   {val_loss:.4f} | Val Acc:   {val_acc:.2f}%")
+        
+        # Save best model
+        if val_acc > best_val_acc:
+            best_val_acc = val_acc
+            torch.save(model.state_dict(), save_path)
+            print(f"   ✅ New best model saved! (Val Acc: {val_acc:.2f}%)")
+    
+    print("\n" + "="*60)
+    print(f"🎉 Training completed!")
+    print(f"   Best validation accuracy: {best_val_acc:.2f}%")
+    print(f"   Model saved to: {save_path}")
+    
+    return history
+
+
+def get_optimizer_and_criterion(model, lr=1e-4, weight_decay=1e-4):
+    """
+    Create optimizer and loss criterion with standard hyperparameters.
+    
+    Args:
+        model: PyTorch model
+        lr: Learning rate (default: 1e-4, conservative for fine-tuning)
+        weight_decay: L2 regularization (default: 1e-4)
+    
+    Returns:
+        tuple: (optimizer, criterion)
+    """
+    # Loss function
+    criterion = nn.CrossEntropyLoss()
+    
+    # Optimizer - only optimize trainable parameters
+    optimizer = torch.optim.AdamW(
+        filter(lambda p: p.requires_grad, model.parameters()),
+        lr=lr,
+        weight_decay=weight_decay
+    )
+    
+    print("✅ Training configuration ready")
+    print(f"   Loss: CrossEntropyLoss")
+    print(f"   Optimizer: AdamW")
+    print(f"   Learning rate: {lr}")
+    print(f"   Weight decay: {weight_decay}")
+    
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    print(f"   Optimizing {trainable_params:,} parameters")
+    
+    return optimizer, criterion

src/utils.py

@@ -0,0 +1,206 @@
+"""
+Utility functions for the smoker detection project.
+"""
+
+import os
+import random
+import numpy as np
+import torch
+import matplotlib.pyplot as plt
+from pathlib import Path
+
+
+def set_seed(seed=42):
+    """
+    Set random seed for reproducibility.
+    
+    Args:
+        seed: Random seed value (default: 42)
+    """
+    random.seed(seed)
+    np.random.seed(seed)
+    torch.manual_seed(seed)
+    if torch.cuda.is_available():
+        torch.cuda.manual_seed(seed)
+        torch.cuda.manual_seed_all(seed)
+        torch.backends.cudnn.deterministic = True
+        torch.backends.cudnn.benchmark = False
+    
+    print(f"✅ Random seed set to {seed}")
+
+
+def get_device():
+    """
+    Get the device to use (cuda or cpu).
+    
+    Returns:
+        torch.device: Device to use for training/inference
+    """
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    
+    if torch.cuda.is_available():
+        print(f"✅ GPU available: {torch.cuda.get_device_name(0)}")
+    else:
+        print("⚠️  No GPU available, using CPU")
+    
+    return device
+
+
+def save_checkpoint(model, optimizer, epoch, val_acc, path='checkpoint.pth'):
+    """
+    Save model checkpoint.
+    
+    Args:
+        model: PyTorch model
+        optimizer: Optimizer
+        epoch: Current epoch number
+        val_acc: Validation accuracy
+        path: Path to save checkpoint
+    """
+    checkpoint = {
+        'epoch': epoch,
+        'model_state_dict': model.state_dict(),
+        'optimizer_state_dict': optimizer.state_dict(),
+        'val_acc': val_acc
+    }
+    torch.save(checkpoint, path)
+    print(f"Checkpoint saved to {path}")
+
+
+def load_checkpoint(model, optimizer, path='checkpoint.pth'):
+    """
+    Load model checkpoint.
+    
+    Args:
+        model: PyTorch model
+        optimizer: Optimizer
+        path: Path to checkpoint file
+    
+    Returns:
+        tuple: (epoch, val_acc)
+    """
+    checkpoint = torch.load(path)
+    model.load_state_dict(checkpoint['model_state_dict'])
+    optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
+    epoch = checkpoint['epoch']
+    val_acc = checkpoint['val_acc']
+    
+    print(f"Checkpoint loaded from {path}")
+    print(f"   Epoch: {epoch}, Val Acc: {val_acc:.2f}%")
+    
+    return epoch, val_acc
+
+
+def visualize_samples(dataset, num_samples=8, class_names=['Not Smoking', 'Smoking']):
+    """
+    Visualize random samples from the dataset.
+    
+    Args:
+        dataset: SmokerDataset instance
+        num_samples: Number of samples to display
+        class_names: List of class names
+    
+    Returns:
+        matplotlib figure
+    """
+    # Get random indices
+    indices = random.sample(range(len(dataset)), num_samples)
+    
+    # Calculate grid size
+    cols = 4
+    rows = (num_samples + cols - 1) // cols
+    
+    fig, axes = plt.subplots(rows, cols, figsize=(16, 4*rows))
+    axes = axes.flatten() if num_samples > 1 else [axes]
+    
+    for idx, ax in zip(indices, axes):
+        # Get image (without transform for visualization)
+        img_path = dataset.image_paths[idx]
+        from PIL import Image
+        img = Image.open(img_path)
+        label = dataset.labels[idx]
+        
+        # Display
+        ax.imshow(img)
+        ax.set_title(f'{class_names[label]}\n{img.size[0]}x{img.size[1]}', 
+                     fontsize=10, fontweight='bold',
+                     color='red' if label == 1 else 'green')
+        ax.axis('off')
+    
+    # Hide extra subplots
+    for ax in axes[num_samples:]:
+        ax.axis('off')
+    
+    plt.tight_layout()
+    return fig
+
+
+def print_dataset_info(train_loader, val_loader, test_loader):
+    """
+    Print information about the datasets.
+    
+    Args:
+        train_loader: Training DataLoader
+        val_loader: Validation DataLoader
+        test_loader: Test DataLoader
+    """
+    print("\n" + "="*60)
+    print("📊 Dataset Information")
+    print("="*60)
+    
+    train_size = len(train_loader.dataset)
+    val_size = len(val_loader.dataset)
+    test_size = len(test_loader.dataset)
+    total_size = train_size + val_size + test_size
+    
+    print(f"\nDataset Splits:")
+    print(f"   Training:   {train_size:4d} images ({100*train_size/total_size:.1f}%)")
+    print(f"   Validation: {val_size:4d} images ({100*val_size/total_size:.1f}%)")
+    print(f"   Test:       {test_size:4d} images ({100*test_size/total_size:.1f}%)")
+    print(f"   Total:      {total_size:4d} images")
+    
+    print(f"\nBatch Information:")
+    print(f"   Batch size: {train_loader.batch_size}")
+    print(f"   Train batches: {len(train_loader)}")
+    print(f"   Val batches:   {len(val_loader)}")
+    print(f"   Test batches:  {len(test_loader)}")
+    print("="*60 + "\n")
+
+
+def create_directories(dirs):
+    """
+    Create directories if they don't exist.
+    
+    Args:
+        dirs: List of directory paths to create
+    """
+    for dir_path in dirs:
+        Path(dir_path).mkdir(parents=True, exist_ok=True)
+    print(f"✅ Directories created: {', '.join(dirs)}")
+
+
+def count_dataset_images(data_path):
+    """
+    Count images in dataset folders.
+    
+    Args:
+        data_path: Path to dataset root
+    
+    Returns:
+        dict: Image counts per split
+    """
+    data_path = Path(data_path)
+    counts = {}
+    
+    for split in ['Training', 'Validation', 'Testing']:
+        folder = data_path / split / split
+        if folder.exists():
+            smoking = len(list(folder.glob('smoking_*.jpg')))
+            not_smoking = len(list(folder.glob('notsmoking_*.jpg')))
+            counts[split] = {
+                'smoking': smoking,
+                'not_smoking': not_smoking,
+                'total': smoking + not_smoking
+            }
+    
+    return counts