does something end-to-end

data_processing.py

@@ -43,7 +43,7 @@ def read_datasets(mini=False):
 
 @dataclass
 class Parameters:
-    solar_cell_num: float = 114 # units
+    solar_cell_num: float = 1140 # units
     solar_efficiency: float = 0.93 * 0.96 # [dimensionless]
     NOCT: float = 280 # [W]
     NOCT_irradiation: float = 800 # [W/m^2]

v2/architecture.py

@@ -14,6 +14,7 @@ from evolution_strategies import evolution_strategies_optimizer
 
 DO_VIS = False
 
+
 # we predict last week same time for consumption, and yesterday same time for production.
 # adds fields in-place
 def add_dummy_predictions(all_data_with_predictions):
@@ -52,6 +53,29 @@ def simulator(battery_model, prod_cons, decider):
     step_in_minutes = prod_cons.index.freq.n
     assert step_in_minutes == 5
 
+    '''
+    surdemand_np = demand_np - production_np
+    plt.plot(demand_np, c="r")
+    plt.plot(production_np, c="g")
+    plt.plot(surdemand_np, c="b")
+    plt.show()
+    print("max prod", production_np.max())
+    exit()
+    '''
+
+    '''
+    surdemand_window = 24 * 60 // 5 # one day
+    mean_surdemands_kw = []
+    for i in range(len(demand_prediction_np) - surdemand_window):
+        mean_surdemand_kw = (demand_prediction_np[i: i+surdemand_window] - production_prediction_np[i: i+surdemand_window]).mean()
+        mean_surdemands_kw.append(mean_surdemand_kw)
+    mean_surdemands_kw = pd.Series(mean_surdemands_kw, prod_cons.index[:len(mean_surdemands_kw)])
+    mean_surdemands_kw.plot()
+    plt.title("mean_surdemands_kw")
+    plt.show()
+    exit()
+    '''
+
     consumption_fees_np = prod_cons['Consumption_fees'].to_numpy()
 
     print("Simulating for", len(demand_np), "time steps. Each step is", step_in_minutes, "minutes.")
@@ -157,7 +181,7 @@ def simulator(battery_model, prod_cons, decider):
     fifteen_minute_surdemands_in_kwh = (fifteen_minute_demands_in_kwh - decider.precalculated_supplier.peak_demand).clip(lower=0)
     demand_charges = fifteen_minute_surdemands_in_kwh * decider.precalculated_supplier.surcharge_per_kwh
     total_network_fee = consumption_charge_series.sum() + demand_charges.sum()
-    print(f"All in all we have paid the network {total_network_fee / 10 ** 6} MHUF.")
+    print(f"Total network fee {total_network_fee / 10 ** 6} MHUF.")
 
     if DO_VIS:
         demand_charges.plot()
@@ -176,17 +200,21 @@ def simulator(battery_model, prod_cons, decider):
     return results, total_network_fee
 
 
+
 def optimizer(battery_model, all_data_with_predictions, precalculated_supplier):
     def objective_function(params):
+        print("Simulating with parameters", params)
         # TODO params completely ignored right now.
-        decider = Decider(precalculated_supplier)
+        decider = Decider(params, precalculated_supplier)
         t = time.perf_counter()
         results, total_network_fee = simulator(battery_model, all_data_with_predictions, decider)
         return total_network_fee
 
-    init_mean = np.array([0.0, 0.0])
-    init_scale = np.array([10.0, 10.0])
-    best_params = evolution_strategies_optimizer(objective_function, init_mean=init_mean, init_scale=init_scale)
+    def clipper_function(params):
+        return Decider.clip_params(params)
+
+    init_mean, init_scale = Decider.initial_params()
+    best_params = evolution_strategies_optimizer(objective_function, clipper_function, init_mean=init_mean, init_scale=init_scale)
 
 
 def main():
@@ -199,12 +227,14 @@ def main():
     # during a 15 minute timestep.
     supplier.set_demand_charge(peak_demand=2.5, surcharge_per_kwh=500) # kWh in a 15 minutes interval, Ft/kWh
 
-    parameters = SolarParameters()
+    solar_parameters = SolarParameters()
 
     met_2021_data, cons_2021_data = read_datasets()
-    add_production_field(met_2021_data, parameters)
+    add_production_field(met_2021_data, solar_parameters)
     all_data = interpolate_and_join(met_2021_data, cons_2021_data)
 
+    print("Working with", solar_parameters.solar_cell_num, "solar cells, that's a maximum production of", all_data['Production'].max(), "kW.")
+
     time_interval_min = all_data.index.freq.n
     time_interval_h = time_interval_min / 60
 
@@ -222,7 +252,8 @@ def main():
     # TODO this is super unfortunate:
     # Consumption_fees travels via all_data_with_predictions,
     # peak_demand and surcharge_per_kwh travels via precalculated_supplier of decider.
-    decider = Decider(precalculated_supplier)
+    decider_init_mean, decider_init_scale = Decider.initial_params()
+    decider = Decider(decider_init_mean, precalculated_supplier)
 
     t = time.perf_counter()
     results, total_network_fee = simulator(battery_model, all_data_with_predictions, decider)

v2/data_processing.py

@@ -44,7 +44,7 @@ def read_datasets(mini=False):
 # BESS parameters are now in BatteryModel
 @dataclass
 class SolarParameters:
-    solar_cell_num: float = 114 # units
+    solar_cell_num: float = 1140 # units
     solar_efficiency: float = 0.93 * 0.96 # [dimensionless]
     NOCT: float = 280 # [W]
     NOCT_irradiation: float = 800 # [W/m^2]

v2/decider.py

@@ -1,5 +1,5 @@
 from enum import IntEnum
-
+import numpy as np
 
 
 STEPS_PER_HOUR = 12
@@ -28,10 +28,16 @@ class Decision(IntEnum):
 # mock class as usual
 # output_window_size is not yet used, always decides one timestep.
 class Decider:
-    def __init__(self, precalculated_supplier):
+    def __init__(self, params, precalculated_supplier):
         self.input_window_size = STEPS_PER_HOUR * 24 # day long window.
         self.random_seed = 0
         self.precalculated_supplier = precalculated_supplier
+        assert params.shape == (2, )
+        # param_1 is how many minutes do we look ahead to decide if there's
+        # an upcoming shortage.
+        # param_2 is the threshhold for shortage, in kW not kWh,
+        # that is, parametrized as an average over the window.
+        self.surdemand_lookahead_window_min, self.lookahead_surdemand_kw = params
 
     def decide(self, prod_pred, cons_pred, fees, battery_model):
         # TODO 15 minutes demand charge window hardwired at this weird place
@@ -42,9 +48,38 @@ class Decider:
         step_in_hour = time_interval_min / 60 # [hour], the length of a time step.
         deficit_kw = (cons_pred[:peak_shaving_window] - prod_pred[:peak_shaving_window]).clip(min=0)
         deficit_kwh = (step_in_hour * deficit_kw).sum()
+
+        surdemand_window = int(self.surdemand_lookahead_window_min // time_interval_min)
+        mean_surdemand_kw = (cons_pred[:surdemand_window] - prod_pred[:surdemand_window]).mean()
+
+        current_fee = fees[0]
+        # TODO this should not be a hard threashold, and more importantly,
+        # it should not be hardwired.
+        HARDWIRED_THRESHOLD_FOR_CHEAP_POWER_HUF_PER_KWH = 20 # [HUF/kWh]
+        if mean_surdemand_kw > self.lookahead_surdemand_kw and current_fee <= HARDWIRED_THRESHOLD_FOR_CHEAP_POWER_HUF_PER_KWH:
+            return Decision.NETWORK_CHARGE
+
         if deficit_kwh > self.precalculated_supplier.peak_demand:
             return Decision.DISCHARGE
         else:
             return Decision.PASSIVE
 
+    # this is called by the optimizer so that meaningless parameter settings are not attempted
+    # we could vectorize this easily, but it's not a bottleneck, the simulation is.
+    @staticmethod
+    def clip_params(params):
+        assert params.shape == (2, )
+        surdemand_lookahead_window_min, lookahead_surdemand_kw = params
+        surdemand_lookahead_window_min = np.clip(surdemand_lookahead_window_min, 5, 60 * 24 * 3)
+        # no-op right now:
+        lookahead_surdemand_kw = np.clip(lookahead_surdemand_kw, -np.inf, np.inf)
+        return np.array([surdemand_lookahead_window_min, lookahead_surdemand_kw])
 
+    @staticmethod
+    def initial_params():
+        # surdemand_lookahead_window_min, lookahead_surdemand_kw
+        # param1 [minutes]. one day mean, half day scale for lookahead horizon.
+        # param2 [kWh], averaged over the horizon. negative values are meaningful.
+        init_mean = np.array([1440.0, 0.0])
+        init_scale = np.array([720.0, 100.0])
+        return init_mean, init_scale

v2/evolution_strategies.py

@@ -1,7 +1,13 @@
 import numpy as np
 
 
-def evolution_strategies_optimizer(objective_function, init_mean, init_scale):
+# in-place
+def clip_params(population, clipper_function):
+    for i, individual in enumerate(population):
+        population[i] = clipper_function(individual)
+
+
+def evolution_strategies_optimizer(objective_function, clipper_function, init_mean, init_scale):
     # Initialize parameters
     population_size = 100
     number_of_generations = 30
@@ -11,6 +17,7 @@ def evolution_strategies_optimizer(objective_function, init_mean, init_scale):
 
     # Initialize population (randomly)
     population = np.random.normal(loc=init_mean, scale=init_scale, size=(population_size, len(init_mean)))
+    clip_params(population, clipper_function)
 
     for generation in range(number_of_generations):
         # Evaluate fitness
@@ -22,6 +29,7 @@ def evolution_strategies_optimizer(objective_function, init_mean, init_scale):
         
         # Reproduce (mutate)
         offspring = selected + np.random.randn(selected_size, 2) * mutation_scale
+        clip_params(offspring, clipper_function) # in-place
         
         # Replacement: Here we simply generate new candidates around the selected ones
         population[:selected_size] = selected
@@ -45,10 +53,14 @@ def toy_objective_function(x):
     return (x[0] - 3)**2 + (x[1] + 2)**2
 
 
+def toy_clipper_function(x):
+    return x
+
+
 def main():
     init_mean = np.array([0.0, 0.0])
     init_scale = np.array([10.0, 10.0])
-    best_solution = evolution_strategies_optimizer(toy_objective_function, init_mean, init_scale)
+    best_solution = evolution_strategies_optimizer(toy_objective_function, toy_clipper_function, init_mean, init_scale)
 
 
 if __name__ == '__main__':