Update app.py

app.py

@@ -11,7 +11,6 @@ from plotly.subplots import make_subplots
 import os
 
 # Load model artifacts
-@st.cache_resource
 def load_model_artifacts():
     try:
         # Load the trained model
@@ -30,14 +29,24 @@ def load_model_artifacts():
         raise Exception(f"Error loading model artifacts: {str(e)}")
 
 # Initialize model components
-model, scaler, metadata = load_model_artifacts()
-feature_names = metadata['feature_names']
+try:
+    model, scaler, metadata = load_model_artifacts()
+    feature_names = metadata['feature_names']
+    print(f"✅ Model loaded successfully with features: {feature_names}")
+except Exception as e:
+    print(f"❌ Error loading model: {e}")
+    # Fallback values for testing
+    model, scaler, metadata = None, None, {}
+    feature_names = ['Feature_1', 'Feature_2', 'Feature_3', 'Feature_4']
 
 def predict_student_eligibility(*args):
     """
     Predict student eligibility based on input features
     """
     try:
+        if model is None or scaler is None:
+            return "Model not loaded", "N/A", "N/A", create_error_plot()
+        
         # Create input dictionary from gradio inputs
         input_data = {feature_names[i]: args[i] for i in range(len(feature_names))}
         
@@ -51,7 +60,7 @@ def predict_student_eligibility(*args):
         input_reshaped = input_scaled.reshape(input_scaled.shape[0], input_scaled.shape[1], 1)
         
         # Make prediction
-        probability = model.predict(input_reshaped)[0][0]
+        probability = float(model.predict(input_reshaped)[0][0])
         prediction = "Eligible" if probability > 0.5 else "Not Eligible"
         confidence = abs(probability - 0.5) * 2  # Convert to confidence score
         
@@ -61,105 +70,139 @@ def predict_student_eligibility(*args):
         return prediction, f"{probability:.4f}", f"{confidence:.4f}", fig
         
     except Exception as e:
-        return f"Error: {str(e)}", "N/A", "N/A", None
+        return f"Error: {str(e)}", "N/A", "N/A", create_error_plot()
+
+def create_error_plot():
+    """Create a simple error plot"""
+    fig = go.Figure()
+    fig.add_annotation(
+        text="Model not available or error occurred",
+        xref="paper", yref="paper",
+        x=0.5, y=0.5, xanchor='center', yanchor='middle',
+        showarrow=False, font=dict(size=20)
+    )
+    fig.update_layout(
+        xaxis={'visible': False},
+        yaxis={'visible': False},
+        height=400
+    )
+    return fig
 
 def create_prediction_viz(probability, prediction, input_data):
     """
     Create visualization for prediction results
     """
-    # Create subplots
-    fig = make_subplots(
-        rows=2, cols=2,
-        subplot_titles=('Prediction Probability', 'Confidence Meter', 'Input Features', 'Feature Distribution'),
-        specs=[[{"type": "indicator"}, {"type": "indicator"}],
-               [{"type": "bar"}, {"type": "histogram"}]]
-    )
-    
-    # Prediction probability gauge
-    fig.add_trace(
-        go.Indicator(
-            mode="gauge+number+delta",
-            value=probability,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Eligibility Probability"},
-            gauge={
-                'axis': {'range': [None, 1]},
-                'bar': {'color': "darkblue"},
-                'steps': [
-                    {'range': [0, 0.5], 'color': "lightgray"},
-                    {'range': [0.5, 1], 'color': "lightgreen"}
-                ],
-                'threshold': {
-                    'line': {'color': "red", 'width': 4},
-                    'thickness': 0.75,
-                    'value': 0.5
+    try:
+        # Create subplots
+        fig = make_subplots(
+            rows=2, cols=2,
+            subplot_titles=('Prediction Probability', 'Confidence Meter', 'Input Features', 'Probability Distribution'),
+            specs=[[{"type": "indicator"}, {"type": "indicator"}],
+                   [{"type": "bar"}, {"type": "scatter"}]]
+        )
+        
+        # Prediction probability gauge
+        fig.add_trace(
+            go.Indicator(
+                mode="gauge+number",
+                value=probability,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                title={'text': "Eligibility Probability"},
+                gauge={
+                    'axis': {'range': [None, 1]},
+                    'bar': {'color': "darkblue"},
+                    'steps': [
+                        {'range': [0, 0.5], 'color': "lightcoral"},
+                        {'range': [0.5, 1], 'color': "lightgreen"}
+                    ],
+                    'threshold': {
+                        'line': {'color': "red", 'width': 4},
+                        'thickness': 0.75,
+                        'value': 0.5
+                    }
                 }
-            }
-        ),
-        row=1, col=1
-    )
-    
-    # Confidence meter
-    confidence = abs(probability - 0.5) * 2
-    fig.add_trace(
-        go.Indicator(
-            mode="gauge+number",
-            value=confidence,
-            domain={'x': [0, 1], 'y': [0, 1]},
-            title={'text': "Prediction Confidence"},
-            gauge={
-                'axis': {'range': [None, 1]},
-                'bar': {'color': "orange"},
-                'steps': [
-                    {'range': [0, 0.3], 'color': "lightcoral"},
-                    {'range': [0.3, 0.7], 'color': "lightyellow"},
-                    {'range': [0.7, 1], 'color': "lightgreen"}
-                ]
-            }
-        ),
-        row=1, col=2
-    )
-    
-    # Input features bar chart
-    features = list(input_data.keys())
-    values = list(input_data.values())
-    
-    fig.add_trace(
-        go.Bar(x=features, y=values, name="Input Values", marker_color="skyblue"),
-        row=2, col=1
-    )
-    
-    # Feature distribution (example data)
-    fig.add_trace(
-        go.Histogram(x=values, nbinsx=10, name="Distribution", marker_color="lightcoral"),
-        row=2, col=2
-    )
-    
-    fig.update_layout(
-        height=800,
-        showlegend=False,
-        title_text="Student Eligibility Prediction Dashboard",
-        title_x=0.5
-    )
-    
-    return fig
+            ),
+            row=1, col=1
+        )
+        
+        # Confidence meter
+        confidence = abs(probability - 0.5) * 2
+        fig.add_trace(
+            go.Indicator(
+                mode="gauge+number",
+                value=confidence,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                title={'text': "Prediction Confidence"},
+                gauge={
+                    'axis': {'range': [None, 1]},
+                    'bar': {'color': "orange"},
+                    'steps': [
+                        {'range': [0, 0.3], 'color': "lightcoral"},
+                        {'range': [0.3, 0.7], 'color': "lightyellow"},
+                        {'range': [0.7, 1], 'color': "lightgreen"}
+                    ]
+                }
+            ),
+            row=1, col=2
+        )
+        
+        # Input features bar chart
+        features = list(input_data.keys())
+        values = list(input_data.values())
+        
+        fig.add_trace(
+            go.Bar(x=features, y=values, name="Input Values", marker_color="skyblue"),
+            row=2, col=1
+        )
+        
+        # Simple probability visualization
+        fig.add_trace(
+            go.Scatter(
+                x=[0, 1], 
+                y=[probability, probability], 
+                mode='lines+markers',
+                name="Probability", 
+                line=dict(color="red", width=3),
+                marker=dict(size=10)
+            ),
+            row=2, col=2
+        )
+        
+        fig.update_layout(
+            height=800,
+            showlegend=False,
+            title_text="Student Eligibility Prediction Dashboard",
+            title_x=0.5
+        )
+        
+        return fig
+    except Exception as e:
+        return create_error_plot()
 
 def create_model_info():
     """
     Create model information display
     """
-    info_html = f"""
-    <div style="padding: 20px; background-color: #f0f2f6; border-radius: 10px; margin: 10px 0;">
-        <h3>🤖 Model Information</h3>
-        <ul>
-            <li><strong>Model Type:</strong> {metadata.get('model_type', 'CNN')}</li>
-            <li><strong>Test Accuracy:</strong> {metadata['performance_metrics']['test_accuracy']:.4f}</li>
-            <li><strong>AUC Score:</strong> {metadata['performance_metrics']['auc_score']:.4f}</li>
-            <li><strong>Creation Date:</strong> {metadata.get('creation_date', 'N/A')}</li>
-            <li><strong>Features:</strong> {len(feature_names)} input features</li>
-        </ul>
-    </div>
-    """
+    if metadata:
+        info_html = f"""
+        <div style="padding: 20px; background-color: #f0f2f6; border-radius: 10px; margin: 10px 0;">
+            <h3>🤖 Model Information</h3>
+            <ul>
+                <li><strong>Model Type:</strong> {metadata.get('model_type', 'CNN')}</li>
+                <li><strong>Test Accuracy:</strong> {metadata.get('performance_metrics', {}).get('test_accuracy', 'N/A')}</li>
+                <li><strong>AUC Score:</strong> {metadata.get('performance_metrics', {}).get('auc_score', 'N/A')}</li>
+                <li><strong>Creation Date:</strong> {metadata.get('creation_date', 'N/A')}</li>
+                <li><strong>Features:</strong> {len(feature_names)} input features</li>
+            </ul>
+        </div>
+        """
+    else:
+        info_html = """
+        <div style="padding: 20px; background-color: #ffebee; border-radius: 10px; margin: 10px 0;">
+            <h3>⚠️ Model Information</h3>
+            <p>Model artifacts not loaded. Please ensure all required files are uploaded.</p>
+        </div>
+        """
     return info_html
 
 def batch_predict(file):
@@ -167,6 +210,12 @@ def batch_predict(file):
     Batch prediction from uploaded CSV file
     """
     try:
+        if model is None or scaler is None:
+            return "Model not loaded. Please check if all model files are uploaded.", None
+        
+        if file is None:
+            return "Please upload a CSV file.", None
+        
         # Read the uploaded file
         df = pd.read_csv(file.name)
         
@@ -199,13 +248,19 @@ def batch_predict(file):
         results_df.to_csv(output_file, index=False)
         
         # Create summary statistics
-        summary = f"""
-        Batch Prediction Summary:
-        - Total predictions: {len(results_df)}
-        - Eligible: {sum(1 for p in predictions if p == 'Eligible')}
-        - Not Eligible: {sum(1 for p in predictions if p == 'Not Eligible')}
-        - Average Probability: {np.mean(probabilities):.4f}
-        - Average Confidence: {np.mean(np.abs(probabilities - 0.5) * 2):.4f}
+        eligible_count = sum(1 for p in predictions if p == 'Eligible')
+        not_eligible_count = len(predictions) - eligible_count
+        
+        summary = f"""Batch Prediction Summary:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+📊 Total predictions: {len(results_df)}
+✅ Eligible: {eligible_count} ({eligible_count/len(predictions)*100:.1f}%)
+❌ Not Eligible: {not_eligible_count} ({not_eligible_count/len(predictions)*100:.1f}%)
+📈 Average Probability: {np.mean(probabilities):.4f}
+🎯 Average Confidence: {np.mean(np.abs(probabilities - 0.5) * 2):.4f}
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+
+Results saved to: {output_file}
         """
         
         return summary, output_file
@@ -229,6 +284,9 @@ with gr.Blocks(
         border-radius: 10px;
         margin-bottom: 20px;
     }
+    .feature-input {
+        margin: 5px 0;
+    }
     """
 ) as demo:
     
@@ -242,66 +300,120 @@ with gr.Blocks(
     
     with gr.Tabs():
         # Single Prediction Tab
-        with gr.TabItem("Single Prediction"):
+        with gr.TabItem("🔮 Single Prediction"):
             gr.Markdown("### Enter student information to predict eligibility")
             
             with gr.Row():
                 with gr.Column(scale=1):
+                    gr.Markdown("#### Input Features")
                     # Create input components dynamically based on features
                     inputs = []
-                    for feature in feature_names:
+                    for i, feature in enumerate(feature_names):
                         inputs.append(
                             gr.Number(
-                                label=f"{feature}",
-                                value=85,  # Default value
+                                label=f"📊 {feature}",
+                                value=75 + i*5,  # Different default values
                                 minimum=0,
                                 maximum=100,
-                                step=1
+                                step=0.1,
+                                elem_classes=["feature-input"]
                             )
                         )
                     
-                    predict_btn = gr.Button("🔮 Predict Eligibility", variant="primary", size="lg")
+                    predict_btn = gr.Button(
+                        "🔮 Predict Eligibility", 
+                        variant="primary", 
+                        size="lg",
+                        elem_id="predict-btn"
+                    )
                 
                 with gr.Column(scale=2):
+                    gr.Markdown("#### Prediction Results")
                     with gr.Row():
-                        prediction_output = gr.Textbox(label="Prediction", scale=1)
-                        probability_output = gr.Textbox(label="Probability", scale=1)
-                        confidence_output = gr.Textbox(label="Confidence", scale=1)
+                        prediction_output = gr.Textbox(label="🎯 Prediction", scale=1)
+                        probability_output = gr.Textbox(label="📊 Probability", scale=1)
+                        confidence_output = gr.Textbox(label="🎯 Confidence", scale=1)
                     
-                    prediction_plot = gr.Plot(label="Prediction Visualization")
+                    prediction_plot = gr.Plot(label="📈 Prediction Visualization")
             
             # Model information
             gr.HTML(create_model_info())
         
         # Batch Prediction Tab
-        with gr.TabItem("Batch Prediction"):
+        with gr.TabItem("📊 Batch Prediction"):
             gr.Markdown("### Upload a CSV file for batch predictions")
-            gr.Markdown(f"**Required columns:** {', '.join(feature_names)}")
+            gr.Markdown(f"**Required columns:** `{', '.join(feature_names)}`")
+            
+            # Sample CSV format
+            gr.Markdown("""
+            **Example CSV format:**
+            ```csv
+            Feature_1,Feature_2,Feature_3,Feature_4
+            85,90,75,88
+            92,78,85,91
+            ```
+            """)
             
             with gr.Row():
                 with gr.Column():
                     file_input = gr.File(
-                        label="Upload CSV File",
+                        label="📁 Upload CSV File",
                         file_types=[".csv"],
                         type="file"
                     )
-                    batch_predict_btn = gr.Button("📊 Process Batch", variant="primary")
+                    batch_predict_btn = gr.Button(
+                        "📊 Process Batch", 
+                        variant="primary",
+                        size="lg"
+                    )
                 
                 with gr.Column():
-                    batch_output = gr.Textbox(label="Batch Results Summary", lines=10)
-                    download_file = gr.File(label="Download Results")
+                    batch_output = gr.Textbox(
+                        label="📋 Batch Results Summary", 
+                        lines=15,
+                        max_lines=20
+                    )
+                    download_file = gr.File(label="⬇️ Download Results")
         
         # Model Analytics Tab
-        with gr.TabItem("Model Analytics"):
+        with gr.TabItem("📈 Model Analytics"):
             gr.Markdown("### Model Performance Metrics")
             
-            # Performance metrics
-            metrics_df = pd.DataFrame([metadata['performance_metrics']])
-            gr.Dataframe(metrics_df, label="Performance Metrics")
+            if metadata and 'performance_metrics' in metadata:
+                # Performance metrics
+                metrics_data = metadata['performance_metrics']
+                metrics_df = pd.DataFrame([{
+                    'Metric': k.replace('_', ' ').title(),
+                    'Value': f"{v:.4f}" if isinstance(v, float) else str(v)
+                } for k, v in metrics_data.items()])
+                
+                gr.Dataframe(
+                    metrics_df, 
+                    label="🎯 Performance Metrics",
+                    headers=['Metric', 'Value']
+                )
+            else:
+                gr.Markdown("⚠️ **Performance metrics not available**")
+            
+            # Feature information
+            gr.Markdown("### 📊 Model Features")
+            feature_info = pd.DataFrame({
+                'Feature Name': feature_names,
+                'Index': range(len(feature_names)),
+                'Type': ['Numerical'] * len(feature_names)
+            })
+            gr.Dataframe(feature_info, label="Feature Information")
             
-            # Feature importance (placeholder - you'd need to calculate this)
-            gr.Markdown("### Feature Names")
-            gr.Textbox(value=", ".join(feature_names), label="Model Features", lines=3)
+            # Model architecture info
+            if metadata:
+                gr.Markdown("### 🏗️ Model Architecture")
+                arch_info = f"""
+                - **Model Type**: {metadata.get('model_type', 'CNN')}
+                - **Input Shape**: {metadata.get('input_shape', 'N/A')}
+                - **Total Features**: {len(feature_names)}
+                - **Output Classes**: {len(metadata.get('target_classes', {}))}
+                """
+                gr.Markdown(arch_info)
     
     # Event handlers
     predict_btn.click(
@@ -318,4 +430,8 @@ with gr.Blocks(
 
 # Launch the app
 if __name__ == "__main__":
-    demo.launch(share=True)
+    demo.launch(
+        share=False,
+        server_name="0.0.0.0",
+        server_port=7860
+    )