Update app.py

app.py

@@ -2,101 +2,152 @@ import gradio as gr
 import joblib
 import pandas as pd
 import os
+import numpy as np
 import traceback
 
-# --- Load model and artifacts ---
+# --- 1. Define Model and Preprocessing Components ---
+model = None
+scaler = None
+encoder = None
+all_feature_columns = None
+numerical_features = None
+categorical_features = None
+prediction_threshold = 0.5
+
+# --- 2. Load the Model and Preprocessing Tools with Error Handling ---
 try:
+    # Get the directory of the script to correctly locate model files
     app_dir = os.path.dirname(os.path.abspath(__file__))
-    model = joblib.load(os.path.join(app_dir, "fall_detection_model.joblib"))
-    scaler = joblib.load(os.path.join(app_dir, "scaler.joblib"))
-    encoder = joblib.load(os.path.join(app_dir, "encoder.joblib"))
-    feature_names = joblib.load(os.path.join(app_dir, "feature_names.joblib"))  # list of all features used during training
-    print("Model, scaler, encoder, and feature names loaded successfully.")
-except FileNotFoundError as e:
-    print(f"Error: Missing file: {e}")
-    exit()
-
-# Categorical features and their categories (from encoder)
-categorical_features = ['Movement Activity', 'Location', 'day_of_week']
-categories_map = {cat: encoder.categories_[i].tolist() for i, cat in enumerate(categorical_features)}
 
-# --- Prediction function ---
+    # Load all the necessary model artifacts
+    model_path = os.path.join(app_dir, 'fall_detection_model.joblib')
+    scaler_path = os.path.join(app_dir, 'scaler.joblib')
+    encoder_path = os.path.join(app_dir, 'encoder.joblib')
+    feature_names_path = os.path.join(app_dir, 'feature_names.joblib')
+    threshold_path = os.path.join(app_dir, 'prediction_threshold.txt')
+
+    model = joblib.load(model_path)
+    scaler = joblib.load(scaler_path)
+    encoder = joblib.load(encoder_path)
+    all_feature_columns = joblib.load(feature_names_path)
+    
+    # Read the prediction threshold from the text file
+    with open(threshold_path, 'r') as f:
+        prediction_threshold = float(f.read().strip())
+    
+    print("All model and preprocessing files loaded successfully.")
+
+    # Dynamically separate numerical from categorical features using the encoder
+    # This is the most reliable and foolproof way to ensure column lists match.
+    # The get_feature_names_out() method from the encoder returns the names of the
+    # one-hot encoded columns. We can then infer the categorical and numerical
+    # features from the master list of all features.
+    encoded_feature_names = encoder.get_feature_names_out()
+    categorical_features_encoded = [col for col in all_feature_columns if col in encoded_feature_names]
+    numerical_features = [col for col in all_feature_columns if col not in encoded_feature_names]
+
+    # Map the original categorical features from the encoder's categories
+    categories_map = {
+        'Movement Activity': encoder.categories_[0].tolist(),
+        'Location': encoder.categories_[1].tolist(),
+        'day_of_week': encoder.categories_[2].tolist()
+    }
+    
+except FileNotFoundError as e:
+    print(f"Error: A required file was not found. Please ensure all model artifacts "
+          f"are in the same directory as this script. Missing file: {e.filename}")
+    model = None  # Set model to None to prevent app from launching
+except Exception as e:
+    print(f"An unexpected error occurred during file loading: {e}\n{traceback.format_exc()}")
+    model = None
+
+# --- 3. Prediction Function for Gradio ---
 def predict_fall(movement_activity, location, day_of_week, hour_of_day, minute_of_day, time_since_last_event):
-    try:
-        # Initialize all features to 0
-        data = {f: 0 for f in feature_names}
-
-        # Set one-hot encoded categorical features
-        data[f'Movement Activity_{movement_activity}'] = 1
-        data[f'Location_{location}'] = 1
-        data[f'day_of_week_{day_of_week}'] = 1
+    """
+    Takes user inputs and uses the loaded model to predict the likelihood of a fall.
+    """
+    if model is None:
+        return "Error: Model not loaded. Check server logs for details."
 
-        # Set numeric features
-        data['hour_of_day'] = hour_of_day
-        data['minute_of_day'] = minute_of_day
-        data['time_since_last_event'] = time_since_last_event
-
-        # Create DataFrame with all features in correct order
-        input_df = pd.DataFrame([data])[feature_names]
-
-        # Get columns scaler was trained on
-        scaler_feature_names = scaler.feature_names_in_
-
-        # Scale only those columns, keep the rest unchanged
-        scaled_array = scaler.transform(input_df[scaler_feature_names])
-        input_df.loc[:, scaler_feature_names] = scaled_array
-
-        # Predict using the model on fully prepared DataFrame
-        pred_proba = model.predict_proba(input_df)[0, 1]
-        threshold = 0.4
-        pred_label = "Fall Detected" if pred_proba >= threshold else "No Fall"
-
-        return f"Prediction: {pred_label}\nFall Probability: {pred_proba:.2f}"
+    try:
+        # Create a dictionary to hold the input data with all expected columns.
+        input_data = {col: 0.0 for col in all_feature_columns}
+        
+        # Populate the one-hot encoded features with user input
+        input_data[f'Movement Activity_{movement_activity}'] = 1.0
+        input_data[f'Location_{location}'] = 1.0
+        input_data[f'day_of_week_{day_of_week}'] = 1.0
+        
+        # Populate the numerical features with user input
+        input_data['hour_of_day'] = float(hour_of_day)
+        input_data['minute_of_day'] = float(minute_of_day)
+        input_data['time_since_last_event'] = float(time_since_last_event)
+
+        # Create a DataFrame from the dictionary, ensuring the column order is correct
+        input_df = pd.DataFrame([input_data], columns=all_feature_columns)
+        
+        # Apply the scaler to only the numerical columns
+        input_df[numerical_features] = scaler.transform(input_df[numerical_features])
+        
+        # Make the prediction
+        fall_probability = model.predict_proba(input_df)[:, 1][0]
+        prediction = 'Fall Detected' if fall_probability >= prediction_threshold else 'No Fall'
+        
+        return f"Prediction: {prediction}\nFall Probability: {fall_probability:.2f}"
 
     except Exception as e:
-        tb = traceback.format_exc()
-        print("Error in prediction:\n", tb)
-        return f"Error: {str(e)}\nCheck server logs for details."
-
-# --- Build Gradio interface ---
-with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# Fall Detection Model")
-    gr.Markdown("Provide sensor data to predict fall detection.")
-
-    movement_activity_input = gr.Dropdown(
-        label="Movement Activity",
-        choices=categories_map['Movement Activity'],
-        value=categories_map['Movement Activity'][0]
-    )
-    location_input = gr.Dropdown(
-        label="Location",
-        choices=categories_map['Location'],
-        value=categories_map['Location'][0]
-    )
-    day_of_week_input = gr.Dropdown(
-        label="Day of Week",
-        choices=categories_map['day_of_week'],
-        value=categories_map['day_of_week'][0]
-    )
-    hour_of_day_input = gr.Slider(0, 23, step=1, label="hour_of_day")
-    minute_of_day_input = gr.Slider(0, 59, step=1, label="minute_of_day")
-    time_since_last_event_input = gr.Number(label="time_since_last_event")
-
-    prediction_output = gr.Textbox(label="Prediction Result", lines=5)
-
-    predict_button = gr.Button("Run Prediction")
-    predict_button.click(
-        fn=predict_fall,
-        inputs=[
-            movement_activity_input,
-            location_input,
-            day_of_week_input,
-            hour_of_day_input,
-            minute_of_day_input,
-            time_since_last_event_input
-        ],
-        outputs=prediction_output
-    )
-
-if __name__ == "__main__":
-    demo.launch()
+        return f"An error occurred during prediction: {e}\n{traceback.format_exc()}"
+
+# --- 4. Gradio Interface Setup ---
+if model is not None:
+    # Use the `gr.Blocks` for a more flexible layout.
+    with gr.Blocks(theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# Fall Detection Model")
+        gr.Markdown(
+            f"This model predicts the likelihood of a fall based on user activity and location. "
+            f"A fall is detected if the probability is >= {prediction_threshold}."
+        )
+
+        with gr.Row():
+            movement_activity_input = gr.Dropdown(
+                label="Movement Activity",
+                choices=categories_map['Movement Activity'],
+                value=categories_map['Movement Activity'][0]
+            )
+            location_input = gr.Dropdown(
+                label="Location",
+                choices=categories_map['Location'],
+                value=categories_map['Location'][0]
+            )
+            day_of_week_input = gr.Dropdown(
+                label="Day of Week",
+                choices=categories_map['day_of_week'],
+                value=categories_map['day_of_week'][0]
+            )
+
+        with gr.Row():
+            hour_of_day_input = gr.Slider(0, 23, step=1, label="Hour of Day")
+            minute_of_day_input = gr.Slider(0, 59, step=1, label="Minute of Day")
+            time_since_last_event_input = gr.Number(label="Time Since Last Event (in seconds)")
+
+        predict_button = gr.Button("Run Prediction", variant="primary")
+        prediction_output = gr.Textbox(label="Prediction Result", lines=3)
+
+        predict_button.click(
+            fn=predict_fall,
+            inputs=[
+                movement_activity_input,
+                location_input,
+                day_of_week_input,
+                hour_of_day_input,
+                minute_of_day_input,
+                time_since_last_event_input
+            ],
+            outputs=prediction_output
+        )
+
+    # --- 5. Launch the Gradio App ---
+    if __name__ == "__main__":
+        demo.launch()
+else:
+    print("Gradio app cannot be launched due to errors during model loading.")