Update app.py

app.py

@@ -12,73 +12,85 @@ import os
 # Set environment variable to avoid oneDNN warnings
 os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
 
-# Load model artifacts
+# Initialize model components at startup
 def load_model_artifacts():
     try:
-        # Load from the same directory where training code saved artifacts
+        # Load model architecture
         with open('model_architecture.json', 'r') as json_file:
             model_json = json_file.read()
         model = model_from_json(model_json)
+        
+        # Load model weights
         model.load_weights('final_model.h5')
-
+        
+        # Load 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)}")
+        print(f"❌ Error loading model artifacts: {str(e)}")
+        return None, None, {}
 
-# Initialize model components
-try:
-    model, scaler, metadata = load_model_artifacts()
-    feature_names = metadata['feature_names']  # Get feature names from metadata
+# Load model
+model, scaler, metadata = load_model_artifacts()
+if model:
+    feature_names = metadata.get('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}")
-    model, scaler, metadata = None, None, {}
-    feature_names = ['Feature_1', 'Feature_2']  # Fallback if metadata not available
+else:
+    feature_names = ['Feature_1', 'Feature_2']
+    print("❌ Model failed to load - running in demo mode with placeholder features")
 
 def predict_student_eligibility(*args):
     try:
         if model is None or scaler is None:
-            return "Model not loaded", "N/A", "N/A", create_error_plot()
-
-        # Create input dictionary with correct feature names
-        input_data = {feature_names[i]: args[i] for i in range(len(feature_names))}
-        input_df = pd.DataFrame([input_data])
+            raise RuntimeError("Model not loaded - please check the model files")
+        
+        # Create input dictionary
+        input_data = {feature_names[i]: float(args[i]) for i in range(len(feature_names))}
         
-        # Ensure columns are in correct order
-        input_df = input_df[feature_names]
+        # Create DataFrame ensuring correct column order
+        input_df = pd.DataFrame([input_data], columns=feature_names)
         
-        # Scale and reshape input
+        # Scale features
         input_scaled = scaler.transform(input_df)
+        
+        # Reshape for CNN (samples, timesteps, features)
         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
+        confidence = abs(probability - 0.5) * 2  # Convert to 0-1 range
+        
+        # Create 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", create_error_plot()
+        error_msg = f"Error: {str(e)}"
+        print(error_msg)
+        return error_msg, "N/A", "N/A", create_error_plot(error_msg)
 
-def create_error_plot():
+def create_error_plot(message="Model not available or error occurred"):
     fig = go.Figure()
     fig.add_annotation(
-        text="Model not available or error occurred",
+        text=message,
         xref="paper", yref="paper",
         x=0.5, y=0.5, xanchor='center', yanchor='middle',
-        showarrow=False, font=dict(size=20)
+        showarrow=False, font=dict(size=16, color="red")
     )
     fig.update_layout(
         xaxis={'visible': False},
         yaxis={'visible': False},
-        height=400
+        height=400,
+        margin=dict(l=20, r=20, t=30, b=20)
     )
     return fig
 
@@ -174,7 +186,7 @@ def create_prediction_viz(probability, prediction, input_data):
 
         return fig
     except Exception as e:
-        return create_error_plot()
+        return create_error_plot(str(e))
 
 def batch_predict(file):
     try:
@@ -227,7 +239,7 @@ Results saved to: {output_file}
         return f"Error processing file: {str(e)}", None
 
 # Gradio UI
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
+with gr.Blocks(theme=gr.themes.Soft(), title="Student Eligibility Predictor") as demo:
     gr.Markdown("# 🎓 Student Eligibility Prediction")
     gr.Markdown("This app predicts student eligibility based on academic performance metrics.")