Update app.py

app.py

@@ -1,58 +1,34 @@
 import gradio as gr
 import numpy as np
-import pandas as pd
 import tensorflow as tf
 from tensorflow.keras.models import load_model
-from sklearn.preprocessing import StandardScaler, LabelEncoder
-import zipfile
-import os
-
-# Define dataset paths
-dataset_zip = "/mnt/data/HUMAN_ACTIVITY_RECOGNITION.zip"
-dataset_dir = "/mnt/data/human_activity_dataset"
-csv_path = os.path.join(dataset_dir, "time_series_data_human_activities.csv")
-model_path = "/mnt/data/human_activity_recognition_model.h5"
+from sklearn.preprocessing import StandardScaler
+import pandas as pd
 
-# Ensure dataset is extracted
-if not os.path.exists(dataset_dir) or not os.path.exists(csv_path):
-    if os.path.exists(dataset_zip):
-        with zipfile.ZipFile(dataset_zip, 'r') as zip_ref:
-            zip_ref.extractall(dataset_dir)
-    else:
-        raise FileNotFoundError(f"Dataset zip file '{dataset_zip}' not found. Please upload it.")
+# Load model and label encoder
+model = load_model("human_activity_recognition_model.h5")
+label_encoder = {0: "Walking", 1: "Running", 2: "Jumping", 3: "Sitting"}  # Adjust as per your dataset
 
-# Load dataset
-if os.path.exists(csv_path):
-    df = pd.read_csv(csv_path)
-    scaler = StandardScaler()
-    df[['x-axis', 'y-axis', 'z-axis']] = scaler.fit_transform(df[['x-axis', 'y-axis', 'z-axis']])
-    label_encoder = LabelEncoder()
-    df['activity'] = label_encoder.fit_transform(df['activity'])
-else:
-    raise FileNotFoundError("Dataset CSV file not found after extraction. Please check the ZIP contents.")
+# Sample scaler (ensure this matches what you used during training)
+scaler = StandardScaler()
 
-# Load trained model
-if os.path.exists(model_path):
-    model = load_model(model_path)
-else:
-    raise FileNotFoundError("Model file not found. Please upload the trained model.")
+# Define prediction function
+def predict_activity(x, y, z):
+    sample_input = np.array([[x, y, z]])
+    sample_input = scaler.fit_transform(sample_input)  # Apply the same scaling as training
+    sample_input = np.expand_dims(sample_input, axis=0)  # Reshape for LSTM input
+    prediction = model.predict(sample_input)
+    predicted_label = label_encoder[np.argmax(prediction)]
+    return f"Predicted Activity: {predicted_label}"
 
-def predict_activity(sensor_data):
-    """
-    Predict human activity based on sensor input.
-    Input should be comma-separated values (e.g., "0.1, 0.2, -0.3, ...").
-    """
-    try:
-        features = np.array([float(x) for x in sensor_data.split(",")])
-        if features.shape[0] != 60:  # Ensure input shape matches expected (20 timesteps * 3 features)
-            return "Error: Expected 60 values (20 timesteps * 3 features)."
-        
-        features = features.reshape(1, 20, 3)  # Reshape for LSTM model
-        features = scaler.transform(features.reshape(-1, 3)).reshape(1, 20, 3)  # Scale and reshape
-        
-        prediction = model.predict(features)
-        predicted_label = label_encoder.inverse_transform([np.argmax(prediction)])[0]
-        return f"Predicted Activity: {predicted_label}"
+# Create Gradio Interface
+demo = gr.Interface(
+    fn=predict_activity,
+    inputs=[gr.Number(label="X-axis"), gr.Number(label="Y-axis"), gr.Number(label="Z-axis")],
+    outputs="text",
+    title="Human Activity Recognition",
+    description="Enter accelerometer values (X, Y, Z) to predict activity.",
+)
 
-    except Exception as e:  # Ensure the except block exists
-        return f"Error: {str(e)}"
+# Launch the app
+demo.launch()