Upload 9 files

Dockerfile

@@ -0,0 +1,34 @@
+# Use Python 3.9 slim image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    wget \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Create models directory
+RUN mkdir -p models
+
+# Expose port
+EXPOSE 7860
+
+# Set environment variables
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Command to run the application
+CMD ["python", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 AhmedAl-Mahdi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

app.py

@@ -0,0 +1,240 @@
+import gradio as gr
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+from torchvision import models
+import numpy as np
+from PIL import Image
+import os
+
+# Aircraft class names (10 classes from the dataset)
+CLASS_NAMES = [
+    '707-320', '737-400', '767-300', 'DC-9-30', 'DH-82', 
+    'Falcon_2000', 'Il-76', 'MD-11', 'Metroliner', 'PA-28'
+]
+
+class AircraftClassifier(nn.Module):
+    """ResNet-18 based aircraft classifier"""
+    def __init__(self, num_classes=10):
+        super(AircraftClassifier, self).__init__()
+        # Load pre-trained ResNet-18
+        self.backbone = models.resnet18(pretrained=True)
+        # Replace the final fully connected layer
+        num_features = self.backbone.fc.in_features
+        self.backbone.fc = nn.Linear(num_features, num_classes)
+    
+    def forward(self, x):
+        return self.backbone(x)
+
+# Image preprocessing pipeline
+def get_transforms():
+    """Get image preprocessing transforms"""
+    return transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+        transforms.Normalize(mean=[0.485, 0.456, 0.406], 
+                           std=[0.229, 0.224, 0.225])
+    ])
+
+# Initialize model and device
+device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+model = AircraftClassifier(num_classes=len(CLASS_NAMES))
+
+# Try to load trained model weights
+model_path = 'models/aircraft_classifier.pth'
+if os.path.exists(model_path):
+    try:
+        model.load_state_dict(torch.load(model_path, map_location=device))
+        print(f"✅ Loaded trained model from {model_path}")
+    except Exception as e:
+        print(f"⚠️ Could not load trained model: {e}")
+        print("Using random weights - please train the model first!")
+else:
+    print(f"⚠️ Model file not found at {model_path}")
+    print("Using random weights - please train the model first!")
+
+model = model.to(device)
+model.eval()
+
+# Get image transforms
+transform = get_transforms()
+
+def classify_aircraft(image):
+    """
+    Classify an aircraft image
+    
+    Args:
+        image: PIL Image or numpy array
+        
+    Returns:
+        dict: Classification results with confidence scores
+    """
+    try:
+        # Convert to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            image = Image.fromarray(image)
+        
+        # Convert to RGB if needed
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        
+        # Apply transforms
+        input_tensor = transform(image).unsqueeze(0).to(device)
+        
+        # Get prediction
+        with torch.no_grad():
+            outputs = model(input_tensor)
+            probabilities = torch.softmax(outputs, dim=1)
+            
+        # Get top predictions
+        probs = probabilities.cpu().numpy()[0]
+        
+        # Create results dictionary for Gradio
+        results = {}
+        for i, class_name in enumerate(CLASS_NAMES):
+            results[class_name] = float(probs[i])
+            
+        return results
+        
+    except Exception as e:
+        print(f"Error in classification: {e}")
+        # Return empty results in case of error
+        return {class_name: 0.0 for class_name in CLASS_NAMES}
+
+def get_top_predictions(image):
+    """
+    Get top 3 predictions with confidence scores
+    
+    Args:
+        image: PIL Image or numpy array
+        
+    Returns:
+        str: Formatted string with top predictions
+    """
+    try:
+        results = classify_aircraft(image)
+        
+        # Sort by confidence
+        sorted_results = sorted(results.items(), key=lambda x: x[1], reverse=True)
+        
+        # Format top 3 predictions
+        output_text = "🎯 **Top Predictions:**\n\n"
+        for i, (class_name, confidence) in enumerate(sorted_results[:3]):
+            confidence_percent = confidence * 100
+            output_text += f"{i+1}. **{class_name}**: {confidence_percent:.2f}%\n"
+            
+        return output_text
+        
+    except Exception as e:
+        return f"❌ Error during classification: {str(e)}"
+
+# Create Gradio interface
+def create_interface():
+    """Create and configure the Gradio interface"""
+    
+    # Custom CSS for better styling
+    css = """
+    .gradio-container {
+        max-width: 900px !important;
+        margin: auto !important;
+    }
+    .title {
+        text-align: center;
+        font-size: 2.5em;
+        font-weight: bold;
+        margin-bottom: 0.5em;
+    }
+    .description {
+        text-align: center;
+        font-size: 1.2em;
+        color: #666;
+        margin-bottom: 2em;
+    }
+    """
+    
+    with gr.Blocks(css=css, title="Aircraft Classifier") as iface:
+        # Header
+        gr.HTML("""
+        <div class="title">🛩️ Aircraft Classifier</div>
+        <div class="description">
+            Fine-grained aircraft classification using deep learning<br>
+            Upload an image to classify it into one of 10 aircraft types
+        </div>
+        """)
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                # Input image
+                input_image = gr.Image(
+                    type="pil",
+                    label="Upload Aircraft Image",
+                    height=400
+                )
+                
+                # Example images section (commented out to avoid network issues)
+                # gr.HTML("### 📸 Try these example images:")
+                # gr.Examples(
+                #     examples=[
+                #         ["path/to/local/example1.jpg"],
+                #         ["path/to/local/example2.jpg"],
+                #     ],
+                #     inputs=input_image,
+                #     cache_examples=False
+                # )
+                
+            with gr.Column(scale=1):
+                # Classification results
+                classification_output = gr.Label(
+                    label="🎯 Classification Results",
+                    num_top_classes=10
+                )
+                
+                # Top predictions text
+                top_predictions = gr.Textbox(
+                    label="📊 Detailed Results",
+                    lines=6,
+                    interactive=False
+                )
+        
+        # Model information
+        gr.HTML("""
+        <div style="margin-top: 2em; padding: 1em; background-color: #f8f9fa; border-radius: 8px;">
+            <h3>🔧 Model Information</h3>
+            <ul>
+                <li><b>Architecture:</b> ResNet-18 with transfer learning</li>
+                <li><b>Dataset:</b> FGVC-Aircraft (10 classes)</li>
+                <li><b>Accuracy:</b> 87.17% on test set</li>
+                <li><b>Classes:</b> 707-320, 737-400, 767-300, DC-9-30, DH-82, Falcon_2000, Il-76, MD-11, Metroliner, PA-28</li>
+            </ul>
+        </div>
+        """)
+        
+        # Set up the prediction triggers
+        input_image.change(
+            fn=classify_aircraft,
+            inputs=[input_image],
+            outputs=[classification_output]
+        )
+        
+        input_image.change(
+            fn=get_top_predictions,
+            inputs=[input_image],
+            outputs=[top_predictions]
+        )
+    
+    return iface
+
+# Launch the interface
+if __name__ == "__main__":
+    print("🚀 Starting Aircraft Classifier Gradio Interface...")
+    print(f"📱 Device: {device}")
+    print(f"🎯 Classes: {len(CLASS_NAMES)}")
+    
+    # Create and launch interface
+    iface = create_interface()
+    iface.launch(
+        share=True,  # Creates a public link
+        server_name="0.0.0.0",  # Allow external connections
+        server_port=7860,  # Default Gradio port
+        show_error=True
+    )

config.py

@@ -0,0 +1,39 @@
+# Aircraft Classifier Configuration
+
+# Model Configuration
+MODEL_NAME = "ResNet-18"
+NUM_CLASSES = 10
+MODEL_PATH = "models/aircraft_classifier.pth"
+
+# Class names for the 10 aircraft types
+CLASS_NAMES = [
+    '707-320',      # Boeing 707-320
+    '737-400',      # Boeing 737-400  
+    '767-300',      # Boeing 767-300
+    'DC-9-30',      # McDonnell Douglas DC-9-30
+    'DH-82',        # de Havilland DH.82 Tiger Moth
+    'Falcon_2000',  # Dassault Falcon 2000
+    'Il-76',        # Ilyushin Il-76
+    'MD-11',        # McDonnell Douglas MD-11
+    'Metroliner',   # Fairchild Metroliner
+    'PA-28'         # Piper PA-28
+]
+
+# Image preprocessing parameters
+IMAGE_SIZE = (224, 224)
+IMAGENET_MEAN = [0.485, 0.456, 0.406]
+IMAGENET_STD = [0.229, 0.224, 0.225]
+
+# Gradio interface settings
+GRADIO_PORT = 7860
+GRADIO_SHARE = True
+ALLOW_FLAGGING = False
+
+# Model performance metrics (from training)
+MODEL_METRICS = {
+    "test_accuracy": 0.8717,
+    "f1_score": 0.8737,
+    "training_accuracy": 1.0000,
+    "validation_accuracy": 0.8559,
+    "epochs_trained": 17
+}

model_utils.py

@@ -0,0 +1,33 @@
+import torch
+import torch.nn as nn
+from torchvision import models
+import os
+
+class AircraftClassifier(nn.Module):
+    """ResNet-18 based aircraft classifier"""
+    def __init__(self, num_classes=10):
+        super(AircraftClassifier, self).__init__()
+        # Load pre-trained ResNet-18
+        self.backbone = models.resnet18(pretrained=True)
+        # Replace the final fully connected layer
+        num_features = self.backbone.fc.in_features
+        self.backbone.fc = nn.Linear(num_features, num_classes)
+    
+    def forward(self, x):
+        return self.backbone(x)
+
+def save_model_checkpoint(model, filepath):
+    """Save model state dict to file"""
+    os.makedirs(os.path.dirname(filepath), exist_ok=True)
+    torch.save(model.state_dict(), filepath)
+    print(f"Model saved to {filepath}")
+
+def load_model_checkpoint(filepath, num_classes=10, device='cpu'):
+    """Load model from checkpoint"""
+    model = AircraftClassifier(num_classes=num_classes)
+    if os.path.exists(filepath):
+        model.load_state_dict(torch.load(filepath, map_location=device))
+        print(f"Model loaded from {filepath}")
+    else:
+        print(f"Checkpoint file {filepath} not found")
+    return model

requirements.txt

@@ -0,0 +1,12 @@
+torch>=1.9.0
+torchvision>=0.10.0
+gradio>=3.0.0
+numpy>=1.21.0
+pillow>=8.3.0
+matplotlib>=3.4.0
+seaborn>=0.11.0
+scikit-learn>=1.0.0
+jupyter>=1.0.0
+notebook>=6.4.0
+tqdm>=4.62.0
+pandas>=1.3.0

setup.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+"""
+Setup script for Aircraft Classifier Gradio deployment
+"""
+import os
+import sys
+import subprocess
+import urllib.request
+from pathlib import Path
+
+def install_requirements():
+    """Install required packages"""
+    print("📦 Installing requirements...")
+    try:
+        subprocess.check_call([sys.executable, "-m", "pip", "install", "-r", "requirements.txt"])
+        print("✅ Requirements installed successfully")
+    except subprocess.CalledProcessError as e:
+        print(f"❌ Error installing requirements: {e}")
+        return False
+    return True
+
+def create_models_directory():
+    """Create models directory if it doesn't exist"""
+    models_dir = Path("models")
+    models_dir.mkdir(exist_ok=True)
+    print(f"📁 Models directory created: {models_dir}")
+
+def download_sample_model():
+    """Download or create a placeholder model file"""
+    model_path = Path("models/aircraft_classifier.pth")
+    
+    if not model_path.exists():
+        print("⚠️ No trained model found.")
+        print("💡 To use the classifier, you need to:")
+        print("   1. Run the training notebook: aircraft_classifier.ipynb")
+        print("   2. Save the trained model to: models/aircraft_classifier.pth")
+        print("   3. Or the app will use random weights (for demo purposes)")
+
+def check_system():
+    """Check system requirements"""
+    print("🔍 Checking system requirements...")
+    
+    # Check Python version
+    if sys.version_info < (3, 8):
+        print("❌ Python 3.8+ is required")
+        return False
+    
+    print(f"✅ Python {sys.version.split()[0]}")
+    
+    # Check if CUDA is available
+    try:
+        import torch
+        if torch.cuda.is_available():
+            print(f"✅ CUDA available: {torch.cuda.get_device_name(0)}")
+        else:
+            print("⚠️ CUDA not available, using CPU")
+    except ImportError:
+        print("⚠️ PyTorch not installed yet")
+    
+    return True
+
+def main():
+    """Main setup function"""
+    print("🛩️ Aircraft Classifier - Setup Script")
+    print("=" * 50)
+    
+    # Check system requirements
+    if not check_system():
+        sys.exit(1)
+    
+    # Install requirements
+    if not install_requirements():
+        sys.exit(1)
+    
+    # Create necessary directories
+    create_models_directory()
+    
+    # Check for model file
+    download_sample_model()
+    
+    print("\n🎉 Setup complete!")
+    print("\n🚀 To start the Gradio interface:")
+    print("   python app.py")
+    print("\n📚 To train the model:")
+    print("   jupyter notebook aircraft_classifier.ipynb")
+
+if __name__ == "__main__":
+    main()

test_app.py

@@ -0,0 +1,68 @@
+#!/usr/bin/env python3
+"""
+Test script to verify the Aircraft Classifier Gradio app functionality
+"""
+import torch
+import numpy as np
+from PIL import Image
+import sys
+import os
+
+# Add current directory to path
+sys.path.append('.')
+
+def test_app_functionality():
+    """Test that the app components work correctly"""
+    print("🧪 Testing Aircraft Classifier App Components")
+    print("=" * 50)
+    
+    try:
+        # Import app components
+        from app import AircraftClassifier, classify_aircraft, get_top_predictions, CLASS_NAMES
+        from config import MODEL_METRICS
+        
+        print("✅ Successfully imported app components")
+        
+        # Test model creation
+        model = AircraftClassifier(num_classes=len(CLASS_NAMES))
+        print(f"✅ Model created: {model.__class__.__name__}")
+        print(f"   Classes: {len(CLASS_NAMES)}")
+        
+        # Create a dummy test image (random noise)
+        test_image = Image.fromarray(np.random.randint(0, 255, (224, 224, 3), dtype=np.uint8))
+        print("✅ Created test image")
+        
+        # Test classification function
+        results = classify_aircraft(test_image)
+        print("✅ Classification function works")
+        print(f"   Got {len(results)} class predictions")
+        
+        # Test top predictions function
+        top_preds = get_top_predictions(test_image)
+        print("✅ Top predictions function works")
+        print("   Sample output:")
+        print(f"   {top_preds[:100]}...")
+        
+        # Display model metrics
+        print(f"\n📊 Model Performance (from config):")
+        for metric, value in MODEL_METRICS.items():
+            print(f"   {metric}: {value}")
+        
+        print(f"\n🛩️ Aircraft Classes:")
+        for i, class_name in enumerate(CLASS_NAMES):
+            print(f"   {i+1:2d}. {class_name}")
+        
+        print(f"\n🎉 All tests passed! The Gradio app is ready to deploy.")
+        print(f"💡 To launch the interface, run: python app.py")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    success = test_app_functionality()
+    sys.exit(0 if success else 1)