Create app.py

app.py

@@ -0,0 +1,242 @@
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from PIL import Image
+import requests
+import io
+import logging
+import time
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Class mappings
+CLASS_NAMES = {
+    0: 'AcrimSat', 1: 'Aquarius', 2: 'Aura', 3: 'Calipso', 4: 'Cloudsat',
+    5: 'CubeSat', 6: 'Debris', 7: 'Jason', 8: 'Sentinel-6', 9: 'TRMM', 10: 'Terra'
+}
+
+# Model configurations
+MODEL_CONFIGS = {
+    "Custom CNN": {
+        "url": "https://huggingface.co/Bhavi23/Custom_CNN/resolve/main/best_multimodal_model.keras",
+        "input_shape": (224, 224, 3)
+    },
+    "MobileNetV2": {
+        "url": "https://huggingface.co/Bhavi23/MobilenetV2/resolve/main/multi_input_model_v1.keras",
+        "input_shape": (224, 224, 3)
+    },
+    "EfficientNetB0": {
+        "url": "https://huggingface.co/Bhavi23/EfficientNet_B0/resolve/main/efficientnet_model.keras",
+        "input_shape": (224, 224, 3)
+    },
+    "DenseNet121": {
+        "url": "https://huggingface.co/Bhavi23/DenseNet/resolve/main/densenet_model.keras",
+        "input_shape": (224, 224, 3)
+    }
+}
+
+# Performance metrics (for recommendation logic)
+MODEL_METRICS = {
+    "Custom CNN": {"accuracy": 95.2, "inference_time": 45, "model_size": 25.3},
+    "MobileNetV2": {"accuracy": 92.8, "inference_time": 18, "model_size": 8.7},
+    "EfficientNetB0": {"accuracy": 96.4, "inference_time": 35, "model_size": 20.1},
+    "DenseNet121": {"accuracy": 94.7, "inference_time": 52, "model_size": 32.8}
+}
+
+def load_model(model_name):
+    """Load model from Hugging Face with error handling"""
+    try:
+        logger.info(f"Loading model: {model_name}")
+        url = MODEL_CONFIGS[model_name]["url"]
+        response = requests.get(url, timeout=60, stream=True)
+        response.raise_for_status()
+        if len(response.content) < 1000:
+            return None, f"Model {model_name} download failed - file too small"
+        model_bytes = io.BytesIO(response.content)
+        model = tf.keras.models.load_model(model_bytes)
+        logger.info(f"Successfully loaded model: {model_name}")
+        return model, None
+    except Exception as e:
+        logger.error(f"Error loading {model_name}: {str(e)}")
+        return None, f"Error loading {model_name}: {str(e)}"
+
+def preprocess_image(image, target_size=(224, 224)):
+    """Preprocess image for model prediction"""
+    try:
+        if image.mode != 'RGB':
+            image = image.convert('RGB')
+        image = image.resize(target_size)
+        image_array = np.array(image) / 255.0
+        return np.expand_dims(image_array, axis=0), None
+    except Exception as e:
+        return None, f"Error preprocessing image: {str(e)}"
+
+def predict_with_model(model, image, model_name):
+    """Make prediction with a specific model"""
+    if model is None:
+        return None
+    try:
+        start_time = time.time()
+        predictions = model.predict(image, verbose=0)
+        inference_time = (time.time() - start_time) * 1000
+        predicted_class = np.argmax(predictions[0])
+        confidence = np.max(predictions[0]) * 100
+        if predicted_class not in CLASS_NAMES:
+            return None
+        return {
+            'class': predicted_class,
+            'class_name': CLASS_NAMES[predicted_class],
+            'confidence': confidence,
+            'inference_time': inference_time,
+            'probabilities': predictions[0]
+        }
+    except Exception as e:
+        logger.error(f"Prediction error with {model_name}: {str(e)}")
+        return None
+
+def recommend_best_model(predictions):
+    """Recommend the best model based on confidence and performance"""
+    if not predictions:
+        return "EfficientNetB0"
+    recommendations = {}
+    for model_name, pred in predictions.items():
+        if pred:
+            base_score = MODEL_METRICS[model_name]["accuracy"]
+            confidence_bonus = pred['confidence'] * 0.1
+            speed_bonus = max(0, 100 - MODEL_METRICS[model_name]["inference_time"]) * 0.05
+            recommendations[model_name] = base_score + confidence_bonus + speed_bonus
+    return max(recommendations, key=recommendations.get) if recommendations else "EfficientNetB0"
+
+def create_confidence_plot(predictions):
+    """Create a bar plot for model confidence comparison"""
+    if not predictions:
+        return None
+    confidences = [pred['confidence'] for pred in predictions.values() if pred]
+    model_names = [name for name, pred in predictions.items() if pred]
+    recommended_model = recommend_best_model(predictions)
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=model_names,
+        y=confidences,
+        marker_color=['gold' if name == recommended_model else 'lightblue' for name in model_names],
+        text=[f'{c:.1f}%' for c in confidences],
+        textposition='auto'
+    ))
+    fig.update_layout(
+        title="Prediction Confidence by Model",
+        xaxis_title="Models",
+        yaxis_title="Confidence (%)",
+        height=400
+    )
+    return fig
+
+def create_probability_plot(predictions, recommended_model):
+    """Create a bar plot for top 5 class probabilities of the recommended model"""
+    if recommended_model not in predictions or not predictions[recommended_model]:
+        return None
+    probs = predictions[recommended_model]['probabilities']
+    prob_df = pd.DataFrame({
+        'Class': [CLASS_NAMES[i] for i in range(len(probs))],
+        'Probability': probs * 100
+    }).sort_values('Probability', ascending=False).head(5)
+    fig = px.bar(
+        prob_df,
+        x='Probability',
+        y='Class',
+        orientation='h',
+        title=f"Top 5 Class Probabilities - {recommended_model}",
+        color='Probability',
+        color_continuous_scale='viridis'
+    )
+    fig.update_layout(height=400)
+    return fig
+
+def classify_image(image, selected_models):
+    """Main function to classify an image and return results"""
+    if image is None:
+        return "Please upload an image.", None, None, None, None
+    if not selected_models:
+        return "Please select at least one model.", None, None, None, None
+
+    processed_image, error = preprocess_image(image)
+    if error:
+        return error, None, None, None, None
+
+    predictions = {}
+    results_data = []
+    for model_name in selected_models:
+        model, error = load_model(model_name)
+        if error:
+            results_data.append({'Model': model_name, 'Error': error})
+            continue
+        pred = predict_with_model(model, processed_image, model_name)
+        if pred:
+            predictions[model_name] = pred
+            results_data.append({
+                'Model': model_name,
+                'Predicted Class': pred['class_name'],
+                'Confidence (%)': f"{pred['confidence']:.1f}%",
+                'Inference Time (ms)': f"{pred['inference_time']:.1f}"
+            })
+        else:
+            results_data.append({'Model': model_name, 'Error': f"Prediction failed for {model_name}"})
+
+    recommended_model = recommend_best_model(predictions)
+    results_df = pd.DataFrame(results_data)
+    confidence_plot = create_confidence_plot(predictions)
+    probability_plot = create_probability_plot(predictions, recommended_model)
+
+    return (
+        f"**Recommended Model**: {recommended_model}",
+        results_df,
+        image,
+        confidence_plot,
+        probability_plot
+    )
+
+# Gradio interface
+with gr.Blocks(title="Satellite Classification Dashboard") as demo:
+    gr.Markdown("# 🛰️ Satellite Classification Dashboard")
+    gr.Markdown("Upload a satellite image and select models to classify it into one of 11 categories. View predictions, confidence scores, and visualizations.")
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            image_input = gr.Image(type="pil", label="Upload Satellite Image (PNG, JPG, JPEG)")
+            model_select = gr.Dropdown(
+                choices=list(MODEL_CONFIGS.keys()),
+                value=["EfficientNetB0"],
+                multiselect=True,
+                label="Select Models"
+            )
+            classify_button = gr.Button("Classify Image", variant="primary")
+        with gr.Column(scale=2):
+            output_text = gr.Markdown(label="Prediction Results")
+            output_table = gr.Dataframe(label="Prediction Details")
+            output_image = gr.Image(label="Uploaded Image")
+    
+    with gr.Row():
+        confidence_plot = gr.Plot(label="Confidence Comparison")
+        probability_plot = gr.Plot(label="Class Probabilities")
+
+    classify_button.click(
+        fn=classify_image,
+        inputs=[image_input, model_select],
+        outputs=[output_text, output_table, output_image, confidence_plot, probability_plot]
+    )
+
+    gr.Markdown("""
+    ### Supported Classes
+    - AcrimSat, Aquarius, Aura, Calipso, Cloudsat, CubeSat, Debris, Jason, Sentinel-6, TRMM, Terra
+    ### Available Models
+    - **Custom CNN**: Tailored for satellite imagery (95.2% accuracy)
+    - **MobileNetV2**: Lightweight and fast (92.8% accuracy, 18ms inference)
+    - **EfficientNetB0**: Best accuracy-efficiency balance (96.4% accuracy)
+    - **DenseNet121**: Complex pattern recognition (94.7% accuracy)
+    """)
+
+demo.launch()