update rtu anomalizer2

src/rtu/RTUAnomalizer1.py

@@ -40,9 +40,12 @@ class RTUAnomalizer1:
                 prediction_model_path, clustering_model_paths, pca_model_paths
             )
 
-        self.actual_list, self.pred_list, self.resid_list, self.resid_pca_list = (
+        self.actual_list, self.pred_list, self.resid_list, self.resid_pca_list, self.distance_list = (
             self.initialize_lists()
         )
+        
+        self.fault_1 = None
+        self.fault_2 = None
 
     def initialize_lists(self, size=30):
         """
@@ -56,11 +59,13 @@ class RTUAnomalizer1:
         """
         initial_values = [[0] * self.num_outputs] * size
         initial_values1 = [[0] * 4] * size
+        initial_values2 = [[0] * 2] * size*2
         return (
             initial_values.copy(),
             initial_values.copy(),
             initial_values.copy(),
             initial_values1.copy(),
+            initial_values2.copy(),
         )
 
     def load_models(
@@ -192,11 +197,24 @@ class RTUAnomalizer1:
                     axis=1,
                 )
             )
+            self.distance_list.pop(0)
+            self.distance_list.append(dist)
         resid_pcas = np.array(resid_pcas).flatten().tolist()
         self.resid_pca_list.pop(0)
         self.resid_pca_list.append(resid_pcas)
 
         return np.array(dist)
+    def fault_windowing(self):
+        rtu_1_dist = np.array(self.distance_list).T[0]>1 #rtu_1_threshold
+        if sum(rtu_1_dist)>80*60: # 80% of the 60 min window
+            self.fault_1 = 1
+        else:
+            self.fault_1 = 0
+        rtu_2_dist = np.array(self.distance_list).T[1]>2.5 #rtu_2_threshold
+        if sum(rtu_2_dist)>80*60: # 80% of the 60 min window
+            self.fault_2 = 1
+        else:
+            self.fault_2 = 0
 
     def pipeline(self, df_new, df_trans, scaler):
         """
@@ -217,12 +235,17 @@ class RTUAnomalizer1:
         actual, pred = self.inverse_transform(scaler, pred, df_trans)
         actual_list, pred_list, resid_list = self.update_lists(actual, pred, resid)
         dist = self.calculate_distances(resid)
-        over_threshold = dist > 0.5
+        
         return (
             actual_list,
             pred_list,
             resid_list,
             self.resid_pca_list,
             dist,
-            over_threshold,
+            np.array(self.distance_list[30:]).T[0]>1, #rtu_1_threshold
+            np.array(self.distance_list[30:]).T[1]>2.5, #rtu_2_threshold
+            self.fault_1,
+            self.fault_2
         )
+
+    

src/rtu/RTUAnomalizer2.py

@@ -3,15 +3,11 @@ from tensorflow.keras.models import load_model
 import joblib
 
 
-class RTUAnomalizer2:
+class RTUAnomalizer1:
     """
     Class for performing anomaly detection on RTU (Roof Top Unit) data.
     """
 
-    model = None
-    kmeans_models = []
-    pca_models = []
-
     def __init__(
         self,
         prediction_model_path=None,
@@ -29,12 +25,27 @@ class RTUAnomalizer2:
             num_inputs (int): Number of input features.
             num_outputs (int): Number of output features.
         """
+        self.model = None
+        self.kmeans_models = []
+        self.pca_models = []
+
         self.num_inputs = num_inputs
         self.num_outputs = num_outputs
-        if prediction_model_path is not None and clustering_model_paths is not None and pca_model_paths is not None:
-            self.load_models(prediction_model_path, clustering_model_paths, pca_model_paths)
-            
-        self.actual_list, self.pred_list, self.resid_list = self.initialize_lists()
+        if (
+            prediction_model_path is not None
+            and clustering_model_paths is not None
+            and pca_model_paths is not None
+        ):
+            self.load_models(
+                prediction_model_path, clustering_model_paths, pca_model_paths
+            )
+
+        self.actual_list, self.pred_list, self.resid_list, self.resid_pca_list, self.distance_list = (
+            self.initialize_lists()
+        )
+        
+        self.fault_1 = None
+        self.fault_2 = None
 
     def initialize_lists(self, size=30):
         """
@@ -46,10 +57,20 @@ class RTUAnomalizer2:
         Returns:
             tuple: A tuple containing three lists initialized with zeros.
         """
-        initial_values = [[0]*self.num_outputs] * size
-        return initial_values.copy(), initial_values.copy(), initial_values.copy()
+        initial_values = [[0] * self.num_outputs] * size
+        initial_values1 = [[0] * 4] * size
+        initial_values2 = [[0] * 2] * size*2
+        return (
+            initial_values.copy(),
+            initial_values.copy(),
+            initial_values.copy(),
+            initial_values1.copy(),
+            initial_values2.copy(),
+        )
 
-    def load_models(self, prediction_model_path, clustering_model_paths, pca_model_paths):
+    def load_models(
+        self, prediction_model_path, clustering_model_paths, pca_model_paths
+    ):
         """
         Load the prediction and clustering models.
 
@@ -61,7 +82,7 @@ class RTUAnomalizer2:
 
         for path in clustering_model_paths:
             self.kmeans_models.append(joblib.load(path))
-            
+
         for path in pca_model_paths:
             self.pca_models.append(joblib.load(path))
 
@@ -75,7 +96,7 @@ class RTUAnomalizer2:
         Returns:
             array: Predicted values.
         """
-        return self.model.predict(df_new,verbose=0)
+        return self.model.predict(df_new, verbose=0)
 
     def calculate_residuals(self, df_trans, pred):
         """
@@ -161,16 +182,39 @@ class RTUAnomalizer2:
             array: Array of distances.
         """
         dist = []
+        resid_pcas = []
         for i, model in enumerate(self.kmeans_models):
+            resid_pca = self.pca_models[i].transform(
+                resid[:, (i * 7) + 1 : (i * 7) + 8]
+            )
+
+            resid_pcas = resid_pcas + resid_pca.tolist()
+
             dist.append(
                 np.linalg.norm(
-                    self.pca_models[i].transform(resid[:, (i * 7) + 1 : (i * 7) + 8]) - model.cluster_centers_[0],
+                    resid_pca - model.cluster_centers_[0],
                     ord=2,
                     axis=1,
                 )
             )
+            self.distance_list.pop(0)
+            self.distance_list.append(dist)
+        resid_pcas = np.array(resid_pcas).flatten().tolist()
+        self.resid_pca_list.pop(0)
+        self.resid_pca_list.append(resid_pcas)
 
         return np.array(dist)
+    def fault_windowing(self):
+        rtu_1_dist = np.array(self.distance_list).T[0]>1.5 #rtu_3_threshold
+        if sum(rtu_1_dist)>80*60: # 80% of the 60 min window
+            self.fault_1 = 1
+        else:
+            self.fault_1 = 0
+        rtu_2_dist = np.array(self.distance_list).T[1]>1.5 #rtu_4_threshold
+        if sum(rtu_2_dist)>80*60: # 80% of the 60 min window
+            self.fault_2 = 1
+        else:
+            self.fault_2 = 0
 
     def pipeline(self, df_new, df_trans, scaler):
         """
@@ -184,12 +228,24 @@ class RTUAnomalizer2:
         Returns:
             tuple: A tuple containing the lists of actual, predicted, and residual values, and the distances.
         """
-        
+
         pred = self.predict(df_new)
         actual, resid = self.calculate_residuals(df_trans, pred)
         pred = self.resize_prediction(pred, df_trans)
         actual, pred = self.inverse_transform(scaler, pred, df_trans)
-        actual_list, pred_list, resid_list = self.update_lists(
-             actual, pred, resid)
+        actual_list, pred_list, resid_list = self.update_lists(actual, pred, resid)
         dist = self.calculate_distances(resid)
-        return actual_list, pred_list, resid_list, dist
+        
+        return (
+            actual_list,
+            pred_list,
+            resid_list,
+            self.resid_pca_list,
+            dist,
+            np.array(self.distance_list[30:]).T[0]>1.5, #rtu_3_threshold
+            np.array(self.distance_list[30:]).T[1]>1.5, #rtu_4_threshold
+            self.fault_1,
+            self.fault_2
+        )
+
+