Update app.py

app.py

@@ -1,6 +1,7 @@
-import gradio as gr
-import joblib
 import numpy as np
+import joblib
+import json
+from typing import List, Dict
 
 # Load the scaler and models
 scaler = joblib.load('scaler.joblib')
@@ -12,30 +13,61 @@ models = {
 }
 
 # Define the prediction function
-def predict(user_input):
-    # Ensure the input is in the same order as your model expects
-    user_input_array = np.array(user_input).reshape(1, -1)
+def predict(features: List[float]) -> Dict[str, float]:
+    """
+    Predict outcomes for all target variables based on input features.
+
+    Args:
+        features (List[float]): A list of 12 numeric features in the correct order.
 
-    # Scale the input using the saved scaler
-    user_input_scaled = scaler.transform(user_input_array)
+    Returns:
+        Dict[str, float]: A dictionary with predictions for each target variable.
+    """
+    # Ensure the input is a NumPy array
+    input_array = np.array(features).reshape(1, -1)
 
-    # Predict outcomes for all target variables
+    # Scale the input
+    scaled_input = scaler.transform(input_array)
+
+    # Predict outcomes
     predictions = {}
     for target, model in models.items():
-        prediction = model.predict(user_input_scaled)
-        predictions[target] = prediction[0]
+        predictions[target] = model.predict(scaled_input)[0]  # Get single prediction
 
     return predictions
 
-# Define Gradio interface
-interface = gr.Interface(fn=predict, 
-                         inputs=gr.Dataframe(type="numpy", row_count=1, col_count=12, 
-                                             headers=['course overview', 'reading file', 'abstract materiale', 
-                                                      'concrete material', 'visual materials', 'self-assessment', 
-                                                      'exercises submit', 'quiz submitted', 'playing', 'paused', 
-                                                      'unstarted', 'buffering']),
-                         outputs=gr.JSON(),
-                         live=True)
-
-# Launch the interface
-interface.launch()
+# Define a callable class for Hugging Face
+class Model:
+    def __init__(self):
+        self.scaler = scaler
+        self.models = models
+
+    def __call__(self, inputs: List[List[float]]) -> List[Dict[str, float]]:
+        """
+        Hugging Face expects the model to handle a batch of inputs.
+
+        Args:
+            inputs (List[List[float]]): A batch of feature vectors.
+
+        Returns:
+            List[Dict[str, float]]: A list of predictions for each input.
+        """
+        outputs = []
+        for features in inputs:
+            predictions = predict(features)
+            outputs.append(predictions)
+        return outputs
+
+
+# Instantiate the model
+model = Model()
+
+# Hugging Face Inference API expects `model` to be callable
+if __name__ == "__main__":
+    # For local testing or debugging
+    test_input = [
+        [0.5, 1.0, 0.0, 1.0, 0.5, 0.0, 1.0, 0.5, 1.0, 0.0, 0.0, 0.5]  # Example input
+    ]
+    output = model(test_input)
+    print(json.dumps(output, indent=4))
+