Rename app.py to Satellite Classification Streamlit app.py

Satellite Classification Streamlit app.py

@@ -0,0 +1,600 @@
+import streamlit as st
+import tensorflow as tf
+import numpy as np
+import pandas as pd
+import plotly.express as px
+import plotly.graph_objects as go
+from plotly.subplots import make_subplots
+from PIL import Image
+import requests
+import io
+from datetime import datetime
+import time
+
+# Configure page
+st.set_page_config(
+    page_title="Satellite Classification Dashboard",
+    page_icon="🛰️",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better styling
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 3rem;
+        font-weight: bold;
+        text-align: center;
+        color: #1f77b4;
+        margin-bottom: 2rem;
+    }
+    .model-card {
+        background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+        padding: 20px;
+        border-radius: 10px;
+        margin: 10px 0;
+        color: white;
+    }
+    .metric-card {
+        background: #f8f9fa;
+        padding: 15px;
+        border-radius: 8px;
+        border-left: 4px solid #1f77b4;
+        margin: 5px 0;
+    }
+    .prediction-box {
+        background: linear-gradient(135deg, #ff7e5f 0%, #feb47b 100%);
+        padding: 20px;
+        border-radius: 10px;
+        text-align: center;
+        color: white;
+        font-size: 1.2rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# 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",
+        "description": "Custom CNN architecture designed for satellite classification",
+        "input_shape": (224, 224, 3),
+        "strengths": ["Good generalization", "Balanced performance", "Stable training"],
+        "best_for": ["General purpose", "Balanced datasets", "When interpretability matters"]
+    },
+    "MobileNetV2": {
+        "url": "https://huggingface.co/Bhavi23/MobilenetV2/resolve/main/multi_input_model_v1.keras",
+        "description": "Lightweight model optimized for mobile deployment",
+        "input_shape": (224, 224, 3),
+        "strengths": ["Fast inference", "Small model size", "Energy efficient"],
+        "best_for": ["Real-time applications", "Mobile devices", "Resource constraints"]
+    },
+    "EfficientNetB0": {
+        "url": "https://huggingface.co/Bhavi23/EfficientNet_B0/resolve/main/efficientnet_model.keras",
+        "description": "Balanced efficiency and accuracy with compound scaling",
+        "input_shape": (224, 224, 3),
+        "strengths": ["High accuracy", "Parameter efficient", "Good transfer learning"],
+        "best_for": ["High accuracy needs", "Limited data", "Transfer learning scenarios"]
+    },
+    "DenseNet121": {
+        "url": "https://huggingface.co/Bhavi23/DenseNet/resolve/main/densenet_model.keras",
+        "description": "Dense connections for feature reuse and gradient flow",
+        "input_shape": (224, 224, 3),
+        "strengths": ["Feature reuse", "Good gradient flow", "Parameter efficiency"],
+        "best_for": ["Complex patterns", "Feature-rich images", "When accuracy is priority"]
+    }
+}
+
+# Performance metrics (based on the results shown in your document)
+MODEL_METRICS = {
+    "Custom CNN": {
+        "accuracy": 95.2,
+        "precision": 94.8,
+        "recall": 95.1,
+        "f1_score": 94.9,
+        "inference_time": 45,  # ms
+        "model_size": 25.3,    # MB
+        "training_time": 120   # minutes
+    },
+    "MobileNetV2": {
+        "accuracy": 92.8,
+        "precision": 92.1,
+        "recall": 92.5,
+        "f1_score": 92.3,
+        "inference_time": 18,  # ms
+        "model_size": 8.7,     # MB
+        "training_time": 95    # minutes
+    },
+    "EfficientNetB0": {
+        "accuracy": 96.4,
+        "precision": 96.1,
+        "recall": 96.2,
+        "f1_score": 96.1,
+        "inference_time": 35,  # ms
+        "model_size": 20.1,    # MB
+        "training_time": 140   # minutes
+    },
+    "DenseNet121": {
+        "accuracy": 94.7,
+        "precision": 94.2,
+        "recall": 94.5,
+        "f1_score": 94.3,
+        "inference_time": 52,  # ms
+        "model_size": 32.8,    # MB
+        "training_time": 160   # minutes
+    }
+}
+
+@st.cache_resource
+def load_model(model_name):
+    """Load model from HuggingFace with caching"""
+    try:
+        with st.spinner(f'Loading {model_name}...'):
+            url = MODEL_CONFIGS[model_name]["url"]
+            response = requests.get(url)
+            response.raise_for_status()
+            
+            model_bytes = io.BytesIO(response.content)
+            model = tf.keras.models.load_model(model_bytes)
+            return model
+    except Exception as e:
+        st.error(f"Error loading {model_name}: {str(e)}")
+        return None
+
+def preprocess_image(image, target_size=(224, 224)):
+    """Preprocess image for model prediction"""
+    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)
+
+def predict_with_model(model, image, model_name):
+    """Make prediction with a specific model"""
+    try:
+        start_time = time.time()
+        predictions = model.predict(image, verbose=0)
+        inference_time = (time.time() - start_time) * 1000  # Convert to ms
+        
+        predicted_class = np.argmax(predictions[0])
+        confidence = np.max(predictions[0]) * 100
+        
+        return {
+            'class': predicted_class,
+            'class_name': CLASS_NAMES[predicted_class],
+            'confidence': confidence,
+            'inference_time': inference_time,
+            'probabilities': predictions[0]
+        }
+    except Exception as e:
+        st.error(f"Prediction error with {model_name}: {str(e)}")
+        return None
+
+def recommend_best_model(image_predictions):
+    """Recommend the best model based on predictions and confidence"""
+    if not image_predictions:
+        return "EfficientNetB0"  # Default recommendation
+    
+    # Calculate recommendation score based on confidence and model performance
+    recommendations = {}
+    for model_name, pred in image_predictions.items():
+        if pred:
+            # Combine confidence with model's overall accuracy
+            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
+    
+    if recommendations:
+        best_model = max(recommendations, key=recommendations.get)
+        return best_model
+    return "EfficientNetB0"
+
+def create_metrics_comparison():
+    """Create comprehensive metrics comparison dashboard"""
+    
+    # Create subplots
+    fig = make_subplots(
+        rows=2, cols=2,
+        subplot_titles=('Accuracy Comparison', 'Model Size vs Inference Time', 
+                       'Performance Metrics Radar', 'Training Efficiency'),
+        specs=[[{"type": "bar"}, {"type": "scatter"}],
+               [{"type": "scatterpolar"}, {"type": "bar"}]]
+    )
+    
+    models = list(MODEL_METRICS.keys())
+    
+    # 1. Accuracy Comparison Bar Chart
+    accuracies = [MODEL_METRICS[model]["accuracy"] for model in models]
+    fig.add_trace(
+        go.Bar(x=models, y=accuracies, name="Accuracy", 
+               marker_color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']),
+        row=1, col=1
+    )
+    
+    # 2. Model Size vs Inference Time Scatter
+    sizes = [MODEL_METRICS[model]["model_size"] for model in models]
+    times = [MODEL_METRICS[model]["inference_time"] for model in models]
+    fig.add_trace(
+        go.Scatter(x=sizes, y=times, mode='markers+text', 
+                   text=models, textposition="top center",
+                   marker=dict(size=15, color=['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728']),
+                   name="Size vs Speed"),
+        row=1, col=2
+    )
+    
+    # 3. Radar Chart for Performance Metrics
+    metrics = ['accuracy', 'precision', 'recall', 'f1_score']
+    for i, model in enumerate(models):
+        values = [MODEL_METRICS[model][metric] for metric in metrics]
+        fig.add_trace(
+            go.Scatterpolar(r=values, theta=metrics, fill='toself', 
+                           name=model, opacity=0.7),
+            row=2, col=1
+        )
+    
+    # 4. Training Time Comparison
+    training_times = [MODEL_METRICS[model]["training_time"] for model in models]
+    fig.add_trace(
+        go.Bar(x=models, y=training_times, name="Training Time",
+               marker_color=['#9467bd', '#8c564b', '#e377c2', '#7f7f7f']),
+        row=2, col=2
+    )
+    
+    # Update layout
+    fig.update_layout(height=800, showlegend=True, 
+                     title_text="Comprehensive Model Comparison Dashboard")
+    fig.update_xaxes(title_text="Models", row=1, col=1)
+    fig.update_yaxes(title_text="Accuracy (%)", row=1, col=1)
+    fig.update_xaxes(title_text="Model Size (MB)", row=1, col=2)
+    fig.update_yaxes(title_text="Inference Time (ms)", row=1, col=2)
+    fig.update_xaxes(title_text="Models", row=2, col=2)
+    fig.update_yaxes(title_text="Training Time (minutes)", row=2, col=2)
+    
+    return fig
+
+def create_class_distribution_chart():
+    """Create class distribution visualization"""
+    classes = list(CLASS_NAMES.values())
+    samples = [7500 if cls != 'Debris' else 15000 for cls in classes]
+    percentages = [8.33 if cls != 'Debris' else 16.67 for cls in classes]
+    
+    fig = go.Figure()
+    fig.add_trace(go.Bar(
+        x=classes,
+        y=samples,
+        text=[f'{s} ({p}%)' for s, p in zip(samples, percentages)],
+        textposition='auto',
+        marker_color=['#ff6b6b' if cls == 'Debris' else '#4ecdc4' for cls in classes]
+    ))
+    
+    fig.update_layout(
+        title="Class Distribution in Training Dataset",
+        xaxis_title="Satellite Classes",
+        yaxis_title="Number of Samples",
+        height=400
+    )
+    
+    return fig
+
+# Main App
+def main():
+    # Header
+    st.markdown('<h1 class="main-header">🛰️ Satellite Classification Dashboard</h1>', 
+                unsafe_allow_html=True)
+    
+    # Sidebar
+    st.sidebar.title("Navigation")
+    page = st.sidebar.selectbox("Choose a page", 
+                               ["🏠 Home", "📊 Model Comparison", "🔍 Image Classification", 
+                                "📈 Performance Analytics", "ℹ️ About Models"])
+    
+    if page == "🏠 Home":
+        st.markdown("## Welcome to the Satellite Classification System")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("### 🎯 System Overview")
+            st.write("""
+            This dashboard provides comprehensive satellite classification using 4 different
+            deep learning models. Upload satellite images to classify them into 11 different
+            categories including various satellites and space debris.
+            """)
+            
+            st.markdown("### 🛰️ Supported Classes")
+            for i, (class_id, class_name) in enumerate(CLASS_NAMES.items()):
+                if i < 6:  # First column
+                    st.write(f"• **{class_name}**")
+        
+        with col2:
+            st.markdown("### 🤖 Available Models")
+            st.write("""
+            - **Custom CNN**: Tailored architecture for satellite imagery
+            - **MobileNetV2**: Lightweight and fast inference
+            - **EfficientNetB0**: Best accuracy-efficiency balance
+            - **DenseNet121**: Complex pattern recognition
+            """)
+            
+            st.markdown("### 📊 Class Distribution")
+            for i, (class_id, class_name) in enumerate(CLASS_NAMES.items()):
+                if i >= 6:  # Second column
+                    st.write(f"• **{class_name}**")
+        
+        # Class distribution chart
+        st.plotly_chart(create_class_distribution_chart(), use_container_width=True)
+    
+    elif page == "📊 Model Comparison":
+        st.markdown("## 📊 Model Performance Comparison")
+        
+        # Metrics table
+        st.markdown("### Performance Metrics Summary")
+        df_metrics = pd.DataFrame(MODEL_METRICS).T
+        st.dataframe(df_metrics.style.highlight_max(axis=0), use_container_width=True)
+        
+        # Comprehensive comparison chart
+        st.plotly_chart(create_metrics_comparison(), use_container_width=True)
+        
+        # Model recommendations
+        st.markdown("### 🎯 Model Selection Guide")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.markdown("#### 🏆 Best for Accuracy")
+            st.success("**EfficientNetB0** - 96.4% accuracy")
+            
+            st.markdown("#### ⚡ Best for Speed")
+            st.info("**MobileNetV2** - 18ms inference time")
+        
+        with col2:
+            st.markdown("#### 💾 Most Lightweight")
+            st.info("**MobileNetV2** - 8.7MB model size")
+            
+            st.markdown("#### 🎯 Best Overall Balance")
+            st.warning("**EfficientNetB0** - High accuracy + efficiency")
+    
+    elif page == "🔍 Image Classification":
+        st.markdown("## 🔍 Image Classification")
+        
+        uploaded_file = st.file_uploader(
+            "Upload a satellite image", 
+            type=['png', 'jpg', 'jpeg'],
+            help="Upload an image of a satellite or space object for classification"
+        )
+        
+        if uploaded_file is not None:
+            # Display uploaded image
+            image = Image.open(uploaded_file)
+            
+            col1, col2 = st.columns([1, 2])
+            
+            with col1:
+                st.image(image, caption="Uploaded Image", use_container_width=True)
+            
+            with col2:
+                st.markdown("### Image Details")
+                st.write(f"**Filename:** {uploaded_file.name}")
+                st.write(f"**Size:** {image.size}")
+                st.write(f"**Mode:** {image.mode}")
+            
+            # Model selection
+            selected_models = st.multiselect(
+                "Select models for prediction",
+                list(MODEL_CONFIGS.keys()),
+                default=["EfficientNetB0", "Custom CNN"]
+            )
+            
+            if st.button("🚀 Classify Image", type="primary"):
+                if not selected_models:
+                    st.warning("Please select at least one model.")
+                    return
+                
+                # Preprocess image
+                processed_image = preprocess_image(image)
+                
+                # Store predictions
+                predictions = {}
+                
+                # Create progress bar
+                progress_bar = st.progress(0)
+                status_text = st.empty()
+                
+                # Make predictions with selected models
+                for i, model_name in enumerate(selected_models):
+                    status_text.text(f'Loading {model_name}...')
+                    model = load_model(model_name)
+                    
+                    if model:
+                        status_text.text(f'Predicting with {model_name}...')
+                        pred = predict_with_model(model, processed_image, model_name)
+                        predictions[model_name] = pred
+                    
+                    progress_bar.progress((i + 1) / len(selected_models))
+                
+                status_text.empty()
+                progress_bar.empty()
+                
+                # Display results
+                if predictions:
+                    # Get recommendation
+                    recommended_model = recommend_best_model(predictions)
+                    
+                    st.markdown("### 🎯 Prediction Results")
+                    
+                    # Show recommendation
+                    st.markdown(f"""
+                    <div class="prediction-box">
+                        <h3>🏆 Recommended Model: {recommended_model}</h3>
+                        <p>Based on confidence and model performance</p>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    # Results table
+                    results_data = []
+                    for model_name, pred in predictions.items():
+                        if 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}",
+                                'Recommended': '🏆' if model_name == recommended_model else ''
+                            })
+                    
+                    if results_data:
+                        df_results = pd.DataFrame(results_data)
+                        st.dataframe(df_results, use_container_width=True)
+                        
+                        # Confidence comparison
+                        st.markdown("### 📊 Confidence Comparison")
+                        confidences = [pred['confidence'] for pred in predictions.values() if pred]
+                        model_names = [name for name, pred in predictions.items() if pred]
+                        
+                        fig_conf = go.Figure()
+                        fig_conf.add_trace(go.Bar(
+                            x=model_names,
+                            y=confidences,
+                            marker_color=['gold' if name == recommended_model else 'lightblue' 
+                                        for name in model_names]
+                        ))
+                        fig_conf.update_layout(
+                            title="Prediction Confidence by Model",
+                            xaxis_title="Models",
+                            yaxis_title="Confidence (%)",
+                            height=400
+                        )
+                        st.plotly_chart(fig_conf, use_container_width=True)
+                        
+                        # Probability distribution for recommended model
+                        if recommended_model in predictions and predictions[recommended_model]:
+                            st.markdown(f"### 🔍 Detailed Probabilities - {recommended_model}")
+                            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)
+                            
+                            fig_prob = px.bar(
+                                prob_df.head(5), 
+                                x='Probability', 
+                                y='Class',
+                                orientation='h',
+                                title=f"Top 5 Class Probabilities - {recommended_model}"
+                            )
+                            st.plotly_chart(fig_prob, use_container_width=True)
+    
+    elif page == "📈 Performance Analytics":
+        st.markdown("## 📈 Performance Analytics")
+        
+        # Performance overview
+        col1, col2, col3, col4 = st.columns(4)
+        
+        with col1:
+            st.metric("Best Accuracy", "96.4%", "EfficientNetB0")
+        with col2:
+            st.metric("Fastest Inference", "18ms", "MobileNetV2")
+        with col3:
+            st.metric("Smallest Model", "8.7MB", "MobileNetV2")
+        with col4:
+            st.metric("Total Classes", "11", "Satellites + Debris")
+        
+        # Detailed analytics
+        tab1, tab2, tab3 = st.tabs(["Accuracy Analysis", "Efficiency Metrics", "Model Comparison"])
+        
+        with tab1:
+            # Accuracy breakdown
+            models = list(MODEL_METRICS.keys())
+            metrics_list = ['accuracy', 'precision', 'recall', 'f1_score']
+            
+            for metric in metrics_list:
+                values = [MODEL_METRICS[model][metric] for model in models]
+                fig = go.Figure()
+                fig.add_trace(go.Bar(x=models, y=values, name=metric.title()))
+                fig.update_layout(title=f"{metric.title()} Comparison", height=300)
+                st.plotly_chart(fig, use_container_width=True)
+        
+        with tab2:
+            # Efficiency metrics
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                # Inference time
+                times = [MODEL_METRICS[model]["inference_time"] for model in models]
+                fig_time = go.Figure()
+                fig_time.add_trace(go.Bar(x=models, y=times, 
+                                        marker_color=['red' if t > 40 else 'green' for t in times]))
+                fig_time.update_layout(title="Inference Time (ms)", height=400)
+                st.plotly_chart(fig_time, use_container_width=True)
+            
+            with col2:
+                # Model size
+                sizes = [MODEL_METRICS[model]["model_size"] for model in models]
+                fig_size = go.Figure()
+                fig_size.add_trace(go.Bar(x=models, y=sizes,
+                                        marker_color=['red' if s > 25 else 'green' for s in sizes]))
+                fig_size.update_layout(title="Model Size (MB)", height=400)
+                st.plotly_chart(fig_size, use_container_width=True)
+        
+        with tab3:
+            # Side-by-side comparison
+            comparison_data = []
+            for model in models:
+                metrics = MODEL_METRICS[model]
+                comparison_data.append({
+                    'Model': model,
+                    'Accuracy (%)': metrics['accuracy'],
+                    'Inference Time (ms)': metrics['inference_time'],
+                    'Model Size (MB)': metrics['model_size'],
+                    'Training Time (min)': metrics['training_time'],
+                    'Efficiency Score': round(metrics['accuracy'] / (metrics['inference_time'] * 0.1 + metrics['model_size'] * 0.1), 2)
+                })
+            
+            df_comparison = pd.DataFrame(comparison_data)
+            st.dataframe(df_comparison.style.highlight_max(axis=0, subset=['Accuracy (%)', 'Efficiency Score'])
+                                          .highlight_min(axis=0, subset=['Inference Time (ms)', 'Model Size (MB)', 'Training Time (min)']), 
+                        use_container_width=True)
+    
+    elif page == "ℹ️ About Models":
+        st.markdown("## ℹ️ Model Information")
+        
+        for model_name, config in MODEL_CONFIGS.items():
+            with st.expander(f"📋 {model_name}", expanded=False):
+                col1, col2 = st.columns(2)
+                
+                with col1:
+                    st.markdown("### Description")
+                    st.write(config["description"])
+                    
+                    st.markdown("### Input Shape")
+                    st.code(f"{config['input_shape']}")
+                    
+                    st.markdown("### Model URL")
+                    st.code(config["url"])
+                
+                with col2:
+                    st.markdown("### Strengths")
+                    for strength in config["strengths"]:
+                        st.write(f"• {strength}")
+                    
+                    st.markdown("### Best Use Cases")
+                    for use_case in config["best_for"]:
+                        st.write(f"• {use_case}")
+                    
+                    # Performance summary
+                    metrics = MODEL_METRICS[model_name]
+                    st.markdown("### Key Metrics")
+                    st.write(f"**Accuracy:** {metrics['accuracy']}%")
+                    st.write(f"**Inference Time:** {metrics['inference_time']}ms")
+                    st.write(f"**Model Size:** {metrics['model_size']}MB")
+
+if __name__ == "__main__":
+    main()

app.py

@@ -1,241 +0,0 @@
-import streamlit as st
-import tensorflow as tf
-import numpy as np
-from PIL import Image
-import pandas as pd
-import matplotlib.pyplot as plt
-import plotly.express as px
-
-# Configure page
-st.set_page_config(
-    page_title="ML Model Demo",
-    page_icon="🤖",
-    layout="wide"
-)
-
-@st.cache_resource
-def load_model():
-    """Load your model (cached to avoid reloading)"""
-    try:
-        # Replace this with your actual model loading
-        # Example: model = tf.keras.models.load_model('path/to/your/model.h5')
-        
-        # For demonstration, we'll create a simple model
-        model = tf.keras.Sequential([
-            tf.keras.layers.Dense(64, activation='relu', input_shape=(4,)),
-            tf.keras.layers.Dense(32, activation='relu'),
-            tf.keras.layers.Dense(3, activation='softmax')
-        ])
-        
-        st.success("✅ Model loaded successfully!")
-        return model
-        
-    except Exception as e:
-        st.error(f"❌ Error loading model: {str(e)}")
-        return None
-
-def preprocess_image(image):
-    """Preprocess image for model input"""
-    # Resize image to expected dimensions
-    image = image.resize((224, 224))
-    # Convert to array and normalize
-    image_array = np.array(image) / 255.0
-    # Add batch dimension
-    return np.expand_dims(image_array, axis=0)
-
-def make_prediction(model, input_data, input_type):
-    """Make prediction with the model"""
-    if model is None:
-        return "❌ Model not available"
-    
-    try:
-        if input_type == "image":
-            # Process image prediction
-            processed_input = preprocess_image(input_data)
-            # Mock prediction for demo
-            prediction = np.random.rand(1, 3)
-            classes = ['Class A', 'Class B', 'Class C']
-            predicted_class = classes[np.argmax(prediction)]
-            confidence = np.max(prediction) * 100
-            
-            return {
-                'predicted_class': predicted_class,
-                'confidence': confidence,
-                'all_predictions': dict(zip(classes, prediction[0]))
-            }
-            
-        elif input_type == "numeric":
-            # Process numeric prediction
-            prediction = model.predict(input_data.reshape(1, -1))
-            predicted_class = f"Class {np.argmax(prediction[0])}"
-            confidence = np.max(prediction[0]) * 100
-            
-            return {
-                'predicted_class': predicted_class,
-                'confidence': confidence,
-                'raw_output': prediction[0].tolist()
-            }
-            
-        elif input_type == "text":
-            # Mock text processing
-            return {
-                'sentiment': 'Positive',
-                'confidence': 85.6,
-                'keywords': ['example', 'text', 'analysis']
-            }
-            
-    except Exception as e:
-        return f"❌ Prediction error: {str(e)}"
-
-def main():
-    # Header
-    st.title("🤖 Machine Learning Model Demo")
-    st.markdown("---")
-    
-    # Sidebar
-    st.sidebar.header("🎛️ Model Controls")
-    
-    # Load model
-    with st.spinner("Loading model..."):
-        model = load_model()
-    
-    # Model selection
-    model_type = st.sidebar.selectbox(
-        "Select Model Type:",
-        ["Image Classification", "Numeric Prediction", "Text Analysis"]
-    )
-    
-    # Main content area
-    col1, col2 = st.columns([2, 1])
-    
-    with col1:
-        if model_type == "Image Classification":
-            st.subheader("📸 Image Classification")
-            
-            uploaded_file = st.file_uploader(
-                "Upload an image:",
-                type=['jpg', 'jpeg', 'png', 'bmp'],
-                help="Supported formats: JPG, JPEG, PNG, BMP"
-            )
-            
-            if uploaded_file is not None:
-                # Display uploaded image
-                image = Image.open(uploaded_file)
-                st.image(image, caption="Uploaded Image", use_column_width=True)
-                
-                # Prediction button
-                if st.button("🔍 Classify Image", type="primary"):
-                    with st.spinner("Analyzing image..."):
-                        result = make_prediction(model, image, "image")
-                    
-                    if isinstance(result, dict):
-                        st.success(f"**Prediction:** {result['predicted_class']}")
-                        st.info(f"**Confidence:** {result['confidence']:.1f}%")
-                        
-                        # Show all predictions
-                        st.subheader("All Predictions:")
-                        for class_name, prob in result['all_predictions'].items():
-                            st.write(f"• {class_name}: {prob*100:.1f}%")
-                    else:
-                        st.error(result)
-        
-        elif model_type == "Numeric Prediction":
-            st.subheader("🔢 Numeric Prediction")
-            
-            # Input parameters
-            col_a, col_b = st.columns(2)
-            
-            with col_a:
-                param1 = st.number_input("Parameter 1:", value=5.0, step=0.1)
-                param2 = st.number_input("Parameter 2:", value=3.2, step=0.1)
-            
-            with col_b:
-                param3 = st.number_input("Parameter 3:", value=1.4, step=0.1)
-                param4 = st.number_input("Parameter 4:", value=0.2, step=0.1)
-            
-            # Create input array
-            input_array = np.array([param1, param2, param3, param4])
-            
-            if st.button("🚀 Make Prediction", type="primary"):
-                with st.spinner("Computing prediction..."):
-                    result = make_prediction(model, input_array, "numeric")
-                
-                if isinstance(result, dict):
-                    st.success(f"**Prediction:** {result['predicted_class']}")
-                    st.info(f"**Confidence:** {result['confidence']:.1f}%")
-                    
-                    # Visualization
-                    fig, ax = plt.subplots()
-                    ax.bar(range(len(result['raw_output'])), result['raw_output'])
-                    ax.set_xlabel('Class')
-                    ax.set_ylabel('Probability')
-                    ax.set_title('Prediction Probabilities')
-                    st.pyplot(fig)
-                else:
-                    st.error(result)
-        
-        elif model_type == "Text Analysis":
-            st.subheader("📝 Text Analysis")
-            
-            text_input = st.text_area(
-                "Enter your text:",
-                placeholder="Type your text here for analysis...",
-                height=150
-            )
-            
-            if st.button("📊 Analyze Text", type="primary") and text_input.strip():
-                with st.spinner("Analyzing text..."):
-                    result = make_prediction(model, text_input, "text")
-                
-                if isinstance(result, dict):
-                    st.success(f"**Sentiment:** {result['sentiment']}")
-                    st.info(f"**Confidence:** {result['confidence']:.1f}%")
-                    
-                    st.subheader("Keywords:")
-                    for keyword in result['keywords']:
-                        st.write(f"• {keyword}")
-                else:
-                    st.error(result)
-    
-    with col2:
-        st.subheader("📊 Model Info")
-        
-        # Model statistics (mock data)
-        metrics = {
-            'Accuracy': 94.2,
-            'Precision': 91.8,
-            'Recall': 93.5,
-            'F1-Score': 92.6
-        }
-        
-        for metric, value in metrics.items():
-            st.metric(metric, f"{value}%")
-        
-        # Additional info
-        st.markdown("---")
-        st.subheader("ℹ️ About")
-        st.info("""
-        **Model Details:**
-        - Framework: TensorFlow 2.13
-        - Architecture: Deep Neural Network
-        - Training Data: Custom dataset
-        - Last Updated: July 2025
-        """)
-        
-        # Usage stats (mock)
-        st.markdown("---")
-        st.subheader("📈 Usage Stats")
-        usage_data = pd.DataFrame({
-            'Day': ['Mon', 'Tue', 'Wed', 'Thu', 'Fri'],
-            'Predictions': [45, 52, 38, 61, 49]
-        })
-        
-        fig = px.bar(usage_data, x='Day', y='Predictions', title='Daily Predictions')
-        st.plotly_chart(fig, use_container_width=True)
-    
-    # Footer
-    st.markdown("---")
-    st.markdown("Built with ❤️ using Streamlit and TensorFlow")
-
-if __name__ == "__main__":
-    main()