Add pickle files for PCA, scaler, and k-means models

dashboard.py

@@ -1,4 +1,8 @@
 from collections import deque
+from src.energy_prediction.EnergyPredictionModel import EnergyPredictionModel
+from src.energy_prediction.EnergyPredictionPipeline import EnergyPredictionPipeline
+from src.vav.VAVAnomalizer import VAVAnomalizer
+from src.vav.VAVPipeline import VAVPipeline
 import streamlit as st
 import pandas as pd
 import numpy as np
@@ -13,39 +17,82 @@ rtu_data_pipeline = RTUPipeline(
     scaler1_path="src/rtu/models/scaler_rtu_1_2.pkl",
     scaler2_path="src/rtu/models/scaler_rtu_3_4.pkl",
 )
-rtu_anomalizer1 = RTUAnomalizer1(
-    prediction_model_path="src/rtu/models/lstm_2rtu_smooth_04.keras",
-    clustering_model_paths=[
-        "src/rtu/models/kmeans_rtu_1.pkl",
-        "src/rtu/models/kmeans_rtu_2.pkl",
-    ],
-    pca_model_paths=[
-        "src/rtu/models/pca_rtu_1.pkl",
-        "src/rtu/models/pca_rtu_2.pkl",
-    ],
-    num_inputs=rtu_data_pipeline.num_inputs,
-    num_outputs=rtu_data_pipeline.num_outputs,
-)
 
+rtu_anomalizers = []
+
+
+rtu_anomalizers.append(
+    RTUAnomalizer1(
+        prediction_model_path="src/rtu/models/lstm_2rtu_smooth_04.keras",
+        clustering_model_paths=[
+            "src/rtu/models/kmeans_rtu_1.pkl",
+            "src/rtu/models/kmeans_rtu_2.pkl",
+        ],
+        pca_model_paths=[
+            "src/rtu/models/pca_rtu_1.pkl",
+            "src/rtu/models/pca_rtu_2.pkl",
+        ],
+        num_inputs=rtu_data_pipeline.num_inputs,
+        num_outputs=rtu_data_pipeline.num_outputs,
+    )
+)
 
-rtu_anomalizer2 = RTUAnomalizer1(
-    prediction_model_path="src/rtu/models/lstm_2rtu_smooth_04.keras",
-    clustering_model_paths=[
-        "src/rtu/models/kmeans_rtu_1.pkl",
-        "src/rtu/models/kmeans_rtu_2.pkl",
-    ],
-    pca_model_paths=[
-        "src/rtu/models/pca_rtu_1.pkl",
-        "src/rtu/models/pca_rtu_2.pkl",
-    ],
-    num_inputs=rtu_data_pipeline.num_inputs,
-    num_outputs=rtu_data_pipeline.num_outputs,
+rtu_anomalizers.append(
+    RTUAnomalizer1(
+        prediction_model_path="src/rtu/models/lstm_2rtu_smooth_04.keras",
+        clustering_model_paths=[
+            "src/rtu/models/kmeans_rtu_1.pkl",
+            "src/rtu/models/kmeans_rtu_2.pkl",
+        ],
+        pca_model_paths=[
+            "src/rtu/models/pca_rtu_1.pkl",
+            "src/rtu/models/pca_rtu_2.pkl",
+        ],
+        num_inputs=rtu_data_pipeline.num_inputs,
+        num_outputs=rtu_data_pipeline.num_outputs,
+    )
 )
 
-rtu_1_thresholds = deque(maxlen=60)
-rtu_1_fault = False
-for i in range(60):
-    rtu_1_thresholds.append(0)
+vav_pipelines = []
+vav_anomalizers = []
+for i in range(1, 2):
+    vav_pipelines.append(
+        VAVPipeline(rtu_id=i, scaler_path=f"src/vav/models/scaler_vav_{i}.pkl")
+    )
+
+for i in range(1, 2):
+    vav_anomalizers.append(
+        VAVAnomalizer(
+            rtu_id=i,
+            prediction_model_path=f"src/vav/models/lstm_vav_0{i}.keras",
+            clustering_model_path=f"src/vav/models/kmeans_vav_{i}.pkl",
+            pca_model_path=f"src/vav/models/pca_vav_{i}.pkl",
+            num_inputs=vav_pipelines[i - 1].num_inputs,
+            num_outputs=vav_pipelines[i - 1].num_outputs,
+        )
+    )
+
+
+all_data = pd.read_csv("data/bootstrap_data.csv")
+
+# energy_pipeline_north = EnergyPredictionPipeline(
+#     scaler_path="src/energy_prediction/models/scalerNorth.pkl",
+#     wing="north",
+#     bootstrap_data=all_data,
+# )
+# energy_pipeline_south = EnergyPredictionPipeline(
+#     scaler_path="src/energy_prediction/models/scalerSouth.pkl",
+#     wing="south",
+#     bootstrap_data=all_data,
+# )
+
+# energy_prediction_model_north = EnergyPredictionModel(
+#     model_path=r"src/energy_prediction/models/lstm_energy_north_01.keras"
+# )
+
+# energy_prediction_model_south = EnergyPredictionModel(
+#     model_path=r"src/energy_prediction/models/lstm_energy_south_01.keras"
+# )
 
 
 # Set the layout of the page to 'wide'
@@ -107,10 +154,8 @@ for i in range(4):
         """,
             unsafe_allow_html=True,
         )
-        placeholder["sa_temp"].markdown("**SA temp:**  --  °C")
-        placeholder["ra_temp"].markdown("**RA temp:**  --  °C")
-
-all_data = []
+        placeholder["sa_temp"].markdown("**SA temp:**  --  °F")
+        placeholder["ra_temp"].markdown("**RA temp:**  --  °F")
 
 
 # Temperatures streaming and updates
@@ -118,8 +163,8 @@ def update_status_boxes(df):
     for i in range(4):
         sa_temp = df[f"rtu_00{i+1}_sa_temp"].iloc[-1]
         ra_temp = df[f"rtu_00{i+1}_ra_temp"].iloc[-1]
-        rtu_placeholders[i]["sa_temp"].markdown(f"**SA temp:**  {sa_temp} °C")
-        rtu_placeholders[i]["ra_temp"].markdown(f"**RA temp:**  {ra_temp} °C")
+        rtu_placeholders[i]["sa_temp"].markdown(f"**SA temp:**  {sa_temp} °F")
+        rtu_placeholders[i]["ra_temp"].markdown(f"**RA temp:**  {ra_temp} °F")
 
 
 # Zones
@@ -299,7 +344,7 @@ with st.container():
 distances = []
 
 
-def create_residual_plot(resid_pca_list, rtu_id):
+def create_residual_plot(resid_pca_list, rtu_id, lim=8):
     if rtu_id % 2 == 1:
         ax1 = 0
         ax2 = 1
@@ -314,8 +359,8 @@ def create_residual_plot(resid_pca_list, rtu_id):
         height=500,
     )
     fig.update_layout(
-        xaxis_range=[-8, 8],
-        yaxis_range=[-8, 8],
+        xaxis_range=[-lim, lim],
+        yaxis_range=[-lim, lim],
         xaxis=dict(showgrid=True, gridwidth=1, gridcolor="lightgray"),
         yaxis=dict(showgrid=True, gridwidth=1, gridcolor="lightgray"),
         margin=dict(l=20, r=20, t=20, b=20),
@@ -334,17 +379,16 @@ def create_residual_plot(resid_pca_list, rtu_id):
 
 resid_placeholder = st.empty()
 
+resid_vav_placeholder = st.empty()
 
 while True:
 
     if mqtt_client.data_list:
-        all_data.extend(mqtt_client.data_list)
-        if len(all_data) > 100:
-            all_data.pop(0)
-        df = pd.DataFrame(all_data)
+        all_data = pd.concat([all_data, pd.DataFrame(mqtt_client.data_list)], axis=0)
+        if len(all_data) > 10080:
+            all_data = all_data.iloc[-10080:]
 
-        if sum(list(rtu_1_thresholds)) > 50:
-            rtu_1_fault = True
+        df = pd.DataFrame(all_data)
 
         df_time = df["date"].iloc[-1]  # Obtain the latest datetime of data
 
@@ -360,59 +404,94 @@ while True:
         update_status_boxes(df)
 
         dist = None
-        resid_pca_list = None
-        resid_pca_list_2 = None
+        resid_pca_list_rtu = None
+        resid_pca_list_rtu_2 = None
+        resid_pca_list_vav_1 = None
 
         df_new1, df_trans1, df_new2, df_trans2 = rtu_data_pipeline.fit(
             pd.DataFrame(mqtt_client.data_list)
         )
+
+        vav_1_df_new, vav_1_df_trans = vav_pipelines[0].fit(
+            pd.DataFrame(mqtt_client.data_list)
+        )
+        vav_anomalizers[0].num_inputs = vav_pipelines[0].num_inputs
+        vav_anomalizers[0].num_outputs = vav_pipelines[0].num_outputs
+
         if (
             not df_new1 is None
             and not df_trans1 is None
             and not df_new2 is None
             and not df_trans2 is None
         ):
-            actual_list, pred_list, resid_list, resid_pca_list, dist, over_threshold = (
-                rtu_anomalizer1.pipeline(df_new1, df_trans1, rtu_data_pipeline.scaler1)
+            (
+                actual_list,
+                pred_list,
+                resid_list,
+                resid_pca_list_rtu,
+                dist,
+                over_threshold,
+            ) = rtu_anomalizers[0].pipeline(
+                df_new1, df_trans1, rtu_data_pipeline.scaler1
             )
             (
                 actual_list_2,
                 pred_list_2,
                 resid_list_2,
-                resid_pca_list_2,
+                resid_pca_list_rtu_2,
                 dist_2,
                 over_threshold_2,
-            ) = rtu_anomalizer1.pipeline(df_new1, df_trans1, rtu_data_pipeline.scaler1)
+            ) = rtu_anomalizers[1].pipeline(
+                df_new1, df_trans1, rtu_data_pipeline.scaler1
+            )
+        if not vav_1_df_new is None:
+            (
+                actual_list_vav_1,
+                pred_list_vav_1,
+                resid_list_vav_1,
+                resid_pca_list_vav_1,
+                dist_vav_1,
+            ) = vav_anomalizers[0].pipeline(
+                vav_1_df_new, vav_1_df_trans, vav_pipelines[0].scaler
+            )
 
-        if resid_pca_list is not None:
-            rtu_1_thresholds.append(over_threshold[0])
-            resid_pca_list = np.array(resid_pca_list)
-            resid_pca_list_2 = np.array(resid_pca_list_2)
+        if resid_pca_list_rtu is not None:
+            resid_pca_list_rtu = np.array(resid_pca_list_rtu)
+            resid_pca_list_rtu_2 = np.array(resid_pca_list_rtu_2)
 
-        if resid_pca_list is not None:
+        if resid_pca_list_rtu is not None:
             with resid_placeholder.container():
                 resid_rtu1_placeholder, resid_rtu2_placeholder = st.columns(2)
                 with resid_rtu1_placeholder:
                     st.subheader("RTU 1 Residuals")
-                    fig = create_residual_plot(resid_pca_list, rtu_id=1)
+                    fig = create_residual_plot(resid_pca_list_rtu, rtu_id=1)
                     st.plotly_chart(fig)
 
                 with resid_rtu2_placeholder:
                     st.subheader("RTU 2 Residuals")
-                    fig = create_residual_plot(resid_pca_list, rtu_id=2)
+                    fig = create_residual_plot(resid_pca_list_rtu, rtu_id=2)
                     st.plotly_chart(fig)
 
                 resid_rtu3_placeholder, resid_rtu4_placeholder = st.columns(2)
                 with resid_rtu3_placeholder:
                     st.subheader("RTU 3 Residuals")
-                    fig = create_residual_plot(resid_pca_list, rtu_id=3)
+                    fig = create_residual_plot(resid_pca_list_rtu, rtu_id=3)
                     st.plotly_chart(fig)
 
                 with resid_rtu4_placeholder:
                     st.subheader("RTU 4 Residuals")
-                    fig = create_residual_plot(resid_pca_list, rtu_id=4)
+                    fig = create_residual_plot(resid_pca_list_rtu, rtu_id=4)
                     st.plotly_chart(fig)
 
+        if resid_pca_list_vav_1 is not None:
+            print(resid_pca_list_vav_1)
+            with resid_vav_placeholder.container():
+                st.subheader("VAV 1 Residuals")
+                fig = create_residual_plot(
+                    np.array(resid_pca_list_vav_1), rtu_id=1, lim=15
+                )
+                st.plotly_chart(fig)
+
         # with north_wing_energy_container:
         #     df_energy = generate_energy_data()  # ---- REPLACE WITH ACTUAL DATA ----
         #     fig, ax = plt.subplots(figsize=(5, 1.5))

physLSTM/kmeans_vav_2.pkl

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

physLSTM/lstm_vav_rtu1.ipynb

@@ -334,7 +334,7 @@
     "\n",
     "checkpoint_path = \"lstm_vav_01.keras\"\n",
     "checkpoint_callback = ModelCheckpoint(filepath=checkpoint_path, monitor='val_loss', verbose=1, save_best_only=True, mode='min')\n",
-    "model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=128, verbose=1, callbacks=[checkpoint_callback])"
+    "# model.fit(X_train, y_train, validation_data=(X_test, y_test), epochs=3, batch_size=128, verbose=1, callbacks=[checkpoint_callback])"
    ]
   },
   {
@@ -450,26 +450,45 @@
     "idx_to_col"
    ]
   },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "test_predict1_unscaled = test_predict1*scaler.scale_[0:31] + scaler.mean_[0:31]\n",
+    "y_test_unscaled = y_test*scaler.scale_[0:31] + scaler.mean_[0:31]"
+   ]
+  },
   {
    "cell_type": "code",
    "execution_count": 84,
    "metadata": {},
    "outputs": [],
    "source": [
-    "%matplotlib qt\n",
-    "plt.figure()\n",
-    "var = 10\n",
-    "plt.plot(y_test[:,var], label='Original Testing Data', color='blue')\n",
-    "plt.plot(test_predict1[:,var], label='Predicted Testing Data', color='red',alpha=0.8)\n",
-    "anomalies = np.where(abs(test_predict1[:,var] - y_test[:,var]) > 0.5)\n",
-    "plt.scatter(anomalies,test_predict1[anomalies,var], color='black',marker =\"o\",s=100 )\n",
-    "\n",
-    "\n",
-    "plt.title('Testing Data - Predicted vs Actual')\n",
-    "plt.xlabel('Time')\n",
-    "plt.ylabel('Value')\n",
-    "plt.legend()\n",
-    "plt.show()"
+    "%matplotlib inline\n",
+    "var = 0\n",
+    "\n",
+    "df = pd.DataFrame([testdataset_df.index[31:],test_predict1_unscaled[:,var], y_test_unscaled[:,var]] ).T\n",
+    "fig, ax = plt.subplots(figsize=(10,8))\n",
+    "df.plot(x = 0, y=1, ax = ax, label = 'Predicted')\n",
+    "df.plot(x = 0, y=2, ax = ax, label = 'Actual')\n",
+    "\n",
+    "anomalies = df.where(df[1]-df[2]>0.38)[0]\n",
+    "df['anomalies'] = anomalies\n",
+    "\n",
+    "df_new = df.dropna()\n",
+    "\n",
+    "df_new.plot.scatter(x='anomalies', y=1,  c='r', ax = ax, label = 'Anomalies')\n",
+    "\n",
+    "# ax.scatter(anomalies,test_predict1[anomalies,var], color='black',marker =\"o\",s=100 )\n",
+    "\n",
+    "\n",
+    "ax.set_title('Testing Data - Predicted vs Actual [Zone 72 Temperature]', fontsize=20)\n",
+    "ax.set_xlabel('Time', fontsize=15)\n",
+    "ax.set_ylabel('Value', fontsize = 15)\n",
+    "ax.legend(fontsize = 15)\n",
+    "fig.tight_layout()"
    ]
   },
   {
@@ -538,30 +557,32 @@
     "\n",
     "k = 2\n",
     "\n",
+    "pca = PCA(n_components=2)\n",
+    "X = pca.fit_transform(X)\n",
+    "\n",
     "kmeans = KMeans(n_clusters=k)\n",
     "\n",
     "kmeans.fit(X)\n",
     "\n",
     "\n",
-    "pca = PCA(n_components=2)\n",
-    "X = pca.fit_transform(X)\n",
-    "\n",
-    "\n",
     "\n",
     "# Getting the cluster centers and labels\n",
     "centroids = kmeans.cluster_centers_\n",
-    "centroids = pca.transform(centroids)\n",
+    "# centroids = pca.transform(centroids)\n",
     "labels = kmeans.labels_\n",
     "\n",
     "# Plotting the data points and cluster centers\n",
     "plt.scatter(X[:, 0], X[:, 1], c=labels, cmap='viridis', alpha=0.5)\n",
     "plt.scatter(centroids[:, 0], centroids[:, 1], marker='x', c='red', s=200, linewidths=2)\n",
+    "plt.text(centroids[0,0]+0.2, centroids[0,1]+0.5, 'Normal', fontsize=12, color='red')\n",
+    "plt.text(centroids[1,0]+0.5, centroids[1,1]+0.2, 'Anomaly', fontsize=12, color='red')\n",
     "plt.title('KMeans Clustering')\n",
     "plt.xlabel('Feature 1')\n",
     "plt.ylabel('Feature 2')\n",
-    "plt.show()\n",
+    "plt.tight_layout()\n",
     "\n",
-    "joblib.dump(kmeans, 'kmeans_vav_1.pkl')"
+    "joblib.dump(kmeans, 'kmeans_vav_2.pkl')\n",
+    "joblib.dump(pca, 'pca_vav_2.pkl')"
    ]
   },
   {

physLSTM/pca_vav_2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00484ce0c76fc9df1f8f119325a12ec7be5baf8879d4ac192448b2d7ba397c7e
+size 1323

physLSTM/scaler_vav_1.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:293ee3c9082e7104dfc96425cecad2a44e5914bbd1f43c25a0fd8c36507b103a
+size 1925

src/energy_prediction/{EnergyPredictionNorth.py → EnergyPredictionModel.py}

@@ -2,13 +2,13 @@ import numpy as np
 import pandas as pd
 from tensorflow.keras.models import load_model
 
-class EnergyPredictionNorth:
+
+class EnergyPredictionModel:
     """
     Class for predicting energy consumption in the north wing of the building.
     """
 
-    def __init__(self, 
-                 model_path=None):
+    def __init__(self, model_path=None):
         """
         Initialize the EnergyPredictionNorth object.
 
@@ -38,15 +38,14 @@ class EnergyPredictionNorth:
             np.ndarray: Predicted energy consumption values.
         """
         return self.model.predict(data, verbose=0)
-    
-    def inverse_transform(self, scaler, pred, df_trans):
+
+    def inverse_transform(self, scaler, pred):
         """
         Inverse transform the predicted and actual values.
 
         Args:
             scaler (object): Scaler object for inverse transformation.
             pred (array): Predicted values.
-            df_trans (DataFrame): Transformed input data.
 
         Returns:
             tuple: A tuple containing the actual and predicted values after inverse transformation.
@@ -54,6 +53,23 @@ class EnergyPredictionNorth:
         mean = scaler.mean_[0]
         std = scaler.scale_[0]
 
-        pred    = pred * std + mean    
-        actual  = df_trans[:,0] * std + mean
-        return actual, pred
+        pred = pred * std + mean
+        # actual  = df_trans[:,0] * std + mean
+        return pred
+
+    def pipeline(self, data, scaler):
+        """
+        Run the prediction pipeline.
+
+        Args:
+            df (pd.DataFrame): Input data for prediction.
+            scaler (object): Scaler object for inverse transformation.
+
+        Returns:
+            tuple: A tuple containing the actual and predicted values after inverse transformation.
+        """
+
+        pred = self.predict(data)
+        pred_scaled = self.inverse_transform(scaler, pred)
+
+        return pred_scaled

src/energy_prediction/EnergyPredictionPipeline.py

@@ -6,78 +6,89 @@ import joblib
 import json
 import numpy as np
 
+
 class EnergyPredictionPipeline:
-    scalerNorth = None 
-    scalerSouth = None 
-
-    def __init__(self, scaler1_path=None,scaler2_path=None):
-        
-        if scaler1_path:
-            self.scalerNorth = self.get_scaler(scaler1_path)
-        if scaler2_path:
-            self.scalerSouth = self.get_scaler(scaler2_path)
-        
-        self.input_col_names = self.input_col_names + [
-            "date",
-            "hvac_N"
-            ]
-     
+    scaler = None
+
+    def __init__(
+        self, scaler_path=None, wing="north", bootstrap_data: pd.DataFrame = None
+    ):
+
+        if scaler_path:
+            self.scaler = self.get_scaler(scaler_path)
+
+        if wing == "north":
+            self.input_col_names = ["date", "hvac_N"]
+        elif wing == "south":
+            self.input_col_names = ["date", "hvac_S"]
+
+        self.df = bootstrap_data[self.input_col_names]
+
     def get_scaler(self, scaler_path):
         return joblib.load(scaler_path)
-    
+
     def transform_windows(self, df):
-        return self.scalerNorth.transform(df)
+        return self.scaler.transform(df)
+
+    def add_dimension(self, df):
+        return df.reshape((1, df.shape[0], df.shape[1]))
+
+    def convert_nan(self, df):
+        return np.nan_to_num(df)
+
+    def date_encoder(self, df):
 
-    def date_encoder(df):
+        df["day_of_week"] = df.index.dayofweek
+        df["hour_of_day"] = df.index.hour
+        df["month"] = df.index.month
 
-        df['day_of_week']  = df.index.dayofweek
-        df['hour_of_day']  = df.index.hour
-        df['month']        = df.index.month
+        df["day_encoding"] = np.sin(2 * np.pi * df["day_of_week"] / 7)
+        df["hour_encoding"] = np.sin(2 * np.pi * df["hour_of_day"] / 24)
+        df["month_encoding"] = np.sin(2 * np.pi * df["month"] / 12)
 
-        df['day_encoding'] = np.sin(2*np.pi*df['day_of_week']/7)
-        df['hour_encoding'] = np.sin(2*np.pi*df['hour_of_day']/24)
-        df['month_encoding'] = np.sin(2*np.pi*df['month']/12)
+        df.drop(columns=["day_of_week", "hour_of_day", "month"], inplace=True)
 
         return df
-    
-    def prepare_input(self, df_new):
-        
-        df = df_new.copy()
+
+    def prepare_input(self, df1):
+
+        df = df1.copy()
         df["date"] = pd.to_datetime(df["date"])
         df.set_index("date", inplace=True)
-        df = df.resample("H").mean()
-        
+        df = df.resample("60T").mean()
         df = self.date_encoder(df)
-
         df.reset_index(inplace=True, drop=True)
+        df = df.astype("float32")
+        df = df.iloc[-24 * 7 :]
 
         return df
-    
-    def extract_data_from_message(self, message):
-        payload = json.loads(message.payload.decode())
 
-        len_df = len(self.df)
+    def extract_data_from_message(self, df):
+        df = df[self.input_col_names]
+        self.df = pd.concat([self.df, df], axis=0)
 
-        k = {}
-        for col in self.input_col_names:
-            k[col] = payload[col]
-        self.df.loc[len_df] = k
         return self.df
-      
+
     def get_window(self, df):
-        len_df = len(df)
-        print(len_df)
-        if len_df > 4*7*24:
-            return df[len_df - 673 : len_df].astype("float32")
+
+        time = df["date"].iloc[-1]
+        time = datetime.strptime(time, "%Y-%m-%d %H:%M:%S")
+
+        if time.minute == 0 & time.second == 0:
+            return df
         else:
             return None
-        
+
     def fit(self, message):
-        df_new      = self.extract_data_from_message(message)
-        df_window   = self.get_window(df_new)
+        df_new = self.extract_data_from_message(message)
+        df_window = self.get_window(df_new)
         if df_window is not None:
             df = self.prepare_input(df_window)
             df = self.transform_windows(df)
+            df = self.convert_nan(df)
+            df = self.add_dimension(df)
+
         else:
             df = None
-        return df
+
+        return df

src/energy_prediction/models/scalerSouth.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:28b4ee66e0160ad1c033e33728ea5b349a168c9070fa6e813184c63dd7ba3e52
+size 689

src/energy_prediction/test_main.py

@@ -0,0 +1,43 @@
+from energy_prediction.EnergyPredictionModel import EnergyPredictionModel
+from energy_prediction.EnergyPredictionPipeline import EnergyPredictionPipeline
+import paho.mqtt.client as mqtt
+import json
+
+broker_address = "localhost"
+broker_port = 1883
+topic = "sensor_data"
+client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2)
+
+def main():
+    prediction_data_pipeline_north = EnergyPredictionPipeline(scaler_path="src\energy_prediction\models\scalerNorth.pkl", wing='north')
+    prediction_data_pipeline_south = EnergyPredictionPipeline(scaler_path="src\energy_prediction\models\scalerSouth.pkl", wing='south')
+
+    # Energy Prediction North wing
+    energy_prediction_north = EnergyPredictionModel(
+        model_path="src/energy_prediction/models/lstm_energy_north_01.keras"
+    )
+    # Energy Prediction South wing
+    energy_prediction_south = EnergyPredictionModel(
+        model_path="src/energy_prediction/models/lstm_energy_south_01.keras"
+    )
+
+    def on_message(client, userdata, message):
+        dfN = prediction_data_pipeline_north.fit(message)
+        dfS = prediction_data_pipeline_south.fit(message)
+        
+        if not(dfN is None and dfS is None):
+            outN = energy_prediction_north.pipeline(dfN, prediction_data_pipeline_north.scaler)
+            outS = energy_prediction_south.pipeline(dfS, prediction_data_pipeline_south.scaler)
+            return outN, outS
+        else:
+            return None
+        
+    print("Connecting to broker")
+    client.on_message = on_message
+    client.connect(broker_address, broker_port)
+    client.subscribe(topic)
+    client.loop_forever()
+
+if __name__ == "__main__":
+    main()
+    

src/vav/VAVAnomalizer.py

@@ -1,4 +1,6 @@
 import numpy as np
+from sklearn.cluster import KMeans
+from sklearn.decomposition import PCA
 from tensorflow.keras.models import load_model
 import joblib
 
@@ -9,6 +11,7 @@ class VAVAnomalizer:
         rtu_id,
         prediction_model_path,
         clustering_model_path,
+        pca_model_path,
         num_inputs,
         num_outputs,
     ):
@@ -18,6 +21,7 @@ class VAVAnomalizer:
         Args:
             rtu_id (int): The ID of the RTU (Roof Top Unit) associated with the VAV (Variable Air Volume) system.
             prediction_model_path (str): The file path to the prediction model.
+            pca_model_path (str): The file path to the PCA model.
             clustering_model_path (str): The file path to the clustering model.
             num_inputs (int): The number of input features for the prediction model.
             num_outputs (int): The number of output features for the prediction model.
@@ -25,18 +29,23 @@ class VAVAnomalizer:
         self.rtu_id = rtu_id
         self.num_inputs = num_inputs
         self.num_outputs = num_outputs
-        self.load_models(prediction_model_path, clustering_model_path)
+        self.load_models(prediction_model_path, clustering_model_path, pca_model_path)
+        self.actual_list, self.pred_list, self.resid_list, self.resid_pca_list = (
+            self.initialize_lists()
+        )
 
-    def load_models(self, prediction_model_path, clustering_model_path):
+    def load_models(self, prediction_model_path, clustering_model_path, pca_model_path):
         """
         Loads the prediction model and clustering model.
 
         Args:
             prediction_model_path (str): The file path to the prediction model.
+            pca_model_path (str): The file path to the PCA model.
             clustering_model_path (str): The file path to the clustering model.
         """
         self.model = load_model(prediction_model_path)
-        self.kmeans_model = joblib.load(clustering_model_path)
+        self.pca_model: PCA = joblib.load(pca_model_path)
+        self.kmeans_model: KMeans = joblib.load(clustering_model_path)
 
     def initialize_lists(self, size=30):
         """
@@ -48,8 +57,14 @@ class VAVAnomalizer:
         Returns:
             tuple: A tuple containing three lists initialized with zeros.
         """
-        initial_values = [0] * size
-        return initial_values.copy(), initial_values.copy(), initial_values.copy()
+        initial_values = [[0] * self.num_outputs] * size
+        initial_values1 = [[0] * 2] * size
+        return (
+            initial_values.copy(),
+            initial_values.copy(),
+            initial_values.copy(),
+            initial_values1.copy(),
+        )
 
     def predict(self, df_new):
         """
@@ -76,7 +91,7 @@ class VAVAnomalizer:
             numpy.ndarray: The residuals.
         """
         actual = df_trans[30, : self.num_outputs]
-        resid = actual - pred
+        resid = pred - actual
         return actual, resid
 
     def calculate_distances(self, resid):
@@ -90,10 +105,27 @@ class VAVAnomalizer:
             array: Array of distances.
         """
         dist = []
-        dist.append(np.linalg.norm(resid - self.kmeans_model.cluster_centers_[0]))
+        dist.append(
+            np.linalg.norm(
+                self.pca_model.transform(resid.reshape(1, -1))
+                - self.kmeans_model.cluster_centers_[0]
+            )
+        )
 
         return np.array(dist)
 
+    def residual_pca(self, resid):
+        """
+        Perform PCA on the residuals.
+
+        Args:
+            resid (array): Residual values.
+
+        Returns:
+            array: Transformed residuals.
+        """
+        return self.pca_model.transform(resid.reshape(1, -1))
+
     def resize_prediction(self, pred, df_trans):
         """
         Resize the predicted values to match the shape of the transformed input data.
@@ -129,7 +161,7 @@ class VAVAnomalizer:
         actual = scaler.inverse_transform(np.array([df_trans[30, :]]))
         return actual, pred
 
-    def update_lists(self, actual_list, pred_list, resid_list, actual, pred, resid):
+    def update_lists(self, actual, pred, resid, resid_pca):
         """
         Update the lists of actual, predicted, and residual values.
 
@@ -137,6 +169,7 @@ class VAVAnomalizer:
             actual_list (list): List of actual values.
             pred_list (list): List of predicted values.
             resid_list (list): List of residual values.
+            resid_pca_list (list): List of PCA-transformed residual values.
             actual (array): Actual values.
             pred (array): Predicted values.
             resid (array): Residual values.
@@ -144,13 +177,15 @@ class VAVAnomalizer:
         Returns:
             tuple: A tuple containing the updated lists of actual, predicted, and residual values.
         """
-        actual_list.pop(0)
-        pred_list.pop(0)
-        resid_list.pop(0)
-        actual_list.append(actual[0, 1])
-        pred_list.append(pred[0, 1])
-        resid_list.append(resid[0, 1])
-        return actual_list, pred_list, resid_list
+        self.actual_list.pop(0)
+        self.pred_list.pop(0)
+        self.resid_list.pop(0)
+        self.resid_pca_list.pop(0)
+        self.actual_list.append(actual.flatten().tolist())
+        self.pred_list.append(pred.flatten().tolist())
+        self.resid_list.append(resid.flatten().tolist())
+        self.resid_pca_list.append(resid_pca.flatten().tolist())
+        return self.actual_list, self.pred_list, self.resid_list, self.resid_pca_list
 
     def pipeline(self, df_new, df_trans, scaler):
         """
@@ -164,13 +199,13 @@ class VAVAnomalizer:
         Returns:
             tuple: A tuple containing the lists of actual, predicted, and residual values, and the distances.
         """
-        actual_list, pred_list, resid_list = self.initialize_lists()
         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_list, pred_list, resid_list, actual, pred, resid
+        resid_pca = self.residual_pca(resid)
+        actual_list, pred_list, resid_list, resid_pca_list = self.update_lists(
+            actual, pred, resid, resid_pca
         )
         dist = self.calculate_distances(resid)
-        return actual_list, pred_list, resid_list, dist
+        return actual_list, pred_list, resid_list, resid_pca_list, dist

src/vav/VAVPipeline.py

@@ -39,28 +39,7 @@ class VAVPipeline:
         if rtu_id == 1:
             self.zones = [69, 68, 67, 66, 65, 64, 42, 41, 40, 39, 38, 37, 36]
         if rtu_id == 2:
-            self.zones = [
-                72,
-                71,
-                63,
-                62,
-                60,
-                59,
-                58,
-                57,
-                50,
-                49,
-                44,
-                43,
-                35,
-                34,
-                33,
-                32,
-                31,
-                30,
-                29,
-                28,
-            ]
+            self.zones = [72, 71, 63, 62, 60, 59, 58,57, 50, 49, 44, 43, 35, 34, 33, 32, 31, 30, 29, 28]
 
         self.output_col_names = []
         self.input_col_names = [
@@ -171,7 +150,7 @@ class VAVPipeline:
         self.num_outputs = len(self.output_col_names)
         self.df = pd.DataFrame(columns=self.column_names)
 
-    def extract_data_from_message(self, message):
+    def extract_data_from_message(self, df: pd.DataFrame):
         """
         Extracts data from the message payload and returns a dataframe.
 
@@ -181,17 +160,27 @@ class VAVPipeline:
         Returns:
             pd.DataFrame: The extracted data as a dataframe.
         """
-        payload = json.loads(message.payload.decode())
-        df = pd.DataFrame.from_dict(payload, orient="index").T
         if self.get_cols == True:
             self.get_input_output(df)
             self.get_cols = False
+
         df = df[self.column_names]
-        self.df.loc[len(self.df)] = df.values[0]
 
-        return self.df
+        len_df = len(self.df)
+
+        if len_df != 0:
+            self.df = pd.concat([self.df, df], axis=0)
+        else:
+            self.df = df
 
-    def fit(self, message):
+        if len_df > 31:
+            self.df = self.df.iloc[len_df - 31 : len_df]
+            self.df.loc[len_df] = self.df.mean()
+            return self.df
+        else:
+            return None
+
+    def fit(self, df: pd.DataFrame):
         """
         Fits the model with the extracted data and returns the prepared input and transformed data.
 
@@ -201,12 +190,12 @@ class VAVPipeline:
         Returns:
             tuple: A tuple containing the prepared input and transformed data.
         """
-        df = self.extract_data_from_message(message)
+        df_window = self.extract_data_from_message(df)
 
-        df_window = self.get_window(df)
         if df_window is not None:
             df_trans = self.transform_window(df_window)
             df_new = self.prepare_input(df_trans)
+
         else:
             df_new = None
             df_trans = None

src/vav/models/kmeans_vav_1.pkl

@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:086d45b9d2c98baaea5b0588cd6d228d84eb141b707fe845b11316b3ddc58774
-size 1568153
+oid sha256:eac01ceecdae11713ee21462a8bd3dc7ea32e740c3daa42795b266a05e7c424a
+size 1567961

src/vav/models/kmeans_vav_2.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:874aa63843989880be0b133e3de125c60ec4290146e152685a0ba09faf101f71
+size 1567961

src/vav/models/kmeans_vav_3.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:086d45b9d2c98baaea5b0588cd6d228d84eb141b707fe845b11316b3ddc58774
+size 1568153

src/vav/models/kmeans_vav_4.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:086d45b9d2c98baaea5b0588cd6d228d84eb141b707fe845b11316b3ddc58774
+size 1568153

src/vav/models/pca_vav_1.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:00484ce0c76fc9df1f8f119325a12ec7be5baf8879d4ac192448b2d7ba397c7e
+size 1323

src/vav/models/pca_vav_2.pkl

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

src/vav/models/scaler_vav_3.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:293ee3c9082e7104dfc96425cecad2a44e5914bbd1f43c25a0fd8c36507b103a
+size 1925

src/vav/models/scaler_vav_4.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:293ee3c9082e7104dfc96425cecad2a44e5914bbd1f43c25a0fd8c36507b103a
+size 1925