Update app.py

app.py

@@ -4,17 +4,23 @@ import numpy as np
 import pickle
 import json
 import tensorflow as tf
-from tensorflow.keras.models import load_model
+from tensorflow.keras.models import load_model, model_from_json
 import plotly.graph_objects as go
-import plotly.express as px
-from plotly.subplots import make_subplots
 import os
 
+# Set environment variable to avoid oneDNN warnings
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+
 # Load model artifacts
 def load_model_artifacts():
     try:
-        # Load the trained model
-        model = load_model('final_model.h5')
+        # Load model architecture first
+        with open('model_architecture.json', 'r') as json_file:
+            model_json = json_file.read()
+        model = model_from_json(model_json)
+        
+        # Then load weights
+        model.load_weights('best_model.h5')
         
         # Load the scaler
         with open('scaler.pkl', 'rb') as f:
@@ -40,9 +46,7 @@ except Exception as e:
     feature_names = ['Feature_1', 'Feature_2', 'Feature_3', 'Feature_4']
 
 def predict_student_eligibility(*args):
-    """
-    Predict student eligibility based on input features
-    """
+    """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()
@@ -89,9 +93,7 @@ def create_error_plot():
     return fig
 
 def create_prediction_viz(probability, prediction, input_data):
-    """
-    Create visualization for prediction results
-    """
+    """Create visualization for prediction results"""
     try:
         # Create subplots
         fig = make_subplots(
@@ -179,36 +181,8 @@ def create_prediction_viz(probability, prediction, input_data):
     except Exception as e:
         return create_error_plot()
 
-def create_model_info():
-    """
-    Create model information display
-    """
-    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):
-    """
-    Batch prediction from uploaded CSV 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
@@ -217,7 +191,7 @@ def batch_predict(file):
             return "Please upload a CSV file.", None
         
         # Read the uploaded file
-        df = pd.read_csv(file.name)
+        df = pd.read_csv(file)
         
         # Check if all required features are present
         missing_features = set(feature_names) - set(df.columns)
@@ -269,169 +243,44 @@ Results saved to: {output_file}
         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;
-    }
-    .feature-input {
-        margin: 5px 0;
-    }
-    """
-) 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.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# 🎓 Student Eligibility Prediction")
     
     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):
-                    gr.Markdown("#### Input Features")
-                    # Create input components dynamically based on features
-                    inputs = []
-                    for i, feature in enumerate(feature_names):
-                        inputs.append(
-                            gr.Number(
-                                label=f"📊 {feature}",
-                                value=75 + i*5,  # Different default values
-                                minimum=0,
-                                maximum=100,
-                                step=0.1,
-                                elem_classes=["feature-input"]
-                            )
-                        )
-                    
-                    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_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.Tab("Single Prediction"):
+            inputs = []
+            for feature in feature_names:
+                inputs.append(gr.Number(label=feature, value=75))
             
-            # 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
-            ```
-            """)
+            predict_btn = gr.Button("Predict")
             
             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",
-                        size="lg"
-                    )
-                
-                with gr.Column():
-                    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"):
-            gr.Markdown("### Model Performance Metrics")
+                prediction = gr.Textbox(label="Prediction")
+                probability = gr.Textbox(label="Probability")
+                confidence = gr.Textbox(label="Confidence")
             
-            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**")
+            plot = gr.Plot()
             
-            # 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")
+            predict_btn.click(
+                predict_student_eligibility,
+                inputs=inputs,
+                outputs=[prediction, probability, confidence, plot]
+            )
+        
+        with gr.Tab("Batch Prediction"):
+            file_input = gr.File(
+                label="Upload CSV",
+                file_types=[".csv"],
+                type="filepath"  # Fixed: Changed from 'file' to 'filepath'
+            )
+            batch_btn = gr.Button("Process Batch")
+            batch_output = gr.Textbox(label="Results")
+            download = gr.File(label="Download")
             
-            # 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(
-        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]
-    )
+            batch_btn.click(
+                batch_predict,
+                inputs=file_input,
+                outputs=[batch_output, download]
+            )
 
-# Launch the app
-if __name__ == "__main__":
-    demo.launch(
-        share=False,
-        server_name="0.0.0.0",
-        server_port=7860
-    )
+demo.launch()