first proposal for issue rte-france#616

Author: BDonnot

CHANGELOG.rst

@@ -40,6 +40,8 @@ Work kind of in progress
 
 Next release
 ---------------------------------
+- TODO bug on maintenance starting at midnight (they are not correctly handled in the observation)
+  => cf script test_issue_616
 - TODO Notebook for tf_agents
 - TODO Notebook for acme
 - TODO Notebook using "keras rl" (see https://keras.io/examples/rl/ppo_cartpole/)
@@ -66,11 +68,23 @@ Next release
   (because  it should always have been like this)
 - [FIXED] a bug in the `MultiFolder` and `MultifolderWithCache` leading to the wrong 
   computation of `max_iter` on some corner cases
+- [FIXED] issue on `seed` and `MultifolderWithCache` which caused 
+  https://github.com/rte-france/Grid2Op/issues/616 
+- [FIXED] another issue with the seeding of `MultifolderWithCache`: the seed was not used
+  correctly on the cache data when calling `chronics_handler.reset` multiple times without 
+  any changes
 - [ADDED] possibility to skip some step when calling `env.reset(..., options={"init ts": ...})`
 - [ADDED] possibility to limit the duration of an episode with `env.reset(..., options={"max step": ...})`
 - [ADDED] possibility to specify the "reset_options" used in `env.reset` when
   using the runner with `runner.run(..., reset_options=xxx)`
+- [ADDED] the time series now are able to regenerate their "random" part 
+  even when "cached" thanks to the addition of the `regenerate_with_new_seed` of the 
+  `GridValue` class (in public API)
+- [ADDED] `MultifolderWithCache` now supports `FromHandlers` time series generator
 - [IMPROVED] the documentation on the `time series` folder.
+- [IMPROVED] now the "maintenance from json" (*eg* the `JSONMaintenanceHandler` or the 
+  `GridStateFromFileWithForecastsWithMaintenance`) can be customized with the day 
+  of the week where the maintenance happens (key `maintenance_day_of_week`)
 
 [1.10.2] - 2024-05-27
 -------------------------

grid2op/Chronics/GSFFWFWM.py

@@ -108,6 +108,14 @@ def initialize(
             self.max_daily_number_per_month_maintenance = dict_[
                 "max_daily_number_per_month_maintenance"
             ]
+            
+            if "maintenance_day_of_week" in dict_:
+                self.maintenance_day_of_week = [int(el) for el in dict_[
+                    "maintenance_day_of_week"
+                ]]
+            else:
+                self.maintenance_day_of_week = np.arange(5)
+                
         super().initialize(
             order_backend_loads,
             order_backend_prods,
@@ -133,7 +141,6 @@ def _sample_maintenance(self):
         ########
         # new method to introduce generated maintenance
         self.maintenance = self._generate_maintenance()  #
-
         ##########
         # same as before in GridStateFromFileWithForecasts
         GridStateFromFileWithForecastsWithMaintenance._fix_maintenance_format(self)
@@ -171,7 +178,12 @@ def _generate_matenance_static(name_line,
                                    daily_proba_per_month_maintenance, 
                                    max_daily_number_per_month_maintenance,
                                    space_prng,
+                                   maintenance_day_of_week=None
                                    ):
+        if maintenance_day_of_week is None:
+            # new in grid2op 1.10.3
+            maintenance_day_of_week = np.arange(5)
+            
         # define maintenance dataframe with size (nbtimesteps,nlines)
         columnsNames = name_line
         nbTimesteps = n_
@@ -203,8 +215,6 @@ def _generate_matenance_static(name_line,
         datelist = datelist[:-1]
 
         n_lines_maintenance = len(line_to_maintenance)
-
-        _24_h = timedelta(seconds=86400)
         nb_rows = int(86400 / time_interval.total_seconds())
         selected_rows_beg = int(
             maintenance_starting_hour * 3600 / time_interval.total_seconds()
@@ -220,7 +230,7 @@ def _generate_matenance_static(name_line,
         maxDailyMaintenance = -1
         for nb_day_since_beg, this_day in enumerate(datelist):
             dayOfWeek = this_day.weekday()
-            if dayOfWeek < 5:  # only maintenance starting on working days
+            if dayOfWeek in maintenance_day_of_week:
                 month = this_day.month
 
                 maintenance_me = np.zeros((nb_rows, nb_line_maint))
@@ -279,5 +289,9 @@ def _generate_maintenance(self):
             self.maintenance_ending_hour,
             self.daily_proba_per_month_maintenance,
             self.max_daily_number_per_month_maintenance,
-            self.space_prng
+            self.space_prng,
+            self.maintenance_day_of_week
         )
+
+    def regenerate_with_new_seed(self):
+        self._sample_maintenance()

grid2op/Chronics/fromChronix2grid.py

@@ -309,4 +309,12 @@ def next_chronics(self):
             GridStateFromFileWithForecastsWithMaintenance._fix_maintenance_format(self)
 
         self.check_validity(backend=None)
+        
+    def regenerate_with_new_seed(self):
+        raise ChronicsError("You should not 'cache' the data coming from the "
+                            "`FromChronix2grid`, which is probably why you ended "
+                            "up calling this function. If you want to generate data "
+                            "'on the fly' please do not use the `MultiFolder` or "
+                            "`MultiFolderWithCache` `chronics_class` when making your "
+                            "environment.")
 

grid2op/Chronics/gridValue.py

@@ -856,3 +856,21 @@ def cleanup_action_space(self):
         """
         self.__action_space = None
         # NB the action space is not closed as it is NOT own by this class
+
+    def regenerate_with_new_seed(self):
+        """
+        INTERNAL this function is called by some classes (*eg* :class:`MultifolderWithCache`)
+        when a new seed has been set. 
+        
+        For example, if you use some 'chronics' that generate part of them randomly (*eg* 
+        :class:`GridStateFromFileWithForecastsWithMaintenance`) they need to be aware of this
+        so that a reset actually update the seeds.
+        
+        This is closely related to issue https://github.com/rte-france/Grid2Op/issues/616
+        
+        .. danger::
+            This function should be called only once (not 0, not twice) after a "seed" function has been set. 
+            Otherwise results might not be fully reproducible.
+            
+        """
+        pass

grid2op/Chronics/handlers/baseHandler.py

@@ -494,3 +494,14 @@ def get_init_dict_action(self) -> Union[dict, None]:
         action space.
         """
         raise NotImplementedError()
+    
+    def regenerate_with_new_seed(self):
+        """This function is called in case of data being "cached" (for example using the 
+        :class:`grid2op.Chronics.MultifolderWithCache`)
+        
+        In this case, the data in cache needs to be updated if the seed has changed since
+        the time they have been added to it.
+        
+        If your handler has some random part, we recommend you to implement this function.
+        Otherwise feel free to ignore it"""
+        pass

grid2op/Chronics/handlers/jsonMaintenanceHandler.py

@@ -63,7 +63,8 @@ def __init__(self,
         self.n_line = None  # used in one of the GridStateFromFileWithForecastsWithMaintenance functions
         self._duration_episode_default = _duration_episode_default
         self.current_index = 0
-    
+        self._order_backend_arrays = None
+        
     def get_maintenance_time_1d(self, maintenance):
         return GridValue.get_maintenance_time_1d(maintenance)
 
@@ -82,7 +83,8 @@ def _create_maintenance_arrays(self, current_datetime):
             self.dict_meta_data["maintenance_ending_hour"],
             self.dict_meta_data["daily_proba_per_month_maintenance"],
             self.dict_meta_data["max_daily_number_per_month_maintenance"],
-            self.space_prng
+            self.space_prng,
+            self.dict_meta_data["maintenance_day_of_week"] if "maintenance_day_of_week" in self.dict_meta_data else None
         )
         GridStateFromFileWithForecastsWithMaintenance._fix_maintenance_format(self)
 
@@ -128,4 +130,8 @@ def _clear(self):
 
     def done(self):
         # maintenance can be generated on the fly so they are never "done"
-        return False
+        return False
+    
+    def regenerate_with_new_seed(self):
+        if self.dict_meta_data is not None:
+            self._create_maintenance_arrays(self.init_datetime)

grid2op/Chronics/handlers/noisyForecastHandler.py

@@ -212,3 +212,7 @@ def forecast(self,
                     res *= self._env_loss_ratio(inj_dict_env)
                 # TODO ramps, pmin, pmax !
         return res.astype(dt_float) if res is not None else None
+
+    def regenerate_with_new_seed(self):
+        # there is nothing to do for this handler as things are generated "on the fly"
+        pass

grid2op/Chronics/multiFolder.py

@@ -394,6 +394,17 @@ def reset(self):
         self._order = np.array(self._order)
         return self.subpaths[self._order]
 
+    def _get_nex_data(self, this_path):
+        res = self.gridvalueClass(
+            time_interval=self.time_interval,
+            sep=self.sep,
+            path=this_path,
+            max_iter=self.max_iter,
+            chunk_size=self.chunk_size,
+            **self._kwargs
+        )
+        return res
+        
     def initialize(
         self,
         order_backend_loads,
@@ -419,14 +430,7 @@ def initialize(
 
         id_scenario = self._order[self._prev_cache_id]
         this_path = self.subpaths[id_scenario]
-        self.data = self.gridvalueClass(
-            time_interval=self.time_interval,
-            sep=self.sep,
-            path=this_path,
-            max_iter=self.max_iter,
-            chunk_size=self.chunk_size,
-            **self._kwargs
-        )
+        self.data = self._get_nex_data(this_path)
         if self.seed is not None:
             max_int = np.iinfo(dt_int).max
             seed_chronics = self.space_prng.randint(max_int)