Create app.py

app.py

@@ -0,0 +1,321 @@
+import gradio as gr
+import pandas as pd
+import numpy as np
+import pickle
+import json
+import tensorflow as tf
+from tensorflow.keras.models import load_model
+import plotly.graph_objects as go
+import plotly.express as px
+from plotly.subplots import make_subplots
+import os
+
+# Load model artifacts
+@st.cache_resource
+def load_model_artifacts():
+    try:
+        # Load the trained model
+        model = load_model('final_model.h5')
+        
+        # Load the scaler
+        with open('scaler.pkl', 'rb') as f:
+            scaler = pickle.load(f)
+        
+        # Load metadata
+        with open('metadata.json', 'r') as f:
+            metadata = json.load(f)
+            
+        return model, scaler, metadata
+    except Exception as e:
+        raise Exception(f"Error loading model artifacts: {str(e)}")
+
+# Initialize model components
+model, scaler, metadata = load_model_artifacts()
+feature_names = metadata['feature_names']
+
+def predict_student_eligibility(*args):
+    """
+    Predict student eligibility based on input features
+    """
+    try:
+        # Create input dictionary from gradio inputs
+        input_data = {feature_names[i]: args[i] for i in range(len(feature_names))}
+        
+        # Convert to DataFrame
+        input_df = pd.DataFrame([input_data])
+        
+        # Scale the input
+        input_scaled = scaler.transform(input_df)
+        
+        # Reshape for CNN
+        input_reshaped = input_scaled.reshape(input_scaled.shape[0], input_scaled.shape[1], 1)
+        
+        # Make prediction
+        probability = 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
+        
+        # Create prediction visualization
+        fig = create_prediction_viz(probability, prediction, input_data)
+        
+        return prediction, f"{probability:.4f}", f"{confidence:.4f}", fig
+        
+    except Exception as e:
+        return f"Error: {str(e)}", "N/A", "N/A", None
+
+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
+                }
+            }
+        ),
+        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
+
+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>
+    """
+    return info_html
+
+def batch_predict(file):
+    """
+    Batch prediction from uploaded CSV file
+    """
+    try:
+        # Read the uploaded file
+        df = pd.read_csv(file.name)
+        
+        # Check if all required features are present
+        missing_features = set(feature_names) - set(df.columns)
+        if missing_features:
+            return f"Missing features: {missing_features}", None
+        
+        # Select only the required features
+        df_features = df[feature_names]
+        
+        # Scale the features
+        df_scaled = scaler.transform(df_features)
+        
+        # Reshape for CNN
+        df_reshaped = df_scaled.reshape(df_scaled.shape[0], df_scaled.shape[1], 1)
+        
+        # Make predictions
+        probabilities = model.predict(df_reshaped).flatten()
+        predictions = ["Eligible" if p > 0.5 else "Not Eligible" for p in probabilities]
+        
+        # Create results dataframe
+        results_df = df_features.copy()
+        results_df['Probability'] = probabilities
+        results_df['Prediction'] = predictions
+        results_df['Confidence'] = np.abs(probabilities - 0.5) * 2
+        
+        # Save results
+        output_file = "batch_predictions.csv"
+        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}
+        """
+        
+        return summary, output_file
+        
+    except Exception as e:
+        return f"Error processing file: {str(e)}", None
+
+# Create Gradio interface
+with gr.Blocks(
+    theme=gr.themes.Soft(),
+    title="Student Eligibility Prediction",
+    css="""
+    .gradio-container {
+        max-width: 1200px !important;
+    }
+    .main-header {
+        text-align: center;
+        padding: 20px;
+        background: linear-gradient(45deg, #667eea 0%, #764ba2 100%);
+        color: white;
+        border-radius: 10px;
+        margin-bottom: 20px;
+    }
+    """
+) as demo:
+    
+    # Header
+    gr.HTML("""
+    <div class="main-header">
+        <h1>🎓 Student Eligibility Prediction System</h1>
+        <p>AI-powered CNN model for predicting student eligibility with advanced analytics</p>
+    </div>
+    """)
+    
+    with gr.Tabs():
+        # Single Prediction Tab
+        with gr.TabItem("Single Prediction"):
+            gr.Markdown("### Enter student information to predict eligibility")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    # Create input components dynamically based on features
+                    inputs = []
+                    for feature in feature_names:
+                        inputs.append(
+                            gr.Number(
+                                label=f"{feature}",
+                                value=85,  # Default value
+                                minimum=0,
+                                maximum=100,
+                                step=1
+                            )
+                        )
+                    
+                    predict_btn = gr.Button("🔮 Predict Eligibility", variant="primary", size="lg")
+                
+                with gr.Column(scale=2):
+                    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_plot = gr.Plot(label="Prediction Visualization")
+            
+            # Model information
+            gr.HTML(create_model_info())
+        
+        # Batch Prediction Tab
+        with gr.TabItem("Batch Prediction"):
+            gr.Markdown("### Upload a CSV file for batch predictions")
+            gr.Markdown(f"**Required columns:** {', '.join(feature_names)}")
+            
+            with gr.Row():
+                with gr.Column():
+                    file_input = gr.File(
+                        label="Upload CSV File",
+                        file_types=[".csv"],
+                        type="file"
+                    )
+                    batch_predict_btn = gr.Button("📊 Process Batch", variant="primary")
+                
+                with gr.Column():
+                    batch_output = gr.Textbox(label="Batch Results Summary", lines=10)
+                    download_file = gr.File(label="Download Results")
+        
+        # Model Analytics Tab
+        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")
+            
+            # Feature importance (placeholder - you'd need to calculate this)
+            gr.Markdown("### Feature Names")
+            gr.Textbox(value=", ".join(feature_names), label="Model Features", lines=3)
+    
+    # Event handlers
+    predict_btn.click(
+        fn=predict_student_eligibility,
+        inputs=inputs,
+        outputs=[prediction_output, probability_output, confidence_output, prediction_plot]
+    )
+    
+    batch_predict_btn.click(
+        fn=batch_predict,
+        inputs=[file_input],
+        outputs=[batch_output, download_file]
+    )
+
+# Launch the app
+if __name__ == "__main__":
+    demo.launch(share=True)