modnn 3.0.2__tar.gz → 3.0.4__tar.gz

{modnn-3.0.2 → modnn-3.0.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modnn
-Version: 3.0.2
+Version: 3.0.4
 Summary: Physics-Informed Modularized Neural Network for Building Energy Modeling
 Author-email: Zixin Jiang <zjiang19@syr.edu>
 License-Expression: MIT

modnn-3.0.4/Update_Log.md

@@ -0,0 +1,36 @@
+# 🧠 Update log
+
+# 🧠 [2.0.0] 2025 May 9
+To further improve physical consistency, 
+
+I replaced heat transfer module by set of energy balance equations, 
+
+Start from version 2.0.0
+
+# 🧠 [2.0.1] 2025 May 10
+Add another parameter: "envelop_mdl", 
+
+Allow user to use the new physics based module or previous data driven module. 
+
+# 🧠 [2.0.2] 2025 May 10
+Fix bug due to parameter: "envelop_mdl",
+
+Vectorize calculation,speed improved by ~6 times.
+
+# 🧠 [3.0.0] 2025 June 11
+Update datadriven modnn
+RC based envelop_mdl really hard to tune on new dataset
+
+# 🧠 [3.0.1] 2025 June 11
+Add a step function for one step ahead prediction
+
+# 🧠 [3.0.2] 2025 June 11
+Fix bug for step function
+
+# 🧠 [3.0.3] 2025 June 11
+Fix bug for step function
+
+# 🧠 [3.0.4] 2025 Sept 10
+Didn't work on it for 3 months, just update the latest version
+Will use it for BESTOpt building dynamic model
+

{modnn-3.0.2 → modnn-3.0.4}/modnn/Config.py

@@ -8,10 +8,10 @@ def _paras(**kwargs):
         "Int_in": 3, "Int_h": 12, "Int_out": 1,
 
         # External disturbance module
-        "Ext_in": 1, "Ext_h": 10, "Ext_out": 1,
+        "Ext_in": 2, "Ext_h": 18, "Ext_out": 1,
 
         # Zone module
-        "Zone_in": 1, "Zone_out": 1,
+        "Zone_in": 1, "Zone_h": 12, "Zone_out": 1,
 
         # HVAC module
         "HVAC_in": 1, "HVAC_out": 1,
@@ -22,14 +22,16 @@ def _paras(**kwargs):
         # LSTM baseline
         "LSTM_h" : 24,
 
-        "en_policy_in":3, "en_policy_hidden":24, "en_policy_out":1,
-        "de_policy_in":6, "de_policy_hidden":24, "de_policy_out":1,
+        "current_meas_dim": 7,
+        "future_disturbance_dim": 6,
+        "horizon": 96,
+        "hidden_dim": 256,
         "policy_epochs":200, "policy_lr":0.01,
 
         # Training hyperparameters
         "lr": 0.01,
         "epochs": 30,
-        "patience": 3, #Early stop
+        "patience": 6, #Early stop
     }
 
     # Allow override from kwargs
@@ -77,6 +79,7 @@ def _args(**kwargs):
         # "datapath": "/home/zjiang19/Documents/GitHub/Eplus_ModNN_Compare/dataset/Eplus/EPlus_train_case1.csv",
         # "datapath": "/home/zjiang19/Documents/GitHub/Physical-Incorporated-Neural-Network-BEM/update/403_new_dyn.csv",
         "datapath": "/home/zjiang19/Documents/GitHub/ModNN-RL-403/dataset/Data_Process/data_coe_update.csv",
+        # "datapath":"/home/zjiang19/Documents/GitHub/BEST_OPT/dataset/dataset_1.csv",
         "device": "cuda:1",
         "save_name": "Eplus",
 
@@ -86,8 +89,8 @@ def _args(**kwargs):
         "resolution": 15, # 15 minutes data
         "enLen": 48, # "Kind of warm-up"
         "deLen": 96, # Prediction horizon, 96 is for 24 hours
-        "startday": 390, # Training data selection
-        "trainday": 90, # Training data selection
+        "startday": 384, # Training data selection
+        "trainday": 180, # Training data selection
         "testday": 1, # Testing data selection
         "training_batch": 1024*1,
         "multi_deLen": [4, 8, 16, 24, 32, 48],
@@ -96,7 +99,7 @@ def _args(**kwargs):
         "ext_mdl": "RNN", # We provide LSTM and RNN module, for RNN, we can apply positive constraint easily
                            # But LSTM has Hadamard product, making this constraint hard to integrate
                            # However, disturbance variables always have similiar distribution, in other word, is this constraint really necessary?
-        "plott": '-all', # all: If want to see how model response to max heating/cooling; else: only Tzone prediction
+        "plott": 'all', # all: If want to see how model response to max heating/cooling; else: only Tzone prediction
         "modeltype": 'PI-modnn', # We also have "LSTM", "PI-modnn", "PI-modnn|C", "PI-modnn|L", "PI-modnn|LC" for fun
                                  # LSTM is the baseline, |C means no constraints, |L means no loss adjustment
         "scale": 1, # scaling factor for HVAC power

{modnn-3.0.2 → modnn-3.0.4}/modnn/Dataset.py

@@ -92,6 +92,8 @@ class DataCook:
         else:
             try:
                 self.df = pd.read_csv(self.args["datapath"], index_col=[0])
+                self.df['temp_room'] = (self.df['temp_room']-32)*5/9
+
             except:
                 print("Input error")
 

{modnn-3.0.2 → modnn-3.0.4}/modnn/Models/ModNN_data.py

@@ -17,6 +17,20 @@ class zone(nn.Module):
     def forward(self, x):
         return self.scale(x)
 
+# --- Zone Module ---
+# class zone(nn.Module):
+#     def __init__(self, input_size, hidden_size, output_size, num_layers=1):
+#         super(zone, self).__init__()
+#         self.dym = nn.RNN(input_size=input_size, hidden_size=hidden_size,
+#                                           num_layers=num_layers, batch_first=True, bias=True)
+#         self.fc = nn.Linear(hidden_size, output_size)
+#
+#     def forward(self, deltaq, hidden):
+#         Tpred, hidden = self.dym(deltaq, hidden)
+#         out = self.fc(Tpred)
+#
+#         return out, hidden
+
 # --- Internal Gain Module ---
 class internal(nn.Module):
     """
@@ -165,8 +179,9 @@ class external(nn.Module):
         self.hidden_size = hidden_size
 
     def forward(self, x_input, hidden_state):
-        ext_mdl_out, hidden = self.ext_mdl((x_input[:, :, [1]] - x_input[:, :, [0]]), hidden_state)
-        # ext_mdl_out, hidden = self.ext_mdl((x_input[:, :, [0,1]]), hidden_state)
+        # Need more work to explore weather we input the deltaT or just Tamb and Tspace toghether
+        # ext_mdl_out, hidden = self.ext_mdl((x_input[:, :, [1]] - x_input[:, :, [0]]), hidden_state)
+        ext_mdl_out, hidden = self.ext_mdl((x_input[:, :, [0,1]]), hidden_state)
         last_output = ext_mdl_out[:, -1:, :]
         out = self.relu(self.fc1(last_output))
         out = self.fc2(out)
@@ -177,6 +192,29 @@ class external(nn.Module):
 
         return out, hidden+solargain.permute(1, 0, 2)
 
+class external_CNN(nn.Module):
+    """
+    CNN-based External Module to learn heat gain from T_zone, T_ambient, and Solar radiation.
+    Models thermal lag with a convolution kernel of 6 hours (24 time steps).
+    """
+
+    def __init__(self, input_channels=3, kernel_size=24):
+        super(external_CNN, self).__init__()
+        self.conv1 = nn.Conv1d(in_channels=input_channels, out_channels=8,
+                               kernel_size=kernel_size, padding=0, bias=False)
+        self.relu = nn.ReLU()
+        self.conv2 = nn.Conv1d(in_channels=8, out_channels=1, kernel_size=1, padding=0, bias=False)
+        self.fc = nn.Linear(1, 1)
+
+    def forward(self, x_input, hidden_state=None):
+        # Input: (batch, window, features) → select 3 features and permute
+        x = x_input[:, :, [0, 1, 2]].permute(0, 2, 1)  # → (B, 3, T)
+        out = self.relu(self.conv1(x))  # → (B, 8, T - k + 1)
+        out = self.relu(self.conv2(out))  # → (B, 1, T - k + 1)
+        out = out[:, :, -1:]  # → take last time step → (B, 1, 1)
+        return self.fc(out.transpose(1, 2)), None  # → (B, 1, 1)
+
+
 # --- Modular Physics-Informed Neural Network ---
 class ModNN(nn.Module):
     """
@@ -189,10 +227,11 @@ class ModNN(nn.Module):
         self.device  = args['device']
         self.window  = para["window"]
         self.ext_mdl = args["ext_mdl"]
-
+        # self.Ext = external_CNN(input_channels=3, kernel_size=para["window"])
         self.Ext = external(para["Ext_in"], para["Ext_h"], para["Ext_out"], self.ext_mdl, para["window"])
         self.Zone = zone(para["Zone_in"], para["Zone_out"])
         self.HVAC = hvac(para["HVAC_in"], para["HVAC_out"])
+        # self.Zone = zone(para["Zone_in"], para["Zone_h"], para["Zone_out"])
         self.Int = internal(para["Int_in"], para["Int_h"], para["Int_out"])
 
     def forward(self, input_X):
@@ -216,6 +255,8 @@ class ModNN(nn.Module):
         else:
             ext_hidd = torch.ones(1, Ext_X.shape[0], self.Ext.ext_mdl.hidden_size).to(self.device)
             ext_cell = torch.ones(1, Ext_X.shape[0], self.Ext.ext_mdl.hidden_size).to(self.device)
+
+        # zone_hidd = torch.ones(1, input_X.shape[0], self.Zone.dym.hidden_size).to(self.device)
         # This is the look back window
         # I strongly suggest to use it, if you are using MLP external module
         # The value if how long you want to look back, typically, larger value for heavy structures
@@ -248,6 +289,7 @@ class ModNN(nn.Module):
                 input_X[:, i-window_size+1:i+1, [0]] * ratio + TOut_list[:, i-window_size+1:i+1, :] * (1 - ratio),
                 Ext_X[:, i-window_size+1:i+1, :]
             ], dim=2)
+            # ext_flux, _ = self.Ext(ext_embed, None)
             if self.ext_mdl == "RNN" or self.ext_mdl == "GRU":
                 ext_flux, ext_hidd = self.Ext(ext_embed, ext_hidd)
             else:
@@ -258,14 +300,17 @@ class ModNN(nn.Module):
             # For a well controlled space, it's not important
             # But if you are interested in extreme case, please add Tzone for Int input
             int_flux = self.Int(Int_X[:, i:i+1, :])
-            total_flux = ext_flux + hvac_flux + int_flux
+            total_flux = ext_flux  + int_flux+ hvac_flux
             HVAC_list[:, i, :] = hvac_flux.squeeze(1)
             Ext_list[:, i, :] = ext_flux.squeeze(1)
             Int_list[:, i, :] = int_flux.squeeze(1)
             deltaQ_list[:, i, :] = total_flux.squeeze(1)
 
             # After get total flux, we can predict the ΔTzone, and use residual connection to predict Tzone step by step
-            E_Zone_T =  input_X[:, i:i+1, [0]] + self.Zone(total_flux)
+            # E_Zone_T =  input_X[:, i:i+1, [0]] + self.Zone(total_flux)
+            # deltaT, zone_hidd = self.Zone(total_flux, zone_hidd)
+            deltaT = self.Zone(total_flux)
+            E_Zone_T =  input_X[:, i:i+1, [0]] + deltaT
 
         # --- Decoding Phase ---
         # Just transfer encoder module here
@@ -281,16 +326,21 @@ class ModNN(nn.Module):
             else:
                 ext_flux, (ext_hidd, ext_cell) = self.Ext(ext_embed, (ext_hidd, ext_cell))
 
+            ext_flux, _ = self.Ext(ext_embed, None)
             hvac_flux = self.HVAC(HVAC_X[:, i:i+1, :])
             int_flux = self.Int(Int_X[:, i:i+1, :])
-            total_flux = ext_flux + hvac_flux + int_flux
+            total_flux = ext_flux  + int_flux+ hvac_flux
 
             HVAC_list[:, i, :] = hvac_flux.squeeze(1)
             Ext_list[:, i, :] = ext_flux.squeeze(1)
             Int_list[:, i, :] = int_flux.squeeze(1)
             deltaQ_list[:, i, :] = total_flux.squeeze(1)
             # No self-learning during decoder stage
-            E_Zone_T = E_Zone_T + self.Zone(total_flux)
+            # E_Zone_T = E_Zone_T + self.Zone(total_flux)
+            # deltaT, zone_hidd = self.Zone(total_flux, zone_hidd)
+            deltaT = self.Zone(total_flux)
+            E_Zone_T = E_Zone_T + deltaT
+
 
         # Return not only temperature, but also latent flux
         # Not sure how to use these fluxes right now, but leave for placeholder
@@ -301,7 +351,7 @@ class ModNN_step(nn.Module):
     We form it as a time-stepper model, in other words, we are predict the ΔTzone for each timestep
     """
     def __init__(self, args):
-        super(ModNN, self).__init__()
+        super(ModNN_step, self).__init__()
         para = args["para"]
         self.encoLen = args["enLen"]
         self.device  = args['device']
@@ -309,7 +359,8 @@ class ModNN_step(nn.Module):
         self.ext_mdl = args["ext_mdl"]
 
         self.Ext = external(para["Ext_in"], para["Ext_h"], para["Ext_out"], self.ext_mdl, para["window"])
-        self.Zone = zone(para["Zone_in"], para["Zone_out"])
+        # self.Zone = zone(para["Zone_in"], para["Zone_out"])
+        self.Zone = zone(para["Zone_in"], para["Zone_h"], para["Zone_out"])
         self.HVAC = hvac(para["HVAC_in"], para["HVAC_out"])
         self.Int = internal(para["Int_in"], para["Int_h"], para["Int_out"])
 

modnn-3.0.4/modnn/Models/PolicyNN.py

@@ -0,0 +1,41 @@
+import torch
+import torch.nn as nn
+
+class Policy(nn.Module):
+    def __init__(self, args):
+        super(Policy, self).__init__()
+        para = args["para"]
+        self.device = args["device"]
+
+        self.horizon = 96
+        input_dim = para["current_meas_dim"] + para["future_disturbance_dim"] * self.horizon
+        hidden_dim = para["hidden_dim"]
+
+        self.model = nn.Sequential(
+            nn.Linear(input_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, hidden_dim),
+            nn.ReLU(),
+            nn.Linear(hidden_dim, self.horizon),
+            nn.Tanh()
+        )
+
+    def forward(self, obs):
+        """
+        obs: [batch, 144, 10]
+        "0.T_zone, 1.T_ambient, 2.solar, 3.day_sin, 4.day_cos,
+        5.occ, 6.phvac, 7.setpt_cool, 8.setpt_heat, 9.price"
+        Returns: [batch, 96] predicted control trajectory
+        """
+
+        # 1. Current measurements at t=47 (T_zone + 6 others)
+        current = obs[:, 47, [0, 1, 2, 5, 7, 8, 9]]  # [batch, 7]
+
+        # 2. Future known disturbances (exclude T_zone and phvac)
+        future = obs[:, 48:, [1, 2, 5, 7, 8, 9]]  # [batch, 96, 6]
+        future = future.reshape(obs.shape[0], -1)  # [batch, 768]
+
+        # Combine
+        x_input = torch.cat([current, future], dim=1)  # [batch, 775]
+
+        return self.model(x_input).unsqueeze(-1)

{modnn-3.0.2 → modnn-3.0.4}/modnn/Play.py

@@ -144,13 +144,17 @@ def train_model(model, train_loader, valid_loader, test_loader, lr, epochs,
                         try:
                             # Positive Hard Constraints
                             model.Zone.scale.weight.data.clamp_(0)
+                            # model.Zone.dym.weight_ih_l0.data.clamp_(0)
+                            # model.Zone.dym.weight_hh_l0.data.clamp_(0)
+                            # model.Zone.fc.weight.data.clamp_(0)
                             model.Int.scale.weight.data.clamp_(0)
                             model.HVAC.scale.weight.data.clamp_(0)
 
 
                             # model.Ext.conduction.weight.data.clamp_(0)
                             if ext_mdl == 'RNN':
-                                model.Ext.rnn.weight.data.clamp_(0)
+                                model.Ext.rnn.weight_ih_l0.data.clamp_(0)
+                                model.Ext.rnn.weight_hh_l0.data.clamp_(0)
                             else:
                                 pass
                         except:
@@ -255,7 +259,7 @@ def train_model(model, train_loader, valid_loader, test_loader, lr, epochs,
                     tem = Temp_out_denorm[timestep][:test_len - timestep]
                     ax.plot_date(rawdf.index[timestep:timestep + pred_len][:test_len - timestep],
                                      tem, '-', linewidth=1, color="gray", label=name)
-                    ax.set_ylim(meas.min()-1, meas.max()+1)
+                    # ax.set_ylim(meas.min()-1, meas.max()+1)
                     # for timestep in [24, 48, 72]:
                     #     tem_other = Temp_out_denorm[timestep][:test_len - timestep]
                     #     tem_other = (tem_other - 32) * 5 / 9
@@ -609,7 +613,7 @@ def control_model(dynamic_mdl, control_mdl, control_loader, args, test_loader, h
                 u_denorm = (u_opt - range_min) / (range_max - range_min) * (data_max - data_min) + data_min
                 price = torch.sum(torch.square(u_denorm/1000*data[:, args['enLen']-1:-1, [9]]))
 
-                to_loss = price*10 + vio
+                to_loss = price + vio*10
                 to_loss.backward()
                 optimizer.step()
 
@@ -618,7 +622,7 @@ def control_model(dynamic_mdl, control_mdl, control_loader, args, test_loader, h
                 price_loss += price.item() * data.size(0)
 
             control_mdl.eval()
-            res = 20
+            res = 10
             if epoch % res == 0:
                 with torch.no_grad():  # No gradients needed
                     for data, _ in test_loader:

{modnn-3.0.2 → modnn-3.0.4}/modnn/run.py

@@ -13,10 +13,11 @@ Mod = Mod(args=args)
 Mod.data_ready()
 Mod.train()
 Mod.load()
+# Mod.load('/home/zjiang19/Documents/GitHub/Physical-Incorporated-Neural-Network-BEM/update/Saved/Eplus/Trained_mdlEnco48_Deco96/PI-modnn_150daysTest_on06-30.pth')
 Mod.test()
 Mod.prediction_show()
 Mod.check()
 Mod.dynamiccheck()
 Mod.check_show()
-
+# Mod.policy_train()
 

{modnn-3.0.2 → modnn-3.0.4}/modnn.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modnn
-Version: 3.0.2
+Version: 3.0.4
 Summary: Physics-Informed Modularized Neural Network for Building Energy Modeling
 Author-email: Zixin Jiang <zjiang19@syr.edu>
 License-Expression: MIT

{modnn-3.0.2 → modnn-3.0.4}/modnn.egg-info/SOURCES.txt

@@ -1,5 +1,6 @@
 LICENSE
 README.md
+Update_Log.md
 pyproject.toml
 modnn/Config.py
 modnn/Dataset.py

{modnn-3.0.2 → modnn-3.0.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "modnn"
-version = "3.0.2"
+version = "3.0.4"
 description = "Physics-Informed Modularized Neural Network for Building Energy Modeling"
 readme = "README.md"
 requires-python = ">=3.7"
@@ -25,3 +25,12 @@ dependencies = [
 
 [tool.setuptools.packages.find]
 include = ["modnn", "modnn.*"]
+
+[tool.setuptools]
+include-package-data = true
+
+[tool.setuptools.package-data]
+mypackage = ["*.md"]
+
+[tool.setuptools.data-files]
+"." = ["Update_Log.md"]

modnn-3.0.2/modnn/Models/PolicyNN.py

@@ -1,75 +0,0 @@
-import torch
-import torch.nn as nn
-import torch.autograd as autograd
-
-
-class LSTM_encoder(nn.Module):
-
-    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
-        super(LSTM_encoder, self).__init__()
-        self.input_size = input_size
-        self.output_size = output_size
-        self.hidden_size = hidden_size
-        self.num_layers = num_layers
-        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
-                           num_layers=num_layers, batch_first=True, bias=True)
-        self.Enfc = nn.Linear(in_features=hidden_size, out_features=output_size, bias=True)
-
-    def forward(self, x_input):
-        lstm_out, self.hidden = self.lstm(x_input)
-        output = self.Enfc(lstm_out)
-
-        return output, self.hidden
-
-    def init_hidden(self, batch_size):
-        return torch.zeros(self.num_layers, batch_size, self.hidden_size)
-
-class LSTM_decoder(nn.Module):
-
-    def __init__(self, input_size, hidden_size, output_size, num_layers=1):
-        super(LSTM_decoder, self).__init__()
-        self.input_size = input_size
-        self.output_size = output_size
-        self.hidden_size = hidden_size
-        self.num_layers = num_layers
-        self.lstm = nn.LSTM(input_size=input_size, hidden_size=hidden_size,
-                           num_layers=num_layers, batch_first=True, bias=True)
-        self.fc = nn.Linear(in_features=hidden_size, out_features=output_size, bias=True)
-
-    def forward(self, x_input, encoder_hidden_states):
-        lstm_out, self.hidden = self.lstm(x_input, encoder_hidden_states)
-        output = self.fc(lstm_out)
-
-        return output
-
-
-class Policy(nn.Module):
-    def __init__(self, args):
-        super().__init__()
-        para = args["para"]
-        self.encoder = LSTM_encoder(input_size=para["en_policy_in"],
-                                    hidden_size=para["en_policy_hidden"],
-                                    output_size=para["en_policy_out"])
-        self.decoder = LSTM_decoder(input_size=para["de_policy_in"],
-                                    hidden_size=para["de_policy_hidden"],
-                                    output_size=para["de_policy_out"])
-        self.device = args['device']
-        self.enLen = args['enLen']
-
-    def forward(self, obs):
-        """
-        0.T_zone, 1.T_ambient, 2.solar, 3.day_sin, 4.day_cos,
-        5.occ, 6.phvac, 7.setpt_cool, 8.setpt_heat, 9.price
-
-        :param input_X:
-        :return: u_opt (96 steps)
-        """
-
-        # Encoder
-        Encoder_X = obs[:, :self.enLen, [0, 1, 2]]
-        # Decoder
-        Decoder_X = obs[:, self.enLen-1:-1, [1, 2, 5, 7, 8, 9]]
-        encoder_out, encoder_hidden = self.encoder(Encoder_X)
-        decoder_out = self.decoder(Decoder_X, encoder_hidden_states = encoder_hidden)
-
-        return torch.tanh(decoder_out)