Fix: Setting random_state now does not effect global numpy random

Author: milankures

cesnet_tszoo/configs/base_config.py

@@ -185,9 +185,6 @@ def __init__(self,
         self.train_dataloader_order: DataloaderOrder = train_dataloader_order
         self.random_state: Optional[int] = random_state
 
-        if self.random_state is not None:
-            np.random.seed(random_state)
-
         self._validate_construction()
 
         self.logger.info("Quick validation succeeded.")
@@ -364,12 +361,14 @@ def _update_identifiers_from_dataset_metadata(self, dataset_metadata: DatasetMet
     def _dataset_init(self, dataset_metadata: DatasetMetadata) -> None:
         """Performs deeper parameter validation and updates values based on data from the dataset. """
 
+        rd = np.random.RandomState(self.random_state)
+
         self.ts_id_name = dataset_metadata.ts_id_name
 
         self._set_features_to_take(dataset_metadata.features)
         self.logger.debug("Features to take have been successfully set.")
 
-        self._set_ts(dataset_metadata.ts_indices, dataset_metadata.ts_row_ranges)
+        self._set_ts(dataset_metadata.ts_indices, dataset_metadata.ts_row_ranges, rd)
         self.logger.debug("Time series IDs have been successfully set.")
 
         self._set_time_period(dataset_metadata.time_indices)
@@ -661,7 +660,7 @@ def _set_time_period(self, all_time_ids: np.ndarray) -> None:
         ...
 
     @abstractmethod
-    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray) -> None:
+    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, rd: np.random.RandomState) -> None:
         """Validates and filters the input time series IDs based on the `dataset` and `source_type`. This typically calls [`_process_ts_ids`](reference_dataset_config.md#references.DatasetConfig._process_ts_ids) for each time series ID filter. """
         ...
 

cesnet_tszoo/configs/disjoint_time_based_config.py

@@ -288,10 +288,10 @@ def _set_time_period(self, all_time_ids: np.ndarray) -> None:
 
         self._prepare_and_set_time_period_sets(all_time_ids, self.time_format)
 
-    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray) -> None:
+    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, rd: np.random.RandomState) -> None:
         """ Validates and filters inputted time series id from `train_ts`, `val_ts` and `test_ts` based on `dataset` and `source_type`. Handles random set."""
 
-        self._prepare_and_set_ts_sets(all_ts_ids, all_ts_row_ranges, self.ts_id_name, self.random_state)
+        self._prepare_and_set_ts_sets(all_ts_ids, all_ts_row_ranges, self.ts_id_name, self.random_state, rd)
 
     def _get_feature_transformers(self) -> Transformer:
         """Creates transformer with `transformer_factory`. """

cesnet_tszoo/configs/handlers/series_based_handler.py

@@ -31,15 +31,15 @@ def __init__(self,
 
         self.logger: Logger = logger
 
-    def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, ts_id_name: str, random_state) -> None:
+    def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, ts_id_name: str, random_state: Optional[int], rd: np.random.RandomState) -> None:
         """Validates and filters the input time series IDs based on the `dataset` and `source_type`. Handles random split."""
 
         random_ts_ids = all_ts_ids[ts_id_name]
         random_indices = np.arange(len(all_ts_ids))
 
         # Process train_ts if it was specified with times series ids
         if self.train_ts is not None and not isinstance(self.train_ts, (float, int)):
-            self.train_ts, self.train_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.train_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state)
+            self.train_ts, self.train_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.train_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state, rd)
 
             mask = np.isin(random_ts_ids, self.train_ts, invert=True)
             random_ts_ids = random_ts_ids[mask]
@@ -49,7 +49,7 @@ def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np
 
         # Process val_ts if it was specified with times series ids
         if self.val_ts is not None and not isinstance(self.val_ts, (float, int)):
-            self.val_ts, self.val_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.val_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state)
+            self.val_ts, self.val_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.val_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state, rd)
 
             mask = np.isin(random_ts_ids, self.val_ts, invert=True)
             random_ts_ids = random_ts_ids[mask]
@@ -59,7 +59,7 @@ def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np
 
         # Process time_ts if it was specified with times series ids
         if self.test_ts is not None and not isinstance(self.test_ts, (float, int)):
-            self.test_ts, self.test_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.test_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state)
+            self.test_ts, self.test_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.test_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state, rd)
 
             mask = np.isin(random_ts_ids, self.test_ts, invert=True)
             random_ts_ids = random_ts_ids[mask]
@@ -80,23 +80,23 @@ def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np
 
         # Process random train_ts if it is to be randomly made
         if isinstance(self.train_ts, int):
-            self.train_ts, self.train_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.train_ts, random_indices, self.logger, ts_id_name, random_state)
+            self.train_ts, self.train_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.train_ts, random_indices, self.logger, ts_id_name, random_state, rd)
             self.logger.debug("Random train_ts set with %s time series.", self.train_ts)
 
         # Process random val_ts if it is to be randomly made
         if isinstance(self.val_ts, int):
-            self.val_ts, self.val_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.val_ts, random_indices, self.logger, ts_id_name, random_state)
+            self.val_ts, self.val_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.val_ts, random_indices, self.logger, ts_id_name, random_state, rd)
             self.logger.debug("Random val_ts set with %s time series.", self.val_ts)
 
         # Process random test_ts if it is to be randomly made
         if isinstance(self.test_ts, int):
-            self.test_ts, self.test_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.test_ts, random_indices, self.logger, ts_id_name, random_state)
+            self.test_ts, self.test_ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.test_ts, random_indices, self.logger, ts_id_name, random_state, rd)
             self.logger.debug("Random test_ts set with %s time series.", self.test_ts)
 
         if self.uses_all_ts:
             if self.train_ts is None and self.val_ts is None and self.test_ts is None:
                 self.all_ts = all_ts_ids[ts_id_name]
-                self.all_ts, self.all_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.all_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state)
+                self.all_ts, self.all_ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.all_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state, rd)
                 self.logger.info("Using all time series for all_ts because train_ts, val_ts, and test_ts are all set to None.")
             else:
                 for temp_ts_ids in [self.train_ts, self.val_ts, self.test_ts]:
@@ -114,7 +114,7 @@ def _prepare_and_set_ts_sets(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np
                 if self.test_ts is not None:
                     self.logger.debug("all_ts includes ids from test_ts.")
 
-                self.all_ts, self.all_ts_row_ranges, _ = self._process_ts_ids(self.all_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state)
+                self.all_ts, self.all_ts_row_ranges, _ = self._process_ts_ids(self.all_ts, all_ts_ids, all_ts_row_ranges, None, None, self.logger, ts_id_name, random_state, rd)
         else:
             self.all_ts = None
 
@@ -163,7 +163,7 @@ def _validate_ts_overlap(self):
             raise ValueError("Train, Val, and Test can't have the same IDs.")
 
     @staticmethod
-    def _process_ts_ids(ts_ids: np.ndarray, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, split_size: float | int | None, random_indices: np.ndarray, logger: Logger, ts_id_name: str, random_state) -> None:
+    def _process_ts_ids(ts_ids: np.ndarray, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, split_size: float | int | None, random_indices: np.ndarray, logger: Logger, ts_id_name: str, random_state: Optional[int], rd: np.random.RandomState) -> None:
         """Validates and filters the input `ts_ids` based on the `dataset` and `source_type`. """
 
         if ts_ids is None and split_size is None:
@@ -175,7 +175,7 @@ def _process_ts_ids(ts_ids: np.ndarray, all_ts_ids: np.ndarray, all_ts_row_range
                 raise ValueError(f"Trying to use more time series than there are in the dataset. There are {len(all_ts_ids)} time series available.")
 
             if split_size == len(random_indices):
-                np.random.shuffle(random_indices)
+                rd.shuffle(random_indices)
                 ts_indices = random_indices
                 ts_ids = all_ts_ids[ts_id_name][ts_indices]
                 random_indices = np.array([])  # No remaining indices

cesnet_tszoo/configs/series_based_config.py

@@ -236,10 +236,10 @@ def _set_time_period(self, all_time_ids: np.ndarray) -> None:
         self.time_period, self.display_time_period = TimeBasedHandler._process_time_period(self.time_period, all_time_ids, self.logger, self.time_format)
         self.logger.debug("Processed time_period: %s, display_time_period: %s", self.time_period, self.display_time_period)
 
-    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray) -> None:
+    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, rd: np.random.RandomState) -> None:
         """Validates and filters the input time series IDs based on the `dataset` and `source_type`. Handles random split."""
 
-        self._prepare_and_set_ts_sets(all_ts_ids, all_ts_row_ranges, self.ts_id_name, self.random_state)
+        self._prepare_and_set_ts_sets(all_ts_ids, all_ts_row_ranges, self.ts_id_name, self.random_state, rd)
 
     def _get_feature_transformers(self) -> Transformer:
         """Creates transformer with `transformer_factory`. """

cesnet_tszoo/configs/time_based_config.py

@@ -283,15 +283,15 @@ def _set_time_period(self, all_time_ids: np.ndarray) -> None:
 
         self._prepare_and_set_time_period_sets(all_time_ids, self.time_format)
 
-    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray) -> None:
+    def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray, rd: np.random.RandomState) -> None:
         """ Validates and filters inputted time series id from `ts_ids` based on `dataset` and `source_type`. Handles random set."""
 
         random_ts_ids = all_ts_ids[self.ts_id_name]
         random_indices = np.arange(len(all_ts_ids))
 
         # Process ts_ids if it was specified with times series ids
         if not isinstance(self.ts_ids, (float, int)):
-            self.ts_ids, self.ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.ts_ids, all_ts_ids, all_ts_row_ranges, None, None, self.logger, self.ts_id_name, self.random_state)
+            self.ts_ids, self.ts_row_ranges, _ = SeriesBasedHandler._process_ts_ids(self.ts_ids, all_ts_ids, all_ts_row_ranges, None, None, self.logger, self.ts_id_name, self.random_state, rd)
 
             mask = np.isin(random_ts_ids, self.ts_ids, invert=True)
             random_ts_ids = random_ts_ids[mask]
@@ -306,7 +306,7 @@ def _set_ts(self, all_ts_ids: np.ndarray, all_ts_row_ranges: np.ndarray) -> None
 
         # Process random ts_ids if it is to be randomly made
         if isinstance(self.ts_ids, int):
-            self.ts_ids, self.ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.ts_ids, random_indices, self.logger, self.ts_id_name, self.random_state)
+            self.ts_ids, self.ts_row_ranges, random_indices = SeriesBasedHandler._process_ts_ids(None, all_ts_ids, all_ts_row_ranges, self.ts_ids, random_indices, self.logger, self.ts_id_name, self.random_state, rd)
             self.logger.debug("Random ts_ids set with %s time series.", self.ts_ids)
 
     def _get_feature_transformers(self) -> np.ndarray[Transformer] | Transformer:

cesnet_tszoo/datasets/cesnet_dataset.py

@@ -110,6 +110,10 @@ def set_dataset_config_and_initialize(self, dataset_config: DatasetConfig, displ
             display_config_details: Flag indicating whether and how to display the configuration values after initialization. `Default: text`  
             workers: The number of workers to use during initialization. `Default: "config"`  
         """
+
+        if self.dataset_config is not None and self.dataset_config != dataset_config:
+            raise ValueError("This dataset is already initialized with config. Create new dataset to configure with passed dataset_config!")
+
         if display_config_details is not None:
             display_config_details = DisplayType(display_config_details)