added fault label

ml/inference.py

@@ -66,6 +66,21 @@ class MLEngine:
         self.ttf_model.load_model(os.path.join(ARTIFACTS_DIR, "xgb_ttf.json"))
         self.fail_model = xgb.XGBClassifier()
         self.fail_model.load_model(os.path.join(ARTIFACTS_DIR, "xgb_fail.json"))
+        
+        # Load fault type classifier if available
+        fault_model_path = os.path.join(ARTIFACTS_DIR, "xgb_fault.json")
+        if os.path.exists(fault_model_path):
+            self.fault_model = xgb.XGBClassifier()
+            self.fault_model.load_model(fault_model_path)
+            self.fault_map = {
+                0: "Normal",
+                1: "Short Circuit", 
+                2: "Degradation",
+                3: "Open Circuit",
+                4: "Shadowing"
+            }
+        else:
+            self.fault_model = None
 
     def _load_lstm_model(self):
         """Load LSTM autoencoder from safetensors."""
@@ -93,23 +108,73 @@ class MLEngine:
 
     def _make_predictions(self, df_scaled: pd.DataFrame, anomaly_lstm: float, health: float) -> dict:
         """Make TTF and failure probability predictions.
-        Returns: Dictionary with ttf, failure_prob, and rul predictions
+        Returns: Dictionary with all predictions including new metrics
         """
         latest_features = df_scaled[self.feature_cols].iloc[[-1]].copy()
         latest_features["anomaly_lstm"] = anomaly_lstm
         latest_features["health_index"] = health
+        
+        # TTF prediction
         expected_ttf_days = float(
             self.ttf_model.predict(latest_features, validate_features=False)[0]
         )
+        
+        # Failure probability (improved calculation from Colab)
         failure_probability = float(
             self.fail_model.predict_proba(latest_features, validate_features=False)[0][1]
         )
+        
+        # RUL calculation
         expected_rul_days = float(health * self.design_life_days)
-        confidence = round(0.5 * abs(failure_probability - 0.5) * 2 + 0.5 * health, 2)
+        
+        # Health trend (over last 200 points if available)
+        if len(df_scaled) >= 200:
+            # Calculate health trend by computing health over the window
+            recent_health_values = []
+            for i in range(max(0, len(df_scaled) - 200), len(df_scaled)):
+                temp_df = df_scaled.iloc[:i+1]
+                if len(temp_df) >= self.seq_len:
+                    temp_anomaly, temp_health = self._compute_anomalies(temp_df.iloc[-self.seq_len:])
+                    recent_health_values.append(temp_health)
+            health_trend = recent_health_values[-1] - recent_health_values[0] if recent_health_values else 0.0
+        else:
+            health_trend = 0.0
+            
+        # Fault type prediction
+        predicted_fault_type = "Unknown"
+        fault_confidence = 0.0
+        if self.fault_model is not None:
+            fault_pred = int(self.fault_model.predict(latest_features, validate_features=False)[0])
+            predicted_fault_type = self.fault_map.get(fault_pred, "Unknown")
+            fault_proba = self.fault_model.predict_proba(latest_features, validate_features=False)[0]
+            fault_confidence = float(np.max(fault_proba))
+        
+        # Improved failure probability calculation (from Colab)
+        ttf_norm = 1 - min(expected_ttf_days / self.design_life_days, 1.0)
+        health_risk = 1 - health
+        trend_risk = max(-health_trend, 0) * 50
+        anomaly_risk = min(anomaly_lstm / 1e6, 1.0)  # Normalize anomaly
+        
+        improved_failure_prob = (
+            0.35 * anomaly_risk +
+            0.30 * health_risk + 
+            0.20 * ttf_norm +
+            0.15 * trend_risk
+        )
+        improved_failure_prob = min(max(improved_failure_prob, 0), 1)
+        
+        # Overall confidence
+        confidence = round(0.5 * abs(improved_failure_prob - 0.5) * 2 + 0.5 * health, 2)
+        
         return {
             "ttf_days": expected_ttf_days,
-            "failure_prob": failure_probability,
+            "failure_prob": improved_failure_prob,
             "rul_days": expected_rul_days,
+            "health_score": round(health, 3),
+            "anomaly_score": round(anomaly_lstm, 4),
+            "health_trend_200step": round(health_trend, 4),
+            "predicted_fault_type": predicted_fault_type,
+            "fault_confidence": round(fault_confidence, 2),
             "confidence": confidence
         }
 
@@ -133,8 +198,13 @@ class MLEngine:
         logger.info("ML analysis end")
         return {
             "asset_id": asset_id,
+            "health_score": predictions["health_score"],
+            "anomaly_score": predictions["anomaly_score"],
+            "health_trend_200step": predictions["health_trend_200step"],
             "failure_probability": round(predictions["failure_prob"], 2),
             "expected_ttf_days": round(predictions["ttf_days"], 1),
             "expected_rul_days": round(predictions["rul_days"], 1),
+            "predicted_fault_type": predictions["predicted_fault_type"],
+            "fault_confidence": predictions["fault_confidence"],
             "confidence": predictions["confidence"]
         }