Upload folder using huggingface_hub

backend/ensemble.py

@@ -9,20 +9,44 @@ if backend_dir not in sys.path:
 
 from preprocessing import resolve_model_dir
 
+CANONICAL_CLASSES = ['Asthma', 'Diabetes Mellitus', 'Healthy', 'Heart Disease', 'Hypertension']
+
 class EnsembleModel:
     def __init__(self):
         self.model_dir = resolve_model_dir()
         self.model_names = ['knn', 'svm', 'logreg', 'rf', 'small_nn']
         self.models = {}
         self.load_models()
-        self.label_encoder = joblib.load(f'{self.model_dir}/label_encoder.pkl')
+        self.label_encoder = None
+        le_path = os.path.join(self.model_dir, 'label_encoder.pkl')
+        if os.path.exists(le_path):
+            try:
+                self.label_encoder = joblib.load(le_path)
+            except Exception as e:
+                print(f"Warning: Failed to load label encoder: {e}")
         self.weights = {'knn': 0.15, 'svm': 0.15, 'logreg': 0.20, 'rf': 0.25, 'small_nn': 0.25}
         
     def load_models(self):
         for name in self.model_names:
-            path = f'{self.model_dir}/{name}.pkl'
+            path = os.path.join(self.model_dir, f'{name}.pkl')
             if os.path.exists(path):
                 self.models[name] = joblib.load(path)
+
+    def decode_label(self, idx: int) -> str:
+        """Safely maps class index to clinical label without throwing on unseen labels."""
+        if self.label_encoder is not None:
+            if hasattr(self.label_encoder, 'classes_'):
+                classes = self.label_encoder.classes_
+                if 0 <= idx < len(classes):
+                    return str(classes[idx])
+            if hasattr(self.label_encoder, 'inverse_transform'):
+                try:
+                    return str(self.label_encoder.inverse_transform([idx])[0])
+                except Exception:
+                    pass
+        if 0 <= idx < len(CANONICAL_CLASSES):
+            return CANONICAL_CLASSES[idx]
+        return f"Condition_{idx}"
                 
     def predict(self, X):
         individual_preds = {}
@@ -31,8 +55,8 @@ class EnsembleModel:
         for name, model in self.models.items():
             probs = model.predict_proba(X)
             individual_probs[name] = probs[0]
-            pred_indices = np.argmax(probs, axis=1)
-            individual_preds[name] = str(self.label_encoder.inverse_transform(pred_indices)[0])
+            pred_indices = int(np.argmax(probs, axis=1)[0])
+            individual_preds[name] = self.decode_label(pred_indices)
             
         num_classes = list(individual_probs.values())[0].shape[0]
         weighted_probs = np.zeros(num_classes)
@@ -44,12 +68,12 @@ class EnsembleModel:
             total_weight += w
             
         weighted_probs /= total_weight
-        final_pred_idx = np.argmax(weighted_probs)
-        final_pred = str(self.label_encoder.inverse_transform([final_pred_idx])[0])
+        final_pred_idx = int(np.argmax(weighted_probs))
+        final_pred = self.decode_label(final_pred_idx)
         confidence = float(np.max(weighted_probs))
         
         class_probs = {
-            str(self.label_encoder.inverse_transform([i])[0]): float(prob)
+            self.decode_label(i): float(prob)
             for i, prob in enumerate(weighted_probs)
         }
         

backend/main.py

@@ -187,6 +187,13 @@ async def explain(data: PatientData):
         return {"error": "RF Model unavailable for explanation."}
         
     df = pd.DataFrame([data.model_dump()])
+    df = df.rename(columns={
+        "Heart_Rate": "Heart Rate (bpm)",
+        "SpO2_Level": "SpO2 Level (%)",
+        "Systolic_BP": "Systolic Blood Pressure (mmHg)",
+        "Diastolic_BP": "Diastolic Blood Pressure (mmHg)",
+        "Body_Temp": "Body Temperature (°C)",
+    })
     X_proc, _ = await asyncio.to_thread(preprocess_data, df, False)
     
     def compute_shap():

backend/preprocessing.py

@@ -31,15 +31,69 @@ def resolve_data_path():
             return os.path.abspath(p)
     return os.path.abspath(candidates[0])
 
-def preprocess_data(df, is_training=True):
-    model_dir = resolve_model_dir()
-    scaler_path = f'{model_dir}/scaler.pkl'
-    label_encoder_path = f'{model_dir}/label_encoder.pkl'
-    imputer_path = f'{model_dir}/imputer.pkl'
+# Canonical Column Alias Mapping
+COLUMN_ALIASES = {
+    'heart rate (bpm)': 'Heart Rate (bpm)',
+    'heart rate': 'Heart Rate (bpm)',
+    'heart_rate': 'Heart Rate (bpm)',
+    'heartrate': 'Heart Rate (bpm)',
+    'hr': 'Heart Rate (bpm)',
+
+    'spo2 level (%)': 'SpO2 Level (%)',
+    'spo2 level': 'SpO2 Level (%)',
+    'spo2_level': 'SpO2 Level (%)',
+    'spo2': 'SpO2 Level (%)',
+    'oxygen': 'SpO2 Level (%)',
+
+    'systolic blood pressure (mmhg)': 'Systolic Blood Pressure (mmHg)',
+    'systolic blood pressure': 'Systolic Blood Pressure (mmHg)',
+    'systolic_bp': 'Systolic Blood Pressure (mmHg)',
+    'sys_bp': 'Systolic Blood Pressure (mmHg)',
+    'systolic': 'Systolic Blood Pressure (mmHg)',
+
+    'diastolic blood pressure (mmhg)': 'Diastolic Blood Pressure (mmHg)',
+    'diastolic blood pressure': 'Diastolic Blood Pressure (mmHg)',
+    'diastolic_bp': 'Diastolic Blood Pressure (mmHg)',
+    'dia_bp': 'Diastolic Blood Pressure (mmHg)',
+    'diastolic': 'Diastolic Blood Pressure (mmHg)',
+
+    'body temperature (°c)': 'Body Temperature (°C)',
+    'body temperature': 'Body Temperature (°C)',
+    'body_temp': 'Body Temperature (°C)',
+    'temperature': 'Body Temperature (°C)',
+    'temp': 'Body Temperature (°C)',
+
+    'predicted disease': 'Predicted Disease',
+    'predicted_disease': 'Predicted Disease',
+    'disease': 'Predicted Disease',
+    'condition': 'Predicted Disease',
+    'diagnosis': 'Predicted Disease',
+    'label': 'Predicted Disease',
+}
+
+def preprocess_data(df, is_training=False, model_dir=None):
+    if model_dir is None:
+        model_dir = resolve_model_dir()
+    os.makedirs(model_dir, exist_ok=True)
+    
+    scaler_path = os.path.join(model_dir, 'scaler.pkl')
+    label_encoder_path = os.path.join(model_dir, 'label_encoder.pkl')
+    imputer_path = os.path.join(model_dir, 'imputer.pkl')
+    
+    # 1. Normalize column names to canonical forms
+    col_map = {}
+    for col in df.columns:
+        norm_key = str(col).strip().lower().replace('\ufffd', '°')
+        if norm_key in COLUMN_ALIASES:
+            col_map[col] = COLUMN_ALIASES[norm_key]
+        elif isinstance(col, str) and '\ufffd' in col:
+            col_map[col] = col.replace('\ufffd', '°')
+    if col_map:
+        df = df.rename(columns=col_map)
         
     columns_to_drop = ['Patient Number', 'Data Accuracy (%)', 'Heart Rate Alert', 'SpO2 Level Alert', 'Blood Pressure Alert', 'Temperature Alert', 'Fall Detection']
     cols_drop = [c for c in columns_to_drop if c in df.columns]
-    X_raw = df.drop(columns=cols_drop)
+    X_raw = df.drop(columns=cols_drop).copy()
     
     y = None
     if 'Predicted Disease' in X_raw.columns:
@@ -49,23 +103,31 @@ def preprocess_data(df, is_training=True):
         if is_training:
             label_encoder = LabelEncoder()
             y = label_encoder.fit_transform(y_raw)
-            os.makedirs(os.path.dirname(label_encoder_path), exist_ok=True)
             joblib.dump(label_encoder, label_encoder_path)
-            joblib.dump(label_encoder.classes_, f'{model_dir}/classes.pkl')
+            joblib.dump(label_encoder.classes_, os.path.join(model_dir, 'classes.pkl'))
         else:
             if os.path.exists(label_encoder_path):
-                label_encoder = joblib.load(label_encoder_path)
                 try:
+                    label_encoder = joblib.load(label_encoder_path)
                     y = label_encoder.transform(y_raw)
                 except Exception:
                     y = None
             else:
                 y = y_raw 
     
-    # Fix broken encoding column names safely
-    X_raw.rename(columns=lambda x: x.replace('\ufffd', '°') if isinstance(x, str) else x, inplace=True)
-        
-    # Engineered Feature
+    # Ensure all canonical continuous features exist (defaults for missing inputs)
+    defaults = {
+        'Heart Rate (bpm)': 75.0,
+        'SpO2 Level (%)': 98.0,
+        'Systolic Blood Pressure (mmHg)': 120.0,
+        'Diastolic Blood Pressure (mmHg)': 80.0,
+        'Body Temperature (°C)': 37.0,
+    }
+    for col, default_val in defaults.items():
+        if col not in X_raw.columns:
+            X_raw[col] = default_val
+            
+    # Engineered Feature: Risk_Severity
     X_raw['Risk_Severity'] = (X_raw['Heart Rate (bpm)'] > 105).astype(int) + (X_raw['SpO2 Level (%)'] < 94).astype(int)
     
     continuous_features = ['Heart Rate (bpm)', 'SpO2 Level (%)', 'Systolic Blood Pressure (mmHg)', 'Diastolic Blood Pressure (mmHg)', 'Body Temperature (°C)', 'Risk_Severity']

model/classes.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:1a279aa014fedd87496788d97cf12c3552ab7720aeb83866ab31155ded322811
-size 388
+oid sha256:43241923778ab2ba4ee472ae79697c0730f7f325bf9d6607aea5d988fea6d7ab
+size 440

model/imputer.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:6f5fa9da126a70dd33010185218f39105c643266a9ba82a6d2c34f058bff01a6
+oid sha256:4b9ed7851cb3f2ef2d1db05bdcbd535259b5182bcf5f15ca24a174c86af19840
 size 935

model/label_encoder.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:383ae3e069a9f5aa7acd3948e54c95219b3ed3d5235c236620a17e8b8575b3f8
-size 491
+oid sha256:9cb3790496bceb78e1a77f585dd34d1fad77a64a5f9d40a410b4aa0dad119f92
+size 543

model/scaler.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:46c920570f77720384e8fc6dfe04a43c58e78285232ad3c5f5376b0630c0a079
+oid sha256:b202b117d5d42740a293bd1c1e017f100ebdc4fdeffeaf7e84d0485d9a88636a
 size 1127

tests/test_preprocessing.py

@@ -11,7 +11,7 @@ def test_resolve_model_dir():
     md = resolve_model_dir()
     assert md.endswith("model")
 
-def test_preprocess_data_training():
+def test_preprocess_data_training(tmp_path):
     df = pd.DataFrame({
         'Heart Rate (bpm)': [80, 90, np.nan],
         'SpO2 Level (%)': [98, 97, 95],
@@ -21,13 +21,26 @@ def test_preprocess_data_training():
         'Predicted Disease': ['Normal', 'Asthma', 'Normal']
     })
     
-    X, y = preprocess_data(df, is_training=True)
+    # Use tmp_path to isolate test artifacts from production models
+    X, y = preprocess_data(df, is_training=True, model_dir=str(tmp_path))
     
     assert not X.isnull().values.any()
     assert len(y) == 3
     assert 'Risk_Severity' in X.columns
+    assert os.path.exists(os.path.join(str(tmp_path), 'label_encoder.pkl'))
 
-def test_preprocess_data_inference():
+def test_preprocess_data_inference(tmp_path):
+    # First fit on dummy data inside tmp_path
+    train_df = pd.DataFrame({
+        'Heart Rate (bpm)': [80, 90],
+        'SpO2 Level (%)': [98, 97],
+        'Systolic Blood Pressure (mmHg)': [120, 125],
+        'Diastolic Blood Pressure (mmHg)': [80, 85],
+        'Body Temperature (°C)': [37.0, 37.2],
+        'Predicted Disease': ['Normal', 'Asthma']
+    })
+    preprocess_data(train_df, is_training=True, model_dir=str(tmp_path))
+    
     df = pd.DataFrame({
         'Heart Rate (bpm)': [100],
         'SpO2 Level (%)': [99],
@@ -36,7 +49,21 @@ def test_preprocess_data_inference():
         'Body Temperature (°C)': [37.0],
     })
     
-    X, y = preprocess_data(df, is_training=False)
+    X, y = preprocess_data(df, is_training=False, model_dir=str(tmp_path))
     
     assert y is None
     assert 'Risk_Severity' in X.columns
+
+def test_preprocess_data_alias_normalization(tmp_path):
+    """Test that schema field names (e.g. Heart_Rate) are automatically normalized without error."""
+    df = pd.DataFrame({
+        'Heart_Rate': [115],
+        'SpO2_Level': [92],
+        'Systolic_BP': [145],
+        'Diastolic_BP': [92],
+        'Body_Temp': [37.4],
+    })
+    X, y = preprocess_data(df, is_training=False)
+    assert 'Risk_Severity' in X.columns
+    assert 'Heart Rate (bpm)' in X.columns
+    assert not X.isnull().values.any()