evolution strategies

v2/architecture.py

@@ -8,7 +8,7 @@ import matplotlib.pyplot as plt
 # it's really just a network pricing model
 from supplier import Supplier, precalculate_supplier
 from data_processing import read_datasets, add_production_field, interpolate_and_join, SolarParameters
-
+from evolution_strategies import evolution_strategies_optimizer
 
 DO_VIS = False
 
@@ -103,18 +103,13 @@ class Decider:
         self.random_seed = 0
         self.precalculated_supplier = precalculated_supplier
 
-    # prod_cons_pred is a dataframe starting at now, containing
-    # fields Production and Consumption.
-    # this function does not mutate its inputs.
-    # battery_model is just queried for capacity and current soc.
-    # the method returns a pd.Series of Decisions as integers.
     def decide(self, prod_pred, cons_pred, fees, battery_model):
-        return Decision.PASSIVE
-        # 15 minutes demand charge window divided by 5 minute timestep, TODO make it more principled
-        peak_shaving_window = 3
-
-        # TODO is there a kWh kW confusion here?:
-        step_in_hour = self.precalculated_supplier.time_index.freq.n / 60 # [hour], the length of a time step.
+        # TODO 15 minutes demand charge window hardwired at this weird place
+        DEMAND_CHARGE_WINDOW_MIN = 15
+        time_interval_min = self.precalculated_supplier.time_index.freq.n
+        assert DEMAND_CHARGE_WINDOW_MIN % time_interval_min == 0
+        peak_shaving_window = DEMAND_CHARGE_WINDOW_MIN // time_interval_min
+        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()
         if deficit_kwh > self.precalculated_supplier.peak_demand:
@@ -123,6 +118,19 @@ class Decider:
             return Decision.PASSIVE
 
 
+# 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):
+    time_interval_min = all_data_with_predictions.index.freq.n
+    cons_shift = 60 * 168 // time_interval_min
+    prod_shift = 60 * 24 // time_interval_min
+    all_data_with_predictions['Consumption_prediction'] = all_data_with_predictions['Consumption'].shift(periods=cons_shift)
+    all_data_with_predictions['Production_prediction'] = all_data_with_predictions['Production'].shift(periods=prod_shift)
+    # we predict zero before we have data, no big deal:
+    all_data_with_predictions['Consumption_prediction'][:cons_shift] = 0
+    all_data_with_predictions['Production_prediction'][:prod_shift] = 0
+
+
 # even mock-er class than usual.
 # knows the future in advance, so it predicts it very well.
 # it's also unrealistic in that it takes row index instead of date.
@@ -252,8 +260,8 @@ def simulator(battery_model, prod_cons, decider):
     fifteen_minute_demands_in_kwh = consumption_from_network_pandas_series.resample('15T').sum() * step_in_hour
     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_charge = consumption_charge_series.sum() + demand_charges.sum()
-    print(f"All in all we have paid the network {total_charge / 10 ** 6} MHUF.")
+    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.")
 
     if DO_VIS:
         demand_charges.plot()
@@ -269,7 +277,20 @@ def simulator(battery_model, prod_cons, decider):
                             'Production': prod_cons['Production']
                             })
     results = results.set_index(prod_cons.index)
-    return results
+    return results, total_network_fee
+
+
+def optimizer(battery_model, all_data_with_predictions, precalculated_supplier):
+    def objective_function(params):
+        # TODO params completely ignored right now.
+        decider = Decider(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 main():
@@ -292,15 +313,8 @@ def main():
     print("time_interval_min", time_interval_min)
     time_interval_h = time_interval_min / 60
 
-    # we predict last week same time for consumption, and yesterday same time for production.
     all_data_with_predictions = all_data.copy()
-    cons_shift = 60 * 168 // time_interval_min
-    prod_shift = 60 * 24 // time_interval_min
-    all_data_with_predictions['Consumption_prediction'] = all_data_with_predictions['Consumption'].shift(periods=cons_shift)
-    all_data_with_predictions['Production_prediction'] = all_data_with_predictions['Production'].shift(periods=prod_shift)
-    # we predict zero before we have data, no big deal:
-    all_data_with_predictions['Consumption_prediction'][:cons_shift] = 0
-    all_data_with_predictions['Production_prediction'][:prod_shift] = 0
+    add_dummy_predictions(all_data_with_predictions)
 
     precalculated_supplier = precalculate_supplier(supplier, all_data.index)
     # we delete the supplier to avoid accidentally calling it instead of precalculated_supplier
@@ -316,7 +330,7 @@ def main():
     decider = Decider(precalculated_supplier)
 
     t = time.perf_counter()
-    results = simulator(battery_model, all_data_with_predictions, decider)
+    results, total_network_fee = simulator(battery_model, all_data_with_predictions, decider)
     print("Simulation runtime", time.perf_counter() - t, "seconds.")
 
     if DO_VIS:
@@ -324,6 +338,7 @@ def main():
         plt.title('soc_series')
         plt.show()
 
+    optimizer(battery_model, all_data_with_predictions, precalculated_supplier)
 
 if __name__ == '__main__':
     main()

v2/evolution_strategies.py

@@ -0,0 +1,55 @@
+import numpy as np
+
+
+def evolution_strategies_optimizer(objective_function, init_mean, init_scale):
+    # Initialize parameters
+    population_size = 100
+    number_of_generations = 30
+    mutation_scale = 0.1
+    selection_ratio = 0.5
+    selected_size = int(population_size * selection_ratio)
+
+    # Initialize population (randomly)
+    population = np.random.normal(loc=init_mean, scale=init_scale, size=(population_size, len(init_mean)))
+
+    for generation in range(number_of_generations):
+        # Evaluate fitness
+        fitness = np.array([objective_function(individual) for individual in population])
+        
+        # Select the best individuals
+        selected_indices = np.argsort(fitness)[:selected_size]
+        selected = population[selected_indices]
+        
+        # Reproduce (mutate)
+        offspring = selected + np.random.randn(selected_size, 2) * mutation_scale
+        
+        # Replacement: Here we simply generate new candidates around the selected ones
+        population[:selected_size] = selected
+        population[selected_size:] = offspring
+        
+        # Logging
+        best_fitness = fitness[selected_indices[0]]
+        best_index = np.argmin(fitness)
+        best_solution = population[best_index]
+        print(f"Generation {generation + 1}: Best Fitness = {best_fitness}", f"Best solution so far: {best_solution}")
+
+
+    # Best solution
+    best_index = np.argmin(fitness)
+    best_solution = population[best_index]
+    print(f"Best solution found: {best_solution}")
+    return best_solution
+
+
+def toy_objective_function(x):
+    return (x[0] - 3)**2 + (x[1] + 2)**2
+
+
+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)
+
+
+if __name__ == '__main__':
+    main()