Upload 5 files

README.md

@@ -1,14 +1,210 @@
----
-title: Smoker Detection
-emoji: 👀
-colorFrom: indigo
-colorTo: red
-sdk: gradio
-sdk_version: 5.49.0
-app_file: app.py
-pinned: false
-license: mit
-short_description: Fine-tuned computer vision model using LoRA
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+---
+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

best_model.pth

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

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