fix(lstm): change the algorithm for LSTM

app.py

@@ -44,19 +44,26 @@ def greet_json():
 def predict_machine():
     logger.info("Prediction request received")
     
-    sensor = database.get_sensor_readings()
+    sensor = database.get_sensor_readings(1)
     logger.info(f"Retrieved sensor: {sensor}")
     
+    # Check if sensor is a duplicate error response
+    if isinstance(sensor, dict) and sensor.get("message") == "Data already predicted":
+        logger.warning("Data already predicted - returning error")
+        return {
+            "success": False,
+            "error": "Data already predicted"
+        }
+    
     if sensor is None:
-        logging.warning("No sensor data available")
+        logger.warning("No sensor data available")
         return {
             "success": False,
             "error": "No sensor data available"
         }
         
     sensor_udi = sensor.get("udi")
-    
-    logger.debug(f"Processing sensor data for machine_id: {sensor.get('machine_id')}")
+    logger.debug(f"Processing sensor data for machine_id: {sensor.get('machine_id')}, UDI: {sensor_udi}")
     
     controller.set_sensor_data(sensor)
     
@@ -70,18 +77,33 @@ def predict_machine():
     if binary_result.get("failure_predicted"):
         logger.info("Failure predicted - running classification and time series analysis")
         classification_result = controller.predict_classification()
+        
+        target_machine = sensor.get("machine_id")
+        
+        sensor_lstm = database.get_sensor_readings(30, machine_id=target_machine)
+        if sensor_lstm is None or (isinstance(sensor_lstm, dict) and sensor_lstm.get("message")):
+            logger.warning("Not enough time-series data available")
+            sensor_lstm = []
+        
+        # Set time series data for RUL prediction
+        if sensor_lstm:
+            controller.set_sensor_data(sensor_lstm)
+        else:
+            controller.set_sensor_data(sensor)
+        
         time_series_result = controller.predict_time_series()
         
         if classification_result.get("success") and time_series_result.get("success"):
             logger.info(f"Prediction successful - failure_type: {classification_result.get('failure_type')}")
             
+            # Uncomment below when ready to save predictions
             save_result = database.create_new_predictions(
                 machine_id=sensor.get("machine_id"),
                 timestamp=sensor.get("timestamp"),
                 risk_score=classification_result.get("risk_score"),
                 failure_predicted=True,
                 failure_type=classification_result.get("failure_type"),
-                predicted_failure_time=time_series_result.get("predictions", {}).get("predicted_timestamp"),
+                predicted_failure_time=time_series_result.get("predictions", {}).get("predicted_failure_date"),
                 confidence=classification_result.get("confidence")
             )
             
@@ -94,6 +116,7 @@ def predict_machine():
                 }
             logger.info(f"Prediction successfully saved for UDI {sensor_udi}")
             database.mark_as_processed(sensor_udi)
+            
             return {
                 "success": True,
                 "failure_predicted": True,
@@ -102,15 +125,17 @@ def predict_machine():
                 "risk_score": classification_result.get("risk_score"),
                 "risk_level": classification_result.get("risk_level"),
                 "all_probabilities": classification_result.get("all_probabilities"),
-                "prediction_time_stamp": time_series_result.get("predictions"),
+                "rul_prediction": time_series_result.get("predictions"),
                 "timestamp": sensor.get("timestamp")
             }
         else:
             logger.error(f"Classification or time series prediction failed for UDI {sensor_udi}")
-            if binary_result.get("error") != "Data already predicted":
+            if not (isinstance(classification_result, dict) and classification_result.get("error") == "Data already predicted"):
                 database.reset_last_processed_id()
             return binary_result
-    else: 
+    else:
+        logger.info(f"No failure predicted for UDI {sensor_udi}")
+        # Uncomment below when ready to save predictions
         save_result = database.create_new_predictions(
             machine_id=sensor.get("machine_id"),
             timestamp=sensor.get("timestamp"),
@@ -123,4 +148,5 @@ def predict_machine():
         
         if save_result and save_result.get("success"):
             database.mark_as_processed(sensor_udi)
-        return binary_result
+        
+        return binary_result

controller.py

@@ -1,6 +1,5 @@
 import logging
 
-from database import Database
 from model import Model
 from utils import (
     calculate_risk_score,
@@ -12,6 +11,8 @@ from utils import (
     prepare_prediction_data,
     prepare_sensor_data_for_anomaly,
 )
+import numpy as np
+from datetime import datetime, timedelta
 
 logger = logging.getLogger(__name__)
 
@@ -24,7 +25,10 @@ class Controller:
     
     def set_sensor_data(self, sensor):
         self.__sensor = sensor
-        logger.debug(f"Sensor data updated for machine_id: {sensor.get('machine_id')}")
+        if isinstance(sensor, list):
+            logger.debug(f"Sensor data updated with {len(sensor)} readings")
+        else:
+            logger.debug(f"Sensor data updated for machine_id: {sensor.get('machine_id')}")
     
     # Binary method
     def predict_binary(self):
@@ -35,7 +39,8 @@ class Controller:
                 "error": "No sensor data available from database.",
             }
         
-        if self.__sensor.get("message") == "Data already predicted":
+        # Handle both list and dict cases
+        if isinstance(self.__sensor, dict) and self.__sensor.get("message") == "Data already predicted":
             logger.info(f"Skipping binary prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
             return {
                 "success": False,
@@ -53,8 +58,11 @@ class Controller:
             }
             
         try:
+            # For binary, we always use single sensor data (dict)
+            sensor_dict = self.__sensor if isinstance(self.__sensor, dict) else self.__sensor[0]
+            
             X_scaled = prepare_sensor_data_for_anomaly(
-                self.__sensor, self.__model.preprocessor_anomaly
+                sensor_dict, self.__model.preprocessor_anomaly
             )
     
             if X_scaled is None:
@@ -100,7 +108,8 @@ class Controller:
                 "error": "No sensor data available from database.",
             }
         
-        if self.__sensor.get("message") == "Data already predicted":
+        # Handle both list and dict cases
+        if isinstance(self.__sensor, dict) and self.__sensor.get("message") == "Data already predicted":
             logger.info(f"Skipping classification prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
             return {
                 "success": False,
@@ -115,8 +124,11 @@ class Controller:
             return {"success": False, "error": "Model or scalers not loaded."}
         
         try:
+            # For classification, we always use single sensor data (dict)
+            sensor_dict = self.__sensor if isinstance(self.__sensor, dict) else self.__sensor[0]
+            
             X_scaled = prepare_sensor_data_for_anomaly(
-                self.__sensor, self.__model.preprocessor_anomaly
+                sensor_dict, self.__model.preprocessor_anomaly
             )
     
             if X_scaled is None:
@@ -164,82 +176,83 @@ class Controller:
 
     # Time series method
     def predict_time_series(self):
+        # 1. Validation Checks
         if self.__sensor is None:
             logger.warning("Time series prediction attempted with no sensor data")
-            return {
-                "success": False,
-                "error": "No sensor data available from database.",
-            }
+            return {"success": False, "error": "No sensor data available."}
         
-        if self.__sensor.get("message") == "Data already predicted":
-            logger.info(f"Skipping time series prediction - data already predicted for UDI: {self.__sensor.get('udi')}")
-            return {
-                "success": False,
-                "error": "Data already predicted",
-            }
+        if isinstance(self.__sensor, dict) and self.__sensor.get("message") == "Data already predicted":
+            logger.info(f"Skipping time series - data already predicted for UDI: {self.__sensor.get('udi')}")
+            return {"success": False, "error": "Data already predicted"}
 
-        if (
-            self.__model.model_lstm is None
-            or self.__model.scaler_x is None
-            or self.__model.scaler_y is None
-        ):
-            logger.error("LSTM model or scalers not loaded - cannot perform prediction")
+        if self.__model.model_lstm is None or self.__model.scaler_lstm is None:
+            logger.error("LSTM model or scaler_x not loaded")
             return {"success": False, "error": "Model or scalers not loaded."}
             
         try:
-            timestamp = self.__sensor.get("timestamp", None)
-    
-            X_sequence = prepare_prediction_data(
-                self.__sensor, timestamp, self.__model.scaler_x, 32
-            )
-    
-            if X_sequence is None:
-                logger.error("Failed to prepare prediction data for time series")
-                return {"success": False, "error": "Failed to prepare prediction data."}
-    
-            scaled_prediction = self.__model.model_lstm.predict(X_sequence, verbose=0)
-    
-            prediction = self.__model.scaler_y.inverse_transform(scaled_prediction)
+            sensor_data = self.__sensor if isinstance(self.__sensor, list) else [self.__sensor]
     
-            pred_values = prediction[0]
-            original_values = convert_cyclical_to_original(
-                pred_values[0],  # hour_sin
-                pred_values[1],  # hour_cos
-                pred_values[2],  # dayofweek_sin
-                pred_values[3],  # dayofweek_cos
-                pred_values[4],  # dayofyear_sin
-                pred_values[5],  # dayofyear_cos
-                pred_values[6],  # month_sin
-                pred_values[7],  # month_cos
-            )
-    
-            predicted_timestamp = create_timestamp_from_predictions(
-                original_values, self.__sensor.get("timestamp", None)
-            )
-    
-            logger.info(f"Time series prediction complete - Predicted Timestamp: {predicted_timestamp}, Hour: {original_values['hour']}, Day of Week: {original_values['dayofweek']}")
+            input_data = []
+            for row in sensor_data:
+                input_data.append([
+                    row.get("air_temp"),
+                    row.get("process_temp"),
+                    row.get("rotational_speed"),
+                    row.get("torque"),
+                    row.get("tool_wear", 0) 
+                ])
+            
+            input_array = np.array(input_data)
+            if len(input_array) < 30:
+                missing = 30 - len(input_array)
+                padding = np.tile(input_array[0], (missing, 1))
+                input_array = np.vstack([padding, input_array])
+            elif len(input_array) > 30:
+                input_array = input_array[-30:]
+            
+            input_scaled = self.__model.scaler_lstm.transform(input_array)
+            input_reshaped = input_scaled.reshape(1, 30, 5)
+            health_score = float(self.__model.model_lstm.predict(input_reshaped, verbose=0)[0][0])
+            
+            
+            MAX_LIFE_DAYS = 7.0 
+            MAX_LIFE_MINUTES = MAX_LIFE_DAYS * 24 * 60
+            
+            rul_minutes_left = health_score * MAX_LIFE_MINUTES
+            days_remaining = health_score * MAX_LIFE_DAYS
+            
+            now_str = sensor_data[0].get("timestamp")
+            if isinstance(now_str, str):
+                now = datetime.fromisoformat(now_str.replace('Z', '+00:00'))
+            else:
+                now = datetime.now()
+                
+            failure_date = now + timedelta(minutes=rul_minutes_left)
+            
+            if days_remaining < 1.0:
+                status = "Critical"
+            elif days_remaining < 3.0:
+                status = "Warning"
+            else:
+                status = "Good"
+
+            logger.info(f"Health: {health_score*100:.1f}% -> {days_remaining:.2f} Days Left")
             
             return {
                 "success": True,
                 "predictions": {
-                    "hour": original_values["hour"],
-                    "dayofweek": original_values["dayofweek"],
-                    "dayofyear": original_values["dayofyear"],
-                    "month": original_values["month"],
-                    "predicted_timestamp": predicted_timestamp,
+                    "health_score": round(health_score, 4),           # e.g., 0.95
+                    "health_percentage": round(health_score * 100, 2), # e.g., 95.0%
+                    "rul_minutes": round(rul_minutes_left, 2),
+                    "days_remaining": round(days_remaining, 2),
+                    "predicted_failure_date": failure_date.strftime('%Y-%m-%d %H:%M:%S'),
+                    "status": status
                 },
-                "raw_sensor_data": {
-                    "air_temp": self.__sensor.get("air_temp"),
-                    "process_temp": self.__sensor.get("process_temp"),
-                    "rotational_speed": self.__sensor.get("rotational_speed"),
-                    "torque": self.__sensor.get("torque"),
-                    "tool_wear": self.__sensor.get("tool_wear"),
-                },
-                "input_timestamp": str(timestamp),
+                "input_timestamp": str(now_str),
             }
         except Exception as e:
             logger.error(f"Exception in time series prediction: {str(e)}")
             return {
                 "success": False,
                 "message": f"Failed to predict time-series data: {str(e)}"
-            }
+            }

database.py

@@ -32,19 +32,29 @@ class Database():
         logger.info("Reset last_processed_id - data can be reprocessed")
 
     
-    def get_sensor_readings(self):
+    def get_sensor_readings(self, limit, machine_id=None):
         try:
+            query = self.__supabase.table("sensor_readings").select("*")
+            
+            if machine_id:
+                query = query.eq("machine_id", machine_id)
+            
             response = (
-                self.__supabase.table("sensor_readings")
-                .select("*")
+                query
                 .order("created_at", desc=True)
-                .limit(1)
+                .limit(limit)
                 .execute()
             )
             
-            if response.data:
+            if not response.data:
+                logger.warning("No sensor readings found in database")
+                return None
+            
+            if limit == 1:
+                # Single reading mode - check for duplicates
                 current_reading = response.data[0]
                 
+                # Prevent reprocessing the same UDI
                 if self.__last_processed_id == current_reading.get("udi"):
                     logger.warning(f"Duplicate data detected - UDI {current_reading.get('udi')} already processed")
                     return {
@@ -52,11 +62,17 @@ class Database():
                         "message": "Data already predicted",
                     }
                 
-                logger.debug(f"Retrieved sensor reading - UDI: {current_reading.get('udi')}, Machine: {current_reading.get('machine_id')}")
+                self.__last_processed_id = current_reading.get("udi")
+                logger.debug(f"Retrieved single sensor reading - UDI: {current_reading.get('udi')}, Machine: {current_reading.get('machine_id')}")
                 return current_reading
-            
-            logger.warning("No sensor readings found in database")
-            return None
+
+            else:
+                # Multiple readings mode - no duplicate check, used for time-series
+                logger.debug(f"Retrieved {len(response.data)} sensor readings for time-series prediction")
+                history_data = response.data[::-1] 
+                                
+                return history_data
+        
         except Exception as e:
             logger.error(f"Failed to retrieve sensor readings: {str(e)}")
             return None
@@ -76,8 +92,8 @@ class Database():
                 })
                 .execute()
             )
-            logger.info(f"Prediction saved - Machine: {machine_id}, Failure: {failure_predicted}, Risk: {risk_score}")
+            logger.info(f"Prediction saved - Machine: {machine_id}, Failure: {failure_predicted}, Risk: {risk_score:.2f}")
             return {"success": True, "data": response}
         except Exception as e:
             logger.error(f"Failed to save prediction to database: {str(e)}")
-            return {"success": False, "error": str(e)}
+            return {"success": False, "error": str(e)}

model.py

@@ -7,15 +7,14 @@ from keras.models import load_model
 class Model:
     def __init__(self) -> None:
         # Time-Series
-        self.__model_lstm = os.path.join("model", "model_lstm_regression_cyclical.h5")
+        self.__model_lstm = os.path.join("model", "model_health_best.keras")
         
         # Anomaly Detection
         self.__model_binary = os.path.join("model", "model_binary_smote.pkl")
         self.__model_multiclass = os.path.join("model", "model_multi.pkl")
         
         # Scaler Time-Series
-        self.__scaler_y = os.path.join("model", "scaler_y.pkl")
-        self.__scaler_X = os.path.join("model", "scaler_X.pkl")
+        self.__scaler_lstm = os.path.join("model", "scaler_lstm.pkl")
         
         # Scaler Anomaly
         self.__preprocessor_anomaly = os.path.join("model", "scaler_anomaly.pkl")
@@ -48,17 +47,12 @@ class Model:
             else:
                 print(f"⚠ preprocessor_anomaly not found at {self.__preprocessor_anomaly}")
 
-            if os.path.exists(self.__scaler_X):
-                self.scaler_x = joblib.load(self.__scaler_X)
-                print("✓ scaler_X loaded successfully")
-            else:
-                print(f"⚠ scaler_X not found at {self.__scaler_X}")
 
-            if os.path.exists(self.__scaler_y):
-                self.scaler_y = joblib.load(self.__scaler_y)
+            if os.path.exists(self.__scaler_lstm):
+                self.scaler_lstm = joblib.load(self.__scaler_lstm)
                 print("scaler_y loaded successfully")
             else:
-                print(f"⚠ scaler_y not found at {self.__scaler_y}")
+                print(f"⚠ scaler_y not found at {self.__scaler_lstm}")
 
         except Exception as e:
             print(f"✗ Error loading model/scalers: {str(e)}")

model/{model_lstm_regression_cyclical.h5 → model_health_best.keras}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:a911c790fe72186bf5f32ead1dc03d17437fa9ca679621b690a59a3a8cfdf6cd
-size 188200
+oid sha256:5f1b298c8549b14c17adda8005dd25881ce00238b7c8c045dd2d592111ca6f1b
+size 908439

model/{scaler_X.pkl → scaler_lstm.pkl}

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:ac5cbaf929a252d67d7c9cb6be8e518c34282ed45a6961c3f808284cd0cab0b6
-size 1663
+oid sha256:e9474087a5515ba74ad828d7d503584213b0d1e3fbc70990f3aceaccb75ab19f
+size 719

model/scaler_y.pkl

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:8650fc69829b340007d54b0fd7c686c8eadb382b15fc3d34fbafe7a5e39af04f
-size 1351