Update app.py

app.py

@@ -4,8 +4,9 @@ import numpy as np
 import pickle
 import json
 import tensorflow as tf
-from tensorflow.keras.models import load_model, model_from_json
+from tensorflow.keras.models import model_from_json
 import plotly.graph_objects as go
+from plotly.subplots import make_subplots
 import os
 
 # Set environment variable to avoid oneDNN warnings
@@ -14,22 +15,17 @@ os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 # Load model artifacts
 def load_model_artifacts():
     try:
-        # 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('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)}")
@@ -37,47 +33,35 @@ def load_model_artifacts():
 # Initialize model components
 try:
     model, scaler, metadata = load_model_artifacts()
-    feature_names = metadata['feature_names']
+    # Use only two features for prediction
+    feature_names = ['Feature_1', 'Feature_2']
     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']
+    feature_names = ['Feature_1', 'Feature_2']
 
 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))}
-        
-        # 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 = 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
-        
-        # Create prediction visualization
+        confidence = abs(probability - 0.5) * 2
         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", 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",
@@ -93,22 +77,18 @@ def create_error_plot():
     return fig
 
 def create_prediction_viz(probability, prediction, input_data):
-    """Create visualization for prediction results"""
     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]},
@@ -123,17 +103,14 @@ def create_prediction_viz(probability, prediction, input_data):
                         'value': 0.5
                     }
                 }
-            ),
-            row=1, col=1
+            ), 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]},
@@ -144,143 +121,103 @@ def create_prediction_viz(probability, prediction, input_data):
                         {'range': [0.7, 1], 'color': "lightgreen"}
                     ]
                 }
-            ),
-            row=1, col=2
+            ), 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.Bar(x=features, y=values, name="Input Values", marker_color="skyblue"), row=2, col=1)
+
         fig.add_trace(
             go.Scatter(
-                x=[0, 1], 
-                y=[probability, probability], 
+                x=[0, 1], y=[probability, probability],
                 mode='lines+markers',
-                name="Probability", 
+                name="Probability",
                 line=dict(color="red", width=3),
                 marker=dict(size=10)
-            ),
-            row=2, col=2
+            ), 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 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)
-        
-        # 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
-        eligible_count = sum(1 for p in predictions if p == 'Eligible')
-        not_eligible_count = len(predictions) - eligible_count
-        
+
+        eligible_count = predictions.count('Eligible')
+        not_eligible_count = predictions.count('Not Eligible')
+
         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}%)
+✅ 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
-        
+
     except Exception as e:
         return f"Error processing file: {str(e)}", None
 
-# Create Gradio interface
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+# Gradio UI
+demo = gr.Blocks(theme=gr.themes.Soft())
+
+with demo:
     gr.Markdown("# 🎓 Student Eligibility Prediction")
-    
     with gr.Tabs():
         with gr.Tab("Single Prediction"):
-            inputs = []
-            for feature in feature_names:
-                inputs.append(gr.Number(label=feature, value=75))
-            
+            inputs = [gr.Number(label=feature, value=75) for feature in feature_names]
             predict_btn = gr.Button("Predict")
-            
             with gr.Row():
                 prediction = gr.Textbox(label="Prediction")
                 probability = gr.Textbox(label="Probability")
                 confidence = gr.Textbox(label="Confidence")
-            
             plot = gr.Plot()
-            
-            predict_btn.click(
-                predict_student_eligibility,
-                inputs=inputs,
-                outputs=[prediction, probability, confidence, plot]
-            )
-        
+            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'
-            )
+            file_input = gr.File(label="Upload CSV", file_types=[".csv"], type="filepath")
             batch_btn = gr.Button("Process Batch")
             batch_output = gr.Textbox(label="Results")
             download = gr.File(label="Download")
-            
-            batch_btn.click(
-                batch_predict,
-                inputs=file_input,
-                outputs=[batch_output, download]
-            )
-
-demo.launch()
+            batch_btn.click(batch_predict, inputs=file_input, outputs=[batch_output, download])
+
+# Launch app
+demo.launch()