load models from hugging face in first run

ml/model_predictor.py

@@ -0,0 +1,82 @@
+import joblib
+import os
+import numpy as np
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+MODEL_REPO = "xplorers/parkinsons-updrs-model"
+MODEL_DIR  = "/tmp/models"
+
+# In-memory cache — models are loaded once at startup, reused for every request
+_cache = {}
+
+def _download_and_cache():
+    """Download models from HF Hub and cache in memory. Runs once at startup."""
+    if _cache:
+        return  # already loaded
+
+    os.makedirs(MODEL_DIR, exist_ok=True)
+
+    filenames = ["ensemble_model.pkl", "feature_names.pkl", "scaler.pkl"]
+    for filename in filenames:
+        hf_hub_download(
+            repo_id=MODEL_REPO,
+            filename=filename,
+            repo_type="model",
+            local_dir=MODEL_DIR,
+            token=os.getenv("HF_TOKEN"),  # needed if your HF model repo is private
+        )
+
+    _cache["model"]         = joblib.load(os.path.join(MODEL_DIR, "ensemble_model.pkl"))
+    _cache["feature_names"] = joblib.load(os.path.join(MODEL_DIR, "feature_names.pkl"))
+    _cache["scaler"]        = joblib.load(os.path.join(MODEL_DIR, "scaler.pkl"))
+    print("Models loaded into memory from HF Hub.")
+
+
+def predict_parkinson(features: dict) -> float:
+    """
+    Predict Parkinson's motor UPDRS score from patient features.
+    Uses cached models — no disk read on each request.
+    """
+    try:
+        model         = _cache["model"]
+        feature_names = _cache["feature_names"]
+        scaler        = _cache["scaler"]
+
+        print(f"Expected features: {feature_names}")
+        print(f"Received features: {list(features.keys())}")
+
+        missing_features = [name for name in feature_names if name not in features]
+        if missing_features:
+            raise ValueError(f"Missing required features: {missing_features}")
+
+        for name in feature_names:
+            value = features[name]
+            if pd.isna(value) or np.isinf(value):
+                print(f"Warning: Feature '{name}' has invalid value: {value}, replacing with 0.0")
+                features[name] = 0.0
+
+        input_values = [features[name] for name in feature_names]
+        input_df     = pd.DataFrame([input_values], columns=feature_names)
+
+        scaled_features  = scaler.transform(input_df)
+        updrs_prediction = model.predict(scaled_features)[0]
+
+        return float(updrs_prediction)
+
+    except KeyError:
+        raise RuntimeError("Models not loaded. Ensure startup lifespan ran successfully.")
+    except Exception as e:
+        raise Exception(f"Prediction error: {e}")
+
+
+def get_required_features():
+    try:
+        return list(_cache["feature_names"])
+    except KeyError:
+        return [
+            'age', 'sex', 'test_time', 'Jitter(%)', 'Jitter(Abs)', 'Jitter:RAP',
+            'Jitter:PPQ5', 'Jitter:DDP', 'Shimmer', 'Shimmer(dB)', 'Shimmer:APQ3',
+            'Shimmer:APQ5', 'Shimmer:APQ11', 'Shimmer:DDA', 'NHR', 'HNR',
+            'RPDE', 'DFA', 'PPE'
+        ]

services/__init__.py

@@ -0,0 +1 @@
+

services/voice_analyze_service.py

@@ -0,0 +1,38 @@
+import os
+from utils.file_handler import save_temp_file
+from ml.model_predictor import predict_parkinson
+from utils.voice_data_extraction import extract_voice_features
+
+async def process_audio_and_predict(audio_file, basic_info):
+    print("PROCESSING IN SERVICE:")
+    print(f"Received basic_info: {basic_info}")
+    print(f"Audio file object: {type(audio_file)}")
+
+    temp_file_path = await save_temp_file(audio_file)
+
+    try:
+        voice_features = extract_voice_features(temp_file_path)
+
+        patient_name = basic_info['name']
+
+        # exclude name
+        prediction_features = {k: v for k, v in basic_info.items() if k != 'name'}
+
+        # Encode sex: male=1, female=0
+        if 'sex' in prediction_features:
+            prediction_features['sex'] = 1 if prediction_features['sex'].lower() == 'male' else 0
+
+        feature_data = {**prediction_features, **voice_features}
+
+        print("CALLING ML MODEL...")
+        prediction = predict_parkinson(feature_data)
+
+        final_result = {"prediction": prediction, "patient": patient_name}
+        print(f"FINAL RESULT: {final_result}")
+
+        return final_result
+    finally:
+        # Always clean up the temp file from disk
+        if temp_file_path and os.path.exists(temp_file_path):
+            os.remove(temp_file_path)
+            print(f"Cleaned up temp file: {temp_file_path}")