Update app.py

app.py

@@ -2,152 +2,101 @@ import gradio as gr
 import joblib
 import pandas as pd
 import os
-import numpy as np
 import traceback
 
-# --- 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 ---
+# --- Load model and artifacts ---
 try:
-    # Get the directory of the script to correctly locate model files
     app_dir = os.path.dirname(os.path.abspath(__file__))
-
-    # 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()
-    }
-    
+    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: 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):
-    """
-    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."
+    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 ---
+def predict_fall(movement_activity, location, day_of_week, hour_of_day, minute_of_day, time_since_last_event):
     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}"
+        # 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
+
+        # 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}"
 
     except Exception as e:
-        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.")
+        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()