Repository: bancaditalia/black-it (language: python)

Issue:
[WIP] Samplers refactoring
## Proposed changes

TODO

## Fixes

n/a

## Types of changes

What types of changes does your code introduce?
_Put an `x` in the boxes that apply_

- [ ] Bugfix (non-breaking change which fixes an issue)
- [X] New feature (non-breaking change which adds functionality)
- [X] Breaking change (fix or feature that would cause existing functionality to not work as expected)

## Checklist

_Put an `x` in the boxes that apply._

- [ ] I have read the [CONTRIBUTING](../blob/master/CONTRIBUTING.md) doc
- [ ] I am making a pull request against the `develop` branch (left side). Also you should start your branch off our `develop`.
- [ ] Lint and unit tests pass locally with my changes
- [ ] I have added tests that prove my fix is effective or that my feature works

## Further comments

n/a


Discussion / hints:

Fix patch:
diff --git a/.github/workflows/main.yml b/.github/workflows/main.yml
index 295a9564..d04c36eb 100644
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -91,11 +91,15 @@ jobs:
       - name: Install dependencies for Pylint checks
         if: ${{ env.PY_FILES_CHANGED != '' }}
         run: |
+          # install the package
+          pip install .
+          # install other importable dependencies
           pip install -r <(./scripts/list-poetry-dependencies.sh \
             pylint                                     \
             pytest                                     \
             hypothesis                                 \
-            mistletoe
+            mesa                                       \
+            mistletoe                                  \
           )
       - name: Pylint
         if: ${{ env.PY_FILES_CHANGED != '' }}
diff --git a/README.md b/README.md
index a47f0853..e2aa237d 100644
--- a/README.md
+++ b/README.md
@@ -83,13 +83,16 @@ best_batch_sampler = BestBatchSampler(batch_size=batch_size)
 model = md.MarkovC_KP
 
 # generate a synthetic dataset to test the calibrator
-N = 1500
+N = 2000
 seed = 1
 real_data = model(true_params, N, seed)
 
 # define a loss
 loss = MethodOfMomentsLoss()
 
+# define the calibration seed
+calibration_seed = 1
+
 # initialize a Calibrator object
 cal = Calibrator(
     samplers=[halton_sampler, random_forest_sampler, best_batch_sampler],
@@ -97,12 +100,13 @@ cal = Calibrator(
     model=model,
     parameters_bounds=np.asarray(bounds),
     parameters_precision=np.asarray(bounds_step),
-    ensemble_size=1,
+    ensemble_size=3,
     loss_function=loss,
+    random_state=calibration_seed,
 )
 
 # calibrate the model
-params, losses = cal.calibrate(n_batches=4)
+params, losses = cal.calibrate(n_batches=5)
 
 print(f"True parameters:       {true_params}")
 print(f"Best parameters found: {params[0]}")
@@ -112,7 +116,7 @@ When the calibration terminates (~half a minute), towards the end  of the output
 you should see the following messages:
 ```
 True parameters:       [0.2, 0.2, 0.75]
-Best parameters found: [0.21 0.2  0.76]
+Best parameters found: [0.18 0.19 0.75]
 ```
 
 ## Docs
diff --git a/black_it/calibrator.py b/black_it/calibrator.py
index 335defbd..65a8d615 100644
--- a/black_it/calibrator.py
+++ b/black_it/calibrator.py
@@ -25,12 +25,13 @@
 
 import numpy as np
 from joblib import Parallel, delayed
+from numpy.random import default_rng
 from numpy.typing import NDArray
 
 from black_it.loss_functions.base import BaseLoss
 from black_it.samplers.base import BaseSampler
 from black_it.search_space import SearchSpace
-from black_it.utils.base import assert_
+from black_it.utils.base import assert_, get_random_seed
 from black_it.utils.json_pandas_checkpointing import (
     load_calibrator_state,
     save_calibrator_state,
@@ -54,7 +55,7 @@ def __init__(  # pylint: disable=too-many-arguments
         convergence_precision: Optional[int] = None,
         verbose: bool = True,
         saving_folder: Optional[str] = None,
-        model_seed: int = 0,
+        random_state: Optional[int] = None,
         n_jobs: Optional[int] = None,
     ):
         """
@@ -76,7 +77,7 @@ def __init__(  # pylint: disable=too-many-arguments
                 not performed if this is set to 'None'.
             verbose: whether to print calibration updates
             saving_folder: the name of the folder where data should be saved and/or retrieved
-            model_seed: random seed passed to the model simulator
+            random_state: random state of the calibrator, used for model simulations and to initialise the samplers
             n_jobs: the maximum number of concurrently running jobs. For more details, see the
                 [joblib.Parallel documentation](https://joblib.readthedocs.io/en/latest/generated/joblib.Parallel.html).
 
@@ -84,7 +85,7 @@ def __init__(  # pylint: disable=too-many-arguments
         self.samplers = samplers
         self.loss_function = loss_function
         self.model = model
-        self.model_seed = model_seed
+        self.random_state = random_state
         self.real_data = real_data
         self.ensemble_size = ensemble_size
         self.N = self.real_data.shape[0]
@@ -120,6 +121,31 @@ def __init__(  # pylint: disable=too-many-arguments
 
         self.samplers_id_table = self._construct_samplers_id_table(samplers)
 
+    @property
+    def random_state(self) -> Optional[int]:
+        """Get the random state."""
+        return self._random_state
+
+    @random_state.setter
+    def random_state(self, random_state: Optional[int]) -> None:
+        """Set the random state."""
+        self._random_state = random_state
+        self._random_generator = default_rng(self.random_state)
+
+    @property
+    def random_generator(self) -> np.random.Generator:
+        """Get the random generator."""
+        return self._random_generator
+
+    def _get_random_seed(self) -> int:
+        """Get new random seed from the current random generator."""
+        return get_random_seed(self._random_generator)
+
+    def _set_samplers_seeds(self) -> None:
+        """Set the calibration seed."""
+        for sampler in self.samplers:
+            sampler.random_state = self._get_random_seed()
+
     @staticmethod
     def _construct_samplers_id_table(samplers: List[BaseSampler]) -> Dict[str, int]:
         """
@@ -198,7 +224,8 @@ def restore_from_checkpoint(  # pylint: disable=too-many-locals
             convergence_precision,
             verbose,
             saving_file,
-            model_seed,
+            random_state,
+            random_generator_state,
             model_name,
             samplers,
             loss_function,
@@ -231,7 +258,7 @@ def restore_from_checkpoint(  # pylint: disable=too-many-locals
             convergence_precision,
             verbose,
             saving_file,
-            model_seed,
+            random_state,
             n_jobs,
         )
 
@@ -243,6 +270,9 @@ def restore_from_checkpoint(  # pylint: disable=too-many-locals
         calibrator.batch_num_samp = batch_num_samp
         calibrator.method_samp = method_samp
 
+        # reset the random number generator state
+        calibrator.random_generator.bit_generator.state = random_generator_state
+
         return calibrator
 
     def simulate_model(self, params: NDArray) -> NDArray:
@@ -262,7 +292,7 @@ def simulate_model(self, params: NDArray) -> NDArray:
         rep_params = np.repeat(params, self.ensemble_size, axis=0)
 
         simulated_data_list = Parallel(n_jobs=self.n_jobs)(
-            delayed(self.model)(param, self.N, self.model_seed + i)
+            delayed(self.model)(param, self.N, self._get_random_seed())
             for i, param in enumerate(rep_params)
         )
 
@@ -285,6 +315,10 @@ def calibrate(self, n_batches: int) -> Tuple[NDArray, NDArray]:
             The sampled parameters and the corresponding sampled losses.
             Both arrays are sorted by increasing loss values
         """
+        if self.current_batch_index == 0:
+            # we only set the samplers' random state at the start of a calibration
+            self._set_samplers_seeds()
+
         for _ in range(n_batches):
             print()
             print(f"BATCH NUMBER:   {self.current_batch_index + 1}")
@@ -307,8 +341,6 @@ def calibrate(self, n_batches: int) -> Tuple[NDArray, NDArray]:
 
                 new_simulated_data = self.simulate_model(new_params)
 
-                self.model_seed += self.ensemble_size * method.batch_size
-
                 new_losses = []
 
                 for sim_data_ensemble in new_simulated_data:
@@ -426,7 +458,8 @@ def create_checkpoint(self, file_name: Union[str, os.PathLike]) -> None:
             self.convergence_precision,
             self.verbose,
             self.saving_folder,
-            self.model_seed,
+            self.random_state,
+            self.random_generator.bit_generator.state,
             model_name,
             self.samplers,
             self.loss_function,
diff --git a/black_it/samplers/base.py b/black_it/samplers/base.py
index 4af58efe..cc152673 100644
--- a/black_it/samplers/base.py
+++ b/black_it/samplers/base.py
@@ -20,10 +20,11 @@
 from typing import List
 
 import numpy as np
+from numpy.random import default_rng
 from numpy.typing import NDArray
 
 from black_it.search_space import SearchSpace
-from black_it.utils.base import digitize_data
+from black_it.utils.base import digitize_data, get_random_seed
 
 
 class BaseSampler(ABC):
@@ -34,20 +35,40 @@ class BaseSampler(ABC):
     """
 
     def __init__(
-        self, batch_size: int, internal_seed: int = 0, max_duplication_passes: int = 5
+        self, batch_size: int, random_state: int = 0, max_duplication_passes: int = 5
     ) -> None:
         """
         Initialize the sampler.
 
         Args:
             batch_size: the number of points sampled every time the sampler is called
-            internal_seed: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
+            random_state: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
             max_duplication_passes: maximum number of duplication passes done to avoid sampling repeated parameters
         """
-        self.internal_seed: int = internal_seed
+        self.random_state: int = random_state
         self.batch_size: int = batch_size
         self.max_duplication_passes = max_duplication_passes
 
+    @property
+    def random_state(self) -> int:
+        """Get the random state."""
+        return self._random_state
+
+    @random_state.setter
+    def random_state(self, random_state: int) -> None:
+        """Set the random state."""
+        self._random_state = random_state
+        self._random_generator = default_rng(self.random_state)
+
+    @property
+    def random_generator(self) -> np.random.Generator:
+        """Get the random generator."""
+        return self._random_generator
+
+    def _get_random_seed(self) -> int:
+        """Get new random seed from the current random generator."""
+        return get_random_seed(self._random_generator)
+
     @abstractmethod
     def single_sample(
         self,
@@ -95,12 +116,13 @@ def sample_batch(
 
         for i in range(batch_size):
             sampled_points[i] = self.single_sample(
-                seed=self.internal_seed,
+                seed=self.random_state,
                 search_space=search_space,
                 existing_points=existing_points,
                 existing_losses=existing_losses,
             )
-            self.internal_seed += 1
+
+            self.random_state += 1
 
         # discretize the new parameters, this should be redundant
         return digitize_data(sampled_points, search_space.param_grid)
@@ -173,12 +195,3 @@ def find_and_get_duplicates(
                     repeated_pos.append(index[0])
 
         return repeated_pos
-
-    def set_internal_seed(self, internal_seed: int) -> None:
-        """
-        Set the internal seed of the sampler to a specific value.
-
-        Args:
-            internal_seed: the internal random seed
-        """
-        self.internal_seed = internal_seed
diff --git a/black_it/samplers/gaussian_process.py b/black_it/samplers/gaussian_process.py
index 1d53f713..89d4b817 100644
--- a/black_it/samplers/gaussian_process.py
+++ b/black_it/samplers/gaussian_process.py
@@ -15,6 +15,7 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 """This module contains the implementation of the Gaussian process-based sampling."""
+import random
 from enum import Enum
 from typing import Optional, Tuple, cast
 
@@ -53,7 +54,7 @@ class GaussianProcessSampler(BaseSampler):
     def __init__(
         self,
         batch_size: int,
-        internal_seed: int = 0,
+        random_state: int = 0,
         candidate_pool_size: Optional[int] = None,
         max_iters: int = 1000,
         optimize_restarts: int = 5,
@@ -64,7 +65,7 @@ def __init__(
 
         Args:
             batch_size: the number of points sampled every time the sampler is called
-            internal_seed: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
+            random_state: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
             candidate_pool_size: number of randomly sampled points on which the random forest predictions are evaluated
             max_iters: maximum number of iteration in the optimization of the GP hyperparameters
             optimize_restarts: number of independent random trials of the optimization of the GP hyperparameters
@@ -72,7 +73,7 @@ def __init__(
         """
         self._validate_acquisition(acquisition)
 
-        super().__init__(batch_size, internal_seed)
+        super().__init__(batch_size, random_state)
         self.max_iters = max_iters
         self.optimize_restarts = optimize_restarts
         self.acquisition = acquisition
@@ -132,8 +133,6 @@ def sample(
         Returns:
             the sampled parameters
         """
-        np.random.seed(self.internal_seed)
-
         X, Y = existing_points, np.atleast_2d(existing_losses).T
 
         if X.shape[0] > 500:
@@ -154,6 +153,10 @@ def sample(
             1e-9, 1e6, warning=False
         )  # constrain_positive(warning=False)
 
+        # we need to set the seed globally for GPy optimisations
+        # to give reproducible results
+        np.random.seed(self._get_random_seed())
+        random.seed(self._get_random_seed())
         if self.max_iters > 0:
             # --- update the model maximizing the marginal likelihood.
             if self.optimize_restarts == 1:
@@ -173,7 +176,7 @@ def sample(
 
         # Get large candidate pool
         candidates: NDArray[np.float64] = RandomUniformSampler(
-            batch_size=self.candidate_pool_size, internal_seed=self.internal_seed
+            batch_size=self.candidate_pool_size, random_state=self._get_random_seed()
         ).sample(search_space, existing_points, existing_losses)
 
         # predict mean or expected improvement on the full sample set
@@ -187,8 +190,6 @@ def sample(
 
         sampled_points = candidates[sorting_indices][: self.batch_size, :]
 
-        self.internal_seed += self.batch_size
-
         return digitize_data(sampled_points, search_space.param_grid)
 
     def _predict_mean_std(
@@ -215,7 +216,7 @@ def _get_fmin(self) -> float:
         return gpmodel.predict(gpmodel.X)[0].min()
 
     def _predict_EI(
-        self, X: NDArray[np.float64], jitter: float = 1e-3
+        self, X: NDArray[np.float64], jitter: float = 0.1
     ) -> NDArray[np.float64]:
         """
         Compute the Expected Improvement per unit of cost.
diff --git a/black_it/samplers/random_forest.py b/black_it/samplers/random_forest.py
index 8037b60c..5bfab6c2 100644
--- a/black_it/samplers/random_forest.py
+++ b/black_it/samplers/random_forest.py
@@ -33,7 +33,7 @@ class RandomForestSampler(BaseSampler):
     def __init__(
         self,
         batch_size: int,
-        internal_seed: int = 0,
+        random_state: int = 0,
         candidate_pool_size: Optional[int] = None,
         n_estimators: int = 500,
         criterion: str = "gini",
@@ -45,12 +45,12 @@ def __init__(
 
         Args:
             batch_size: the number of points sampled every time the sampler is called
-            internal_seed: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
+            random_state: the internal state of the sampler, fixing this numbers the sampler behaves deterministically
             candidate_pool_size: number of randomly sampled points on which the random forest predictions are evaluated
             n_estimators: number of trees in the forest
             criterion: The function to measure the quality of a split.
         """
-        super().__init__(batch_size, internal_seed)
+        super().__init__(batch_size, random_state)
 
         self.n_estimators = n_estimators
         self.criterion = criterion
@@ -102,7 +102,7 @@ def sample(
             n_estimators=self.n_estimators,
             criterion=self.criterion,
             n_jobs=-1,
-            random_state=self.internal_seed,
+            random_state=self._get_random_seed(),
         )
         classifier.fit(x, y)
         # Predict quantiles
@@ -113,8 +113,6 @@ def sample(
             : self.batch_size
         ]
 
-        self.internal_seed += self.batch_size
-
         return digitize_data(sampled_points, search_space.param_grid)
 
     @staticmethod
@@ -168,7 +166,7 @@ def _get_candidates(
         """
 
         def sample(nb_samples: int) -> NDArray[np.float64]:
-            random_generator = default_rng(self.internal_seed)
+            random_generator = default_rng(self.random_state)
             candidates = np.zeros((nb_samples, search_space.dims))
             for i, params in enumerate(search_space.param_grid):
                 candidates[:, i] = random_generator.choice(params, size=(nb_samples,))
diff --git a/black_it/utils/base.py b/black_it/utils/base.py
index 4473885a..3ec5da91 100644
--- a/black_it/utils/base.py
+++ b/black_it/utils/base.py
@@ -111,3 +111,18 @@ def default(self, o: Any) -> Any:
         if isinstance(o, np.ndarray):
             return o.tolist()
         return JSONEncoder.default(self, o)  # pragma: no cover
+
+
+def get_random_seed(random_generator: np.random.Generator) -> int:
+    """
+    Get a random seed from a random generator.
+
+    Sample an integer in the range [0, 2^32 - 1].
+
+    Args:
+        random_generator: the random generator to be used for sampling the random seed.
+
+    Returns:
+        the random seed.
+    """
+    return random_generator.integers(2**32 - 1)
diff --git a/black_it/utils/json_pandas_checkpointing.py b/black_it/utils/json_pandas_checkpointing.py
index c65b1231..cde96582 100644
--- a/black_it/utils/json_pandas_checkpointing.py
+++ b/black_it/utils/json_pandas_checkpointing.py
@@ -19,7 +19,7 @@
 import json
 import pickle  # nosec B403
 from pathlib import Path
-from typing import Optional, Sequence, Tuple
+from typing import Mapping, Optional, Sequence, Tuple
 
 import numpy as np
 import pandas as pd
@@ -74,7 +74,8 @@ def load_calibrator_state(checkpoint_path: PathLike, _code_state_version: int) -
         cp["convergence_precision"],
         cp["verbose"],
         cp["saving_file"],
-        cp["model_seed"],
+        cp["initial_random_seed"],
+        cp["random_generator_state"],
         cp["model_name"],
         samplers,
         loss_function,
@@ -101,7 +102,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
     convergence_precision: Optional[float],
     verbose: bool,
     saving_file: Optional[str],
-    model_seed: int,
+    initial_random_seed: Optional[int],
+    random_generator_state: Mapping,
     model_name: str,
     samplers: Sequence[BaseSampler],
     loss_function: BaseLoss,
@@ -128,7 +130,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
         convergence_precision: the convergence precision
         verbose: the verbosity mode
         saving_file: the saving file
-        model_seed: the model seed
+        initial_random_seed: the initial seed of the calibrator
+        random_generator_state: the internal random state of the calibrator
         model_name: the model name
         samplers: the ordered list of samplers to use in the calibration
         loss_function: the loss function
@@ -156,7 +159,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
         convergence_precision=convergence_precision,
         verbose=verbose,
         saving_file=saving_file,
-        model_seed=model_seed,
+        initial_random_seed=initial_random_seed,
+        random_generator_state=random_generator_state,
         model_name=model_name,
         current_batch_index=current_batch_index,
         n_sampled_params=n_sampled_params,
diff --git a/black_it/utils/sqlite3_checkpointing.py b/black_it/utils/sqlite3_checkpointing.py
index 21282310..990518c1 100644
--- a/black_it/utils/sqlite3_checkpointing.py
+++ b/black_it/utils/sqlite3_checkpointing.py
@@ -17,10 +17,11 @@
 """This module contains serialization and deserialization of calibration state with SQLite."""
 import gzip
 import io
+import json
 import pickle  # nosec B403
 import sqlite3
 from pathlib import Path
-from typing import Optional, Sequence, Tuple
+from typing import Mapping, Optional, Sequence, Tuple
 
 import numpy as np
 from numpy.typing import NDArray
@@ -29,7 +30,7 @@
 from black_it.samplers.base import BaseSampler
 from black_it.utils.base import PathLike
 
-SCHEMA_VERSION = 2
+SCHEMA_VERSION = 3
 """
 Encodes the version of a checkpoint, preventing to load incompatible versions.
 
@@ -49,7 +50,8 @@
         convergence_precision,
         verbose,
         saving_folder,
-        model_seed,
+        initial_random_seed,
+        random_generator_state_json,
         model_name,
         samplers_pickled,
         loss_function_pickled,
@@ -73,7 +75,8 @@
         convergence_precision,
         verbose,
         saving_folder,
-        model_seed,
+        initial_random_seed,
+        random_generator_state_json,
         model_name,
         samplers_pickled,
         loss_function_pickled,
@@ -102,6 +105,7 @@
         ?,
         ?,
         ?,
+        ?,
         ?
     )
 """
@@ -117,26 +121,27 @@
 SQL_DDL = """
     CREATE TABLE IF NOT EXISTS checkpoint (
         -- initialization parameters
-        parameters_bounds     NDARRAY,
-        parameters_precision  NDARRAY,
-        real_data             NDARRAY,
-        ensemble_size         INTEGER,
-        N                     INTEGER,
-        D                     INTEGER,
-        convergence_precision DOUBLE,
-        verbose               INTEGER,
-        saving_folder           TEXT,
-        model_seed            INTEGER,
-        model_name            TEXT,
-        samplers_pickled      BLOB,
-        loss_function_pickled BLOB,
+        parameters_bounds            NDARRAY,
+        parameters_precision         NDARRAY,
+        real_data                    NDARRAY,
+        ensemble_size                INTEGER,
+        N                            INTEGER,
+        D                            INTEGER,
+        convergence_precision        DOUBLE,
+        verbose                      INTEGER,
+        saving_folder                TEXT,
+        initial_random_seed          INTEGER,
+        random_generator_state_json  TEXT,
+        model_name                   TEXT,
+        samplers_pickled             BLOB,
+        loss_function_pickled        BLOB,
         -- arrays resulting from calibration
-        current_batch_index   INTEGER,
-        params_samp           NDARRAY,
-        losses_samp           NDARRAY,
-        series_samp           GZ_NDARRAY,
-        batch_num_samp        NDARRAY,
-        method_samp           NDARRAY
+        current_batch_index          INTEGER,
+        params_samp                  NDARRAY,
+        losses_samp                  NDARRAY,
+        series_samp                  GZ_NDARRAY,
+        batch_num_samp               NDARRAY,
+        method_samp                  NDARRAY
     );
 
     DELETE FROM checkpoint;
@@ -203,7 +208,8 @@ def load_calibrator_state(  # pylint: disable=too-many-locals
             convergence_precision,
             verbose,
             saving_file,
-            model_seed,
+            initial_random_seed,
+            random_generator_state_json,
             model_name,
             samplers_pickled,
             loss_function_pickled,
@@ -228,7 +234,8 @@ def load_calibrator_state(  # pylint: disable=too-many-locals
             convergence_precision,
             verbose,
             saving_file,
-            model_seed,
+            initial_random_seed,
+            json.loads(random_generator_state_json),
             model_name,
             samplers,
             loss_function,
@@ -257,7 +264,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
     convergence_precision: Optional[float],
     verbose: bool,
     saving_file: Optional[str],
-    model_seed: int,
+    initial_random_seed: Optional[int],
+    random_generator_state: Mapping,
     model_name: str,
     samplers: Sequence[BaseSampler],
     loss_function: BaseLoss,
@@ -282,7 +290,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
         convergence_precision: the convergence precision
         verbose: the verbosity mode
         saving_file: the saving file
-        model_seed: the model seed
+        initial_random_seed: initial random seed for the calibration task
+        random_generator_state: the state of the random generator
         model_name: the model name
         samplers: the ordered list of samplers to use in the calibration
         loss_function: the loss function
@@ -323,7 +332,8 @@ def save_calibrator_state(  # pylint: disable=too-many-arguments,too-many-locals
                 convergence_precision,
                 verbose,
                 saving_file,
-                model_seed,
+                initial_random_seed,
+                json.dumps(random_generator_state),
                 model_name,
                 samplers_pickled,
                 loss_function_pickled,
diff --git a/docs/index.md b/docs/index.md
index b6407215..553c259b 100644
--- a/docs/index.md
+++ b/docs/index.md
@@ -48,6 +48,9 @@ The following example will refer to **`examples/main.py`**.
 # define a loss
 loss = MethodOfMomentsLoss()
 
+# define the calibration seed
+calibration_seed = 1
+
 # initialize a Calibrator object
 cal = Calibrator(
     samplers=[halton_sampler, random_forest_sampler, best_batch_sampler],
@@ -55,12 +58,13 @@ cal = Calibrator(
     model=model,
     parameters_bounds=np.asarray(bounds),
     parameters_precision=np.asarray(bounds_step),
-    ensemble_size=1,
+    ensemble_size=3,
     loss_function=loss,
+    random_state=calibration_seed,
 )
 
 # calibrate the model
-params, losses = cal.calibrate(n_batches=4)
+params, losses = cal.calibrate(n_batches=5)
 ```
 The calibrator constructor accepts as inputs:
 
diff --git a/examples/docker-sir.py b/examples/docker-sir.py
index 01fb7a7b..7f58d34d 100755
--- a/examples/docker-sir.py
+++ b/examples/docker-sir.py
@@ -17,11 +17,11 @@
     bounds_step = [0.01, 0.01]  # Step size in range between bounds
 
     batch_size = 8
-    random_sampler = RandomUniformSampler(batch_size=batch_size, internal_seed=0)
-    rseq_sampler = RSequenceSampler(batch_size=batch_size, internal_seed=0)
-    halton_sampler = HaltonSampler(batch_size=batch_size, internal_seed=0)
-    best_batch_sampler = BestBatchSampler(batch_size=batch_size, internal_seed=0)
-    random_forest_sampler = RandomForestSampler(batch_size=batch_size, internal_seed=0)
+    random_sampler = RandomUniformSampler(batch_size=batch_size, random_state=0)
+    rseq_sampler = RSequenceSampler(batch_size=batch_size, random_state=0)
+    halton_sampler = HaltonSampler(batch_size=batch_size, random_state=0)
+    best_batch_sampler = BestBatchSampler(batch_size=batch_size, random_state=0)
+    random_forest_sampler = RandomForestSampler(batch_size=batch_size, random_state=0)
 
     # generate a synthetic dataset to test the calibrator
     N = 10
diff --git a/examples/main.py b/examples/main.py
index 54ae2717..4c574138 100755
--- a/examples/main.py
+++ b/examples/main.py
@@ -26,13 +26,16 @@
     model = md.MarkovC_KP
 
     # generate a synthetic dataset to test the calibrator
-    N = 1500
+    N = 2000
     seed = 1
     real_data = model(true_params, N, seed)
 
     # define a loss
     loss = MethodOfMomentsLoss()
 
+    # define the calibration seed
+    calibration_seed = 1
+
     # initialize a Calibrator object
     cal = Calibrator(
         samplers=[halton_sampler, random_forest_sampler, best_batch_sampler],
@@ -40,12 +43,13 @@
         model=model,
         parameters_bounds=np.asarray(bounds),
         parameters_precision=np.asarray(bounds_step),
-        ensemble_size=1,
+        ensemble_size=3,
         loss_function=loss,
+        random_state=calibration_seed,
     )
 
     # calibrate the model
-    params, losses = cal.calibrate(n_batches=4)
+    params, losses = cal.calibrate(n_batches=5)
 
     print(f"True parameters:       {true_params}")
     print(f"Best parameters found: {params[0]}")
diff --git a/examples/overview_of_the_different_samplers.ipynb b/examples/overview_of_the_different_samplers.ipynb
index b39c135c..d3ef9f71 100644
--- a/examples/overview_of_the_different_samplers.ipynb
+++ b/examples/overview_of_the_different_samplers.ipynb
@@ -70,34 +70,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 4,
+   "execution_count": 3,
    "id": "b7f542a1",
    "metadata": {},
    "outputs": [],
    "source": [
-    "sampler = RandomUniformSampler(batch_size=50, internal_seed=0)\n",
+    "sampler = RandomUniformSampler(batch_size=50, random_state=0)\n",
     "new_params = sampler.sample(param_grid, np.zeros((0, 2)), np.zeros((0, 2)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 5,
+   "execution_count": 4,
    "id": "f3f959fd",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2e4b05f90>"
+       "<matplotlib.legend.Legend at 0x7fe9bd497250>"
       ]
      },
-     "execution_count": 5,
+     "execution_count": 4,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -148,36 +148,36 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 6,
+   "execution_count": 5,
    "id": "af196713",
    "metadata": {
     "scrolled": true
    },
    "outputs": [],
    "source": [
-    "sampler = HaltonSampler(batch_size=50, internal_seed=0)\n",
+    "sampler = HaltonSampler(batch_size=50, random_state=0)\n",
     "new_params = sampler.sample(param_grid, np.zeros((0, 2)), np.zeros((0, 2)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 7,
+   "execution_count": 6,
    "id": "90e3a38b",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2e4ce1790>"
+       "<matplotlib.legend.Legend at 0x7fe9bd6c5ca0>"
       ]
      },
-     "execution_count": 7,
+     "execution_count": 6,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAU0AAAE/CAYAAADCGpEOAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAw6UlEQVR4nO3de3xV1bXo8d8gCSQSmoBCSQgcHgKKGkKMImrvEaiJNA3YU0t9fHz0aJVePQZOi0pP5USt59IPVozVyqHqEVtaSik3EKPCLWC1gsgjGqjKU1ryKpiYSGISkjDvHzs7ZCc7yVrJXvs5vp8Pn2TPvfbaY4kO51pzzjHFGINSSilrBgQ6AKWUCiWaNJVSygZNmkopZYMmTaWUskGTplJK2aBJUymlbHAsaYrIyyJyUkQOdPO+iMizInJEREpEJN2pWJRSylec7Gm+AtzQw/tzgIltf+4FXnAwFqWU8olop05sjHlbRMb2cMg84FXjml3/nogkikiSMaaip/NecMEFZuzYnk6rlFL27d279zNjzPDejnMsaVowCjjR4XVpW1uPSXPs2LHs2bPHybiUUhFIRP5m5bhADgSJlzavazpF5F4R2SMie06dOuVwWEop1b1AJs1SYHSH1ylAubcDjTGrjDEZxpiM4cN77T0rpZRjApk0NwF3tI2iXwXU9vY8UymlAs2xZ5oi8jvgOuACESkF/hOIATDGrAReB74BHAG+BL7nVCxKBavm5mZKS0tpbGwMdCgRIzY2lpSUFGJiYvr0eSdHz2/p5X0D3O/U9ysVCkpLSxkyZAhjx45FxNtjfuVLxhiqqqooLS1l3LhxfTqHrghSKoAaGxs5//zzNWH6iYhw/vnn96tnr0lTqQDThOlf/f3nrUlT2VJ0rIjM9Zmkrk4lc30mRceKAh2S6qerr74agOPHj/Pb3/7WZ+dtamriu9/9LhdeeCHTp0/n+PHjtj5fVVXFzJkziY+P54EHHvB4b+/evVx22WVceOGFPPjgg/hzBwpNmsqyomNF5O3Io6K+AoOhor6CvB15mjhD3I4dO4C+Jc3W1tZu33vppZcYOnQoR44cYdGiRTz88MO2zh0bG8sTTzzBU0891eW9H/zgB6xatYrDhw9z+PBh3nzzTVvn7g9Nmsqy/H35NLZ6PgtqbG0kf19+gCKKPAXFZVyzbBvjHinimmXbKCgu6/c54+PjAXjkkUd45513SEtLY8WKFbS2trJ48WKuuOIKUlNT+e///m8A3nrrLWbOnMmtt97KZZdd1u15N27cyJ133gnATTfdxNatW231CAcPHsy1115LbGysR3tFRQVffPEFM2bMQES44447KCgosHnVfRfIZZQqxFTWV9pqV75VUFzGkg37aWh29e7KahpYsmE/ADdOG9Xv8y9btoynnnqK1157DYBVq1aRkJDA7t27aWpq4pprriEzMxOA999/nwMHDvQ4Al1WVsbo0a71K9HR0SQkJFBVVcUFF1zQrzjLyspISUlpf52SkkJZWf//52GV9jSVZSMHj7TVrnxr+eaD7QnTraG5leWbDzryfVu2bOHVV18lLS2N6dOnU1VVxeHDhwG48sore52y461X6YtBL6fOa5UmTWVZbnousVGet0qxUbHkpucGKKLIUl7TYKu9v4wx/OIXv+CDDz7ggw8+4NNPP23vaQ4ePLjXz6ekpHDihKsmT0tLC7W1tQwbNszjmOeff560tDTS0tIoL/e6itrreUtLS9tfl5aWkpycbPWy+k2TZhA7tKuS1T9+l+cXbGP1j9/l0K7A3gZnj88m7+o8kgYnIQhJg5PIuzqP7PHZAY0rUiQnxtlqt2vIkCGcPn26/XVWVhYvvPACzc3NABw6dIj6+nrL55s7dy6rV68GYP369cyaNatLj/D+++9vT8pWE19SUhJDhgzhvffewxjDq6++yrx58yzH1V/6TDNIHdpVyfY1n9By5iwAddVNbF/zCQCTpgfudjh7fLYmyQBZnDXZ45kmQFxMFIuzJvvk/KmpqURHRzN16lTuuusucnNzOX78OOnp6RhjGD58uNcBl3vuuYcFCxaQkZHh0X733Xdz++23c+GFFzJs2DDWrl1rO6axY8fyxRdfcObMGQoKCtiyZQtTpkzhhRde4K677qKhoYE5c+YwZ86cvl62beLP+U2+kJGRYSKhnubqH79LXXVTl/b4YYO487+uCUBEYahkHWx9HGpLISEFZi+F1Pl+DeHjjz/m4osvtnx8QXEZyzcfpLymgeTEOBZnTfbJIFCk8fbPXUT2GmMyuvlIO+1pBilvCbOndmVTyToofBCa254H1p5wvQa/J047bpw2SpNkgOkzzSAVP2yQrXZl09bHzyVMt+YGV7tSPdCkGaRmzJtA9EDPv57ogQOYMW9CgCIKM7Wl9tqVaqO350HKPdizc+NR6qqbiB82iBnzJgR0ECisJKS4bsm9tSvVA02aQWzS9JGaJJ0ye6nnM02AmDhXu1I90NtzFZlS50POs5AwGhDXz5xng3oQSAUHTZoqcqXOh0UHIK/G9TNCE6ZTpeHefvtt0tPTiY6OZv369R7vrV69mokTJzJx4sT2CfBWffnll2RnZ3PRRRdxySWX8Mgjj7S/199ydFZo0lQqQrXU1NB48CBbV62i8eBBjh444NPScGPGjOGVV17h1ltv9Wivrq7mscceY9euXbz//vs89thjfP7557a+90c/+hGffPIJxcXFvPvuu7zxxhtA/8vRWaFJU6lQUrIOVlwKeYmunyXr+nSalpoamsvKMc3NDL/ySkxzM0v+4z945+23fVYabuzYsaSmpjJggGea2bx5M9dffz3Dhg1j6NChXH/99bbqYZ533nnMnDkTgIEDB5Kent6+Fr2/5eis0IEgpUKFDyfkt/zjH2DOerQ9sXAh+atX8/pbbwH9Lw3XnY4l46B/pd1qamooLCwkNze3y7l9WY6uI02abXR5mgp6PU3It5k0TVsRji7tHXplW7ZsoaSkpP15ZG1tLYcPH2bgwIGWSsN1+90+Ku3W0tLCLbfcwoMPPsj48eN9eu6e6O0554q7ltU0YDhX3NUXVbGV8hkfTsiXbvb87phg+lsarjsdS8aB99JuJ06caC8Zt3LlSq/nuffee5k4cSILFy70eu7uytH1lyZN/F/cVak+6W7ifR8m5Ed/9asgnv/5xw+Op65DD7S/peG6k5WVxZYtW/j888/5/PPP2bJlC1lZWR7HjB49uj1ZL1iwoMs5fvKTn1BbW8szzzzj0W6lHF1/adLE/8VdleqT2UtdE/A76uOE/OjERGJGJbf3OCUmhvSZ1xETG8vUqVNZsWIF99xzD1OmTCE9PZ1LL72U++67j5aWli7nuueee/BWeWz37t2kpKTwhz/8gfvuu49LLrkEgGHDhvHoo49yxRVXcMUVV7B06VJbvcHS0lKefPJJPvroI9LT00lLS+PFF18EXOXoqqqquPDCC3n66adZtmyZ7X82vdHScMA1y7ZR5iVBjkqM491HZvn0u5TqyG5puGAoZxcOtDRcPzld3FUpn0mdr0kywDRpcm4nPx09V0r1RpNmm0gv7npoV6VWVFLKAk2aKmj3I1IqGOnouWLnxqPtCdOt5cxZdm48GqCIlApe2tNUuh+RCho1TTWcrD9J89lmYgbEMGLwCBIHJQY6LA/a01S6H1GEc6o03NNPP82UKVNITU1l9uzZ/O1vf2t/z1tpuJqmGsrrymk+65pM33y2mfK6cmqaarqc+4YbbmDq1KlccsklLFiwoL3akpaGU36h+xFFth07dgB9S5o9lYabNm0ae/bsoaSkhJtuuomHHnoI6L403Mn6k13WjhtjOFl/ssu5161bx4cffsiBAwc4deoUf/jDHwAtDaf8ZNL0kcy87aL2nmX8sEHMvO0iHQQKQkXHishcn0nq6lQy12dSdKyo3+eMj48H4JFHHuGdd97xWWm4mTNnct555wFw1VVXtZdv6640nLuH2Zm39q985SuAa335mTNn2pdKamk45Te6H1HwKzpWRN6OPBpbGwGoqK8gb0ceANnjs/t9/mXLlvHUU0/x2muvAb4tDffSSy8xZ84coPvScJcPuNxrgowZ4L24SFZWFu+//z5z5szhpptu6nJuLQ2nVBAI5HzW/H357QnTrbG1kfx9+T5Jmp35qjTcb37zG/bs2cOf//xnoPvybSMGj6C8rtzjfXe7N5s3b6axsZHbbruNbdu2cf3112tpOKWCiXs+q3tWgXs+66FdlX75/sp679/TXXt/+aI03J/+9CeefPJJNm3axKBBrsc/3ZWGSxyUSHJ8MjEDYqgoq+CmmTfx3VnfZe3/rO32/LGxscydO5eNGzd2ObeWhlMqwAI9n3XkYO892u7a7RoyZAinT59uf93f0nDFxcXcd999bNq0iREjzvUWeyoNlzgokUnDJvH1qV/n4/0fs//D/V1Kw9XV1VFRUQG4EuPrr7/ORRddBPinNJzenitlUaDns+am53o80wSIjYolNz3XJ+dPTU0lOjqaqVOnctddd5Gbm8vx48dJT0/HGMPw4cMpKCjo8rl77rmHBQsWkJHhWSBo8eLF1NXV8Z3vfAdwbbS2adMmj9JwgO3ScPX19cydO5empiZaW1uZNWtWe2K9++67uf3227nwwgsZNmwYa9d230vtKy0Np5RFq3/8rtcEGT9sEHf+1zV9Oqfd0nBFx4rI35dPZX0lIwePJDc915HnmeFOS8Op8BRktSNnzJvgsUYf/D+fNXt8tibJANOkqYKTD3de9BX3KLlWg4psjiZNEbkByAeigBeNMcs6vZ8A/AYY0xbLU8aY/3EyJhUifLjzoi/pfFbl2Oi5iEQBzwNzgCnALSIypdNh9wMfGWOmAtcBPxeRgU7FpEKID3deVMqXnJxydCVwxBhzzBhzBlgLzOt0jAGGiGtOQDxQDXTduUlFHh/uvKiULzmZNEcBJzq8Lm1r6+g54GKgHNgP5BpjzqKUD3deVMqXnEya3maUdp7flAV8ACQDacBzIvKVLicSuVdE9ojInlOnTlkOoLawkMOzZvPxxVM4PGs2tYWFlj+rAix1PuQ8CwmjAXH9zHlWNxVzgFOl4VauXMlll11GWloa1157LR999FH7e95Kw/XF3LlzufTSS9tf+6M0HMYYR/4AM4DNHV4vAZZ0OqYI+FqH19uAK3s67+WXX26sqNm0yXw8Nc18NPmi9j8fT00zNZs2Wfq8Uv7w0UcfBTqEdtu3bzfZ2dm2PtPS0tLte7W1te2/b9y40WRlZRljjKmqqjLjxo0zVVVVprq62owbN85UV1fbjvePf/yjueWWW8wll1zS3vb888+b++67zxhjzO9+9zszf/58r5/19s8d2GMs5DYne5q7gYkiMq5tcOdmYFOnY/4OzAYQka8Ck4FjvvjykyuewTR6FjcwjY2cXPGML06vlC0FxWVcs2wb4x4p4ppl2ygoLuvTeZy4e3KqNJy7fBu4VvG4lzN2VxrOjrq6Op5++ml+8pOfeLSHdGk4Y0yLiDwAbMY15ehlY8xfRWRB2/srgSeAV0RkP67b+YeNMZ/54vtb2tamWm1XyikFxWUs2bCfhmZXwd6ymgaWbNgPwORY6+epLSyk4tGl7Z2BlvJyKh51PeNNyMnpd5xOlIZ7/vnnefrppzlz5gzbtm0Dui8NZ8ejjz7KD3/4w/Z6nW7+KA3naMEOY8zrxphJxpgJxpgn29pWtiVMjDHlxphMY8xlxphLjTG/8dV3Rycl2WpXyinLNx9sT5huDc2tLN980NZ5/H33tGXLFl599VXS0tKYPn06VVVVHD58GMByabj777+fo0eP8rOf/Yyf/vSnrpj7Wb7tgw8+4MiRI3zrW9/q8l5/z21F2FY5GrFoIRLr+b9xiY1lxKKFgQlIRazymgZb7d3x992T8UFpOLebb765vdhHd6XhOjpx4gRpaWmkpaWxcuVKj/d27tzJ3r17GTt2LNdeey2HDh3iuuuu63JuLQ1nU0JODklPPE50cjKIEJ2cTNITj/vkNkYpO5IT42y1d8fpuydfl4Zz90oBioqKmDhxYvt5uysN5zZ69Oj2ZN25NNwPfvADysvLOX78OH/5y1+YNGkSb731FqCl4fotISdHk6QKuMVZkz2eaQLExUSxOGsy8IXl84xYtNDjmSb49u7J16XhnnvuOf70pz8RExPD0KFD25NZf0vD9URLw3mhpeFUKCooLmP55oOU1zSQnBjH4qzJ3DhtlO3ScLWFhZxc8QwtFRVEJyUxYtFC7Rj0gZaGUyrI3ThtFDdO67wgzj69ewo8TZpKqZDUWNdMXU0TZ1vPMiBqAPGJg4iN975zpS9p0lRKhZzGumZOVze2TzE623qW09WuZ71OJ86wHT1XSoWvupqmLnMyjTHU1Ti/X5MmTX8rWQcrLoW8RNfPknWBjkipkHO21XsxtO7afUlvz/0pCLdwUCoUDYga4DVBDohyvh+oPU1/6mkLB6UCxKnScG7r169HROg4VbC/peH+5ZZsrp51ObPmXMusOddy6rNTiAgxcTheGk57mv6kWzioILRjxw7gXNK89dZbLX+2tbWVqKiobt8/ffo0zz77LNOnT29vq66u5rHHHmPPnj2ICJdffjlz585l6NChlr93QJSw+n9+zeTxl3qMnr/86q8YOnQoR44cYe3atTz88MP8/ve/t3xeS9/t07OpnukWDqqfDu2qZPWP3+X5BdtY/eN3ObSrst/ndKo0HLiqET300EPEdqgD4YvScACDzovmgpR4RvzTV7ggJZ7Y+Bi/lIbTpOlPEbyFg1bR779DuyrZvuYT6qpdI8R11U1sX/OJTxInuErDfe1rX+ODDz5g0aJFvPTSS+2l4Xbv3s2vfvUrPv30U8BVGu7JJ5/0qMbeWXFxMSdOnOCb3/ymR7svSsMBfO973yMtLY0nnniiPTF2VxrOl/T23J/cgz1bH3fdkiekuBJmmA8COV0HMlLs3HiUljOegx8tZ86yc+NRR7YV3rJlCyUlJaxfvx6A2tpaDh8+zMCBA3stDXf27FkWLVrEK6+80uU9X5RvW7NmDaNGjeL06dN8+9vf5te//jV33HGHloYLS6nzYdEByKtx/QzzhAlaRd9X3D1Mq+391Z/ScKdPn+bAgQNcd911jB07lvfee4+5c+eyZ8+efpeGAxg1yrUkdciQIdx66628//77gJaGU2FCq+j7RvywQbba7fJlabiEhAQ+++wzjh8/zvHjx7nqqqvYtGkTGRkZ/S4N19LSwmefuTZ4aG5u5rXXXmvfXE1Lw6mwEJ2UREt5udd2Zd2MeRPYvuYTj1v06IEDmDFvgk/O7+vScN3pb2m4pqYmsrKyaG5uprW1la9//et8//vfB7Q0nFdaGi70dH6mCa46kFoU2nuJsp4c2lXJzo1HqatuIn7YIGbMm+DI88wuvqyG0xXQegaiBsKQJDjPt7e9/qSl4VRQcydGrQPZf5Omj/RPkuzoy2rX6jXT1sNtPeN6DSGdOPtKk6byC60DGcJOV5xLmG7mrKs9ApOmDgQppXrWesZee5jTpKlUgAX9uELUQHvtQa6//7z19lypAIqNjaWqqorzzz+/X1NjappqOFl/kuazzcQMiGHE4BEkDkr0TZBDkjyfaQLIAFd7iDHGUFVV5bGs0y5NmkoFUEpKCqWlpZw6darP52hoaaCmsQbDuR5UKaUkxiYSF21vm+BunWmGxlo42wIDoiE2AWr+AfzDN+f3o9jYWFJS+l7vQZOmUgEUExPT43JEKzLXZ1JR33WhQNLgJLbctKVf51ZdadIMM91tFavCV2W994Id3bWr/tGBoDBSUFzGkg37KatpwABlNQ0s2bCfgmL7FWRU6Bg52Pu8ze7aVf9o0gwjyzcfpKG51aOtobmV5ZsPBigi5Q+56bnERnkObMRGxZKbnhugiMKb3p6HkfKaBlvtKjxkj88GIH9fPpX1lYwcPJLc9Nz2duVbmjTDSHJiHGVeEmRyoo9GUFXQyh6frUnST/T2PIwszppMXIznfi1xMVEszpocoIiUCj/a0wwj7lFyHT1XyjmaNMPMjdNGaZJUykF6e66UUjZo0lRKKRs0aSrVR0XHishcn0nq6lQy12dSdKwo0CEpP9Bnmkr1QdGxIvJ25NHY6trCo6K+grwdeQA69SfMaU9TqT7I35ffnjDdGlsbyd+XH6CIlL9o0lSqD7RIRuTSpKlUH2iRjMilSVOpPtAiGZFLB4KU6gMtkhG5HE2aInIDkA9EAS8aY5Z5OeY64BkgBvjMGPPPTsaklK9okYzI5FjSFJEo4HngeqAU2C0im4wxH3U4JhH4JXCDMebvIjLCqXiUUr51aFclOzcepa66ifhhg5gxbwKTpof/M10nn2leCRwxxhwzxpwB1gLzOh1zK7DBGPN3AGPMSQfjUUr5yKFdlWxf8wl11U0A1FU3sX3NJxzaFf6zB5xMmqOAEx1el7a1dTQJGCoib4nIXhG5w8F4lFI+snPjUVrOnPVoazlzlp0bjwYoIv9x8pmmt02cO+/SHg1cDswG4oCdIvKeMeaQx4lE7gXuBRgzZkzfoilZB1sfh9pSSEiB2UshdX7fzqVUhHP3MK22hxMne5qlwOgOr1OAci/HvGmMqTfGfAa8DUztfCJjzCpjTIYxJmP48OH2IylZB4UPuja8x7h+Fj7oaldK2RY/bJCt9nDiZNLcDUwUkXEiMhC4GdjU6ZiNwNdEJFpEzgOmAx/7PJKtj0Nzp20gmhtc7Uop22bMm0D0QM/0ET1wADPmTQhQRP7j2O25MaZFRB4ANuOacvSyMeavIrKg7f2VxpiPReRNoAQ4i2ta0gGfB1Nbaq9dKdUj9yh5JI6eizGdHzMGt4yMDLNnzx57H1pxaduteScJo2GR73O0Uir0iMheY0xGb8dFxjLK2UshptOOjDFxrvYIUVtYyOFZs/n44ikcnjWb2sLCQIekVEiKjGWU7lHyCB09ry0spOLRpZhGVymzlvJyKh51/Q8jIScnkKEpFXIi4/Y8wh2eNZuW8s4TFyA6OZmJ27YGICIVqQqKy4J2t1Srt+eR0dOMcC0VFbbalXJCQXEZSzbsp6G5FYCymgaWbNgPEDSJ04rIeKYZ4aKTkmy1K+WE5ZsPtidMt4bmVpZvPhigiPqm26QpIpeJyHsickJEVonI0A7vve+f8JQvjFi0EIn1rP0osbGMWLQwMAGpiFRe02CrPVj11NN8AcgDLgMOAX8REffM1RiH41I+lJCTQ9ITjxOdnAwiRCcnk/TE4zoIpPwqOTHOVnuw6umZZrwx5s22358Skb3AmyJyO13XkKsgl5CTo0lSBdTirMkezzQB4mKiWJw1OYBR2ddT0hQRSTDG1AIYY7aLyLeBPwLD/BKdUipsuAd7gnX03KqekubPgIuB99wNxpgSEZkNPOp0YEqp8HPjtFEhlyQ76zZpGmN+203734HvOxaRUgEUqdXIlXU6T1OpNu5q5O7iuu5q5IAmTtVO52kq1SaSq5Er6zRpqoApOlZE5vpMUlenkrk+k6JjRQGNJ5KrkSvr+pQ0ReSbvg5ERZaiY0Xk7cijor4Cg6GivoK8HXkBTZyRXI1cWdfXnuYVPo1CRZz8ffk0tjZ6tDW2NpK/Lz9AEUV2NXJlXZ8Ggowx/+nrQFRkqaz3vtVrd+3+EMnVyJV1vSZNEYkCsoGxHY83xjztXFgq3I0cPJKK+q5VlkYODmyCmjR9pCZJ1SMrt+eFwF3A+cCQDn+U6rPc9FxiozyLiMRGxZKbnhugiJSyxsrteYoxJtXxSFREyR6fDbiebVbWVzJy8Ehy03Pb25UKVlaS5hsikmmM2eJ4NCqiZI/P1iSpQo6V2/P3gP8rIg0i8oWInBaRL5wOLBjoZmRKqc6s9DR/DswA9ptQ21CoH3QzMqWUN1Z6moeBA5GUMAFOrnimPWG6mcZGTq54JjABqchWsg5WXAp5ia6fJesCHVHEstLTrADeEpE3gPb1ZOE+5Ug3I1NBo2QdFD4IzW3bQtSecL2GiNmGOphY6Wl+CmwFBhJBU450MzIVNLY+fi5hujU3uNqV3/Xa0zTGPOaPQILNiEULPZ5pgm5GpgKkttReu3KUlRVBw4GHgEuA9tnIxphZDsYVcO7BnpMrnqGlooLopCRGLFqog0DK/xJSXLfk3tqV31l5prkG+D3wTWABcCdwysmggoVuRqaCwuylns80AWLiXO2qi9rCQkc7O1aeaZ5vjHkJaDbG/NkY86/AVT6LQCnVs9T5kPMsJIwGxPUz51kdBPLCPVWwpbwcjGmfKujLOdZWeprNbT8rRCQbKAf0vkApf0qdr0nSgp6mCvqqt2klaf5URBKAHwK/AL4CLPLJtyullA/5Y6pgj0mzrSzcRGPMa0AtMNNn36yUUj4WnZTkujX30u4rPT7TNMa0AnN99m1KKeWgEYsWIrGeJQd9PVXQyu35DhF5DtcIer270Rizz2dRhJGC4jKWbz5IeU0DyYlxLM6azI3TRgU6LKUigj+mCkpvS8pFZLuXZhOoeZoZGRlmz549gfjqXhUUl7Fkw34amlvb2+Jiovg//3KZJk6lgpyI7DXGZPR2nJUVQfoc06Llmw96JEyAhuZWlm8+qElTqTBhaWO1tqlGnVcE6cLXTsprGmy1K6VCT6+T20VkJfBd4N8AAb4D/JPDcYWk5MQ4W+1KqdBjpad5tTEmVURKjDGPicjPgQ1OBxaKFmdN9vpMc3HW5ABGFR4O7arUrXVVULCSNN33ll+KSDJQBYxzLqTQ5X5uqaPnvnVoVyXb13xCy5mzANRVN7F9zScAmjiV31lJmq+JSCKwHNgHGOBXTgYVym6cNkqTpI/t3Hi0PWG6tZw5y86NRzVp+krJOld9ztpSV/Wk2Ut12WY3rIyeP9H26x9F5DUg1hhT62xYSp1TV91kq13ZpJXhbbEyEBQrIv8uIhuA3wL/KiKxvX2u7bM3iMhBETkiIo/0cNwVItIqIjdZD11Fivhhg2y1K5u0MrwtVkrDvYprutEvgOeAi4Ff9/ahtnXrzwNzgCnALSIypZvjfgZsth62iiQz5k0geqDnv6rRAwcwY96EAEUUZrQyvC1WnmlONsZM7fB6u4h8aOFzVwJHjDHHAERkLTAP+KjTcf8G/BG4wsI5VQRyP7fU0XOHaGV4W6wkzWIRucoY8x6AiEwH3rXwuVFAx7+JUmB6xwNEZBTwLWAWmjRVDyZNH6lJ0ilaGd4WK0lzOnCHiPy97fUY4GMR2Y9rDXpqN58TL22dF7o/AzxsjGkV8XZ424lE7gXuBRgzZoyFkJVSlrkHe3T03BIrSfOGPp67FBjd4XUKrqrvHWUAa9sS5gXAN0SkxRhT0PEgY8wqYBW4Cnb0MR6lVHe0MrxlVqYc/a2P594NTBSRcUAZcDNwa6dzt0+SF5FXgNc6J0ylwonTm34p51kq2NEXxpgWEXkA16h4FPCyMeavIrKg7f2VTn23UsHIvemXew8b96ZfgCbOENJrPc1gE8z1NJXqyeFZs71vxZCczMRtWwMQkerIZ/U0VWTRyvPO8cemX8p5Via3qwjhrjxfVtOAAcpqGliyYT8FxWWBDi0sdLe5ly83/VLO06Sp2vVUeV71nz82/VLO09tz1U4rzzvLH5t+Kedp0lTtkhPjKPOSILXyvO8k5ORokgxxenseYoqOFZG5PpPU1alkrs+k6FiRz869OGsycTFRHm1aeV4pT9rTDCFFx4rI25FHY6trnl9FfQV5O/IAyB6f3e/za+V5pXqn8zRDSOb6TCrqu05PSRqcxJabtgQgIqXCh9V5mnp7HkIq6ytttSulfE+TZggZOdh7abTu2pVSvqdJM4TkpucSG+U5zy82Kpbc9NwARRTcCorLuGbZNsY9UsQ1y7bpJH3lEzoQFELcgz35+/KprK9k5OCR5Kbn+mQQKNy4Vze5J+u7VzcBOrCl+kWTZojJHp+tSdKCnlY3adJU/aG35yos6eom5RRNmiosdbeKSVc3qf7SpKnCkq5uUk7RZ5oqLOnqJuUUTZoqbN04bZQmSeVzentukZOFMpRSoUN7mhY4XShDKRU6tKdpQf6+/PaE6dbY2kj+vvwARaSUChRNmhZooQyllJsmTQu0UIZSyk2TpgVaKEMp5aYDQRZooQyllJsmTYu0UIZSCjRpKosO7apk58aj1FU3ET9sEDPmTWDSdH2mqyKPJk3Vq0O7Ktm+5hNazpwFoK66ie1rPgHQxKkijg4EqV7t3Hi0PWG6tZw5y86NRwMUkYpoJetgxaWQl+j6WbLOr1+vPU3Vq7rqJlvtSjmmZB0UPgjNbXVRa0+4XgOkzvdLCNrTVL2KHzbIVrtSjtn6+LmE6dbc4Gr3E02aqlcz5k0geqDnvyrRAwcwY96EAEWkIlZtqb12B+jtueqVe7BHR89VwCWkuG7JvbX7iSZNZcmk6SM1SarAm73U85kmQEycq91P9PZcKRU6UudDzrOQMBoQ18+cZ/02CATa01RKhZrU+X5Nkp1pT1NFlNrCQg7Pms3HF0/h8KzZ1BYWBjokFWK0p6kiRm1hIRWPLsU0ugpKt5SXU/Go61lYQk5OIENTIUR7mipinFzxTHvCdDONjZxc8UxgAlIhSXuayjEFxWVBtYVuS0WFrXalvNGepnJEQXEZSzbsp6ymAQOU1TSwZMN+CorLAhZTdFKSrXalvNGkqRyxfPNBGppbPdoamltZvvlggCKCEYsWIrGeFfglNpYRixYGJiAVkvT2XDmivKbBVrs/uAd7Tq54hpaKCqKTkhixaKEOAilbHE2aInIDkA9EAS8aY5Z1ev824OG2l3XAD4wxHzoZk/KP5MQ4yrwkyOTEuABEc05CTo4mSdUvjiVNEYkCngeuB0qB3SKyyRjzUYfDPgX+2RjzuYjMAVYB052KqTOtRu6cxVmTWbJhv8ctelxMFIuzJgcwKqX6z8me5pXAEWPMMQARWQvMA9qTpjFmR4fj3wP8tupeq5E7yz1KHkyj50r5gpNJcxTQsRxJKT33Iu8G3nAwHg89VSPXpOkbN04bpUlShR0nk6Z4aTNeDxSZiStpXtvN+/cC9wKMGTPGJ8FpNXIVTIqOFekW0SHCySlHpcDoDq9TgPLOB4lIKvAiMM8YU+XtRMaYVcaYDGNMxvDhw30SnFYjV8Gi6FgReTvyqKivwGCoqK8gb0ceRceKAh2a8sLJpLkbmCgi40RkIHAzsKnjASIyBtgA3G6MOeRgLF1oNXIVLPL35dPY6rm8s7G1kfx9+QGKSPXEsdtzY0yLiDwAbMY15ehlY8xfRWRB2/srgaXA+cAvRQSgxRiT4VRMHWk1chUsKusrbbWrwHJ0nqYx5nXg9U5tKzv8fg9wj5Mx9ESrkatgMHLwSCrqu65/HzlY/90MRrqMUqkAy03PJTbKc3lnbFQsuem5AYpI9USXUSoVYO5Rch09Dw2aNJUKAtnjsyMuSdYWFoZkHQBNmkopvwvlKvr6TFMp5XehXEVfk2awKVkHKy6FvETXz5J1gY5IKZ8L5Sr6mjSDSck6KHwQak8AxvWz8EFNnCrshHIVfU2awWTr49DcqQZlc4OrXakwEspV9HUgKJjUltprVypEhXIVfU2awSQhpe3W3Eu7UmEmVKvo6+15MJm9FGI6bQcRE+dqV0oFBU2awSR1PuQ8CwmjAXH9zHnW1a6UCgp6ex5sUudrklQqiGlPU4WsomNFZK7PJHV1KpnrM7Vor/IL7WmqkOSudu4u3uuudg5E3Bpu5V/a01QhSaud21NQXMY1y7Yx7pEirlm2jYLiskCHFLK0p6lCklY7t66guMxjD/qymgaWbNgPoLuF9oH2NFVI6q6quVY772r55oPtCdOtobmV5ZsPBiii0KZJU4UkrXZuXXlNg6121TO9PVchSaudW5ecGEeZlwSZnBjn5WjVG02aKmRFYrXzvlicNdnjmSZAXEwUi7MmBzCq0KVJU6kQcmhXpe1tp92DPcs3H6S8poHkxDgWZ03WQaA+0qSpVIg4tKuS7Ws+oeXMWQDqqpvYvuYTAEuJU5Okb+hAkFIhYufGo+0J063lzFl2bjwaoIgikyZNpUJEXXWTrXblDE2aSoWI+GGDbLUrZ2jSjDS6cVvImjFvAtEDPf+TjR44gBnzJgQoosikA0GRxL1xm3sfIvfGbaDl6EKAe7DH7ui58i1NmpGkp43bNGmGhEnTR2qSDDC9PY8kunGbUv2mSTOSdLdBm27cppRlmjQdVFtYyOFZs/n44ikcnjWb2sLCwAakG7cp1W/6TNMhtYWFVDy6FNPoKpTbUl5OxaOu5BSwbUvdzy23Pu66JU9IcSVMfZ6plGVijAl0DLZkZGSYPXv2BDqMXh2eNZuW8vIu7dHJyUzctjUAESmleiIie40xGb0dpz1Nh7RUVNhqV8GnoLhMi1yoLvSZpkOik5Jstavg4t4ioqymAcO5LSJ0bx2lSdMhIxYtRGI9K4tLbCwjFi0MTEDKFt0iQnVHb88d4h7sObniGVoqKohOSmLEooWBGwRStugWEao7mjQdlJCTo0kyROkWEao7enuulBeLsyYTFxPl0aZbRCjQnqZSXukWEao7mjSV6oZuEWFd0bGiiNkZVJOmUqpfio4Vkbcjj8ZW1+q3ivoK8nbkAYRl4nT0maaI3CAiB0XkiIg84uV9EZFn294vEZF0J+NRSvle/r789oTp1tjaSP6+/ABF5CzHkqaIRAHPA3OAKcAtIjKl02FzgIltf+4FXnAqHqWUMyrrK221hzone5pXAkeMMceMMWeAtcC8TsfMA141Lu8BiSKiS2aUCiEjB3svitxde6hzMmmOAk50eF3a1mb3GKVUEMtNzyU2ynP1W2xULLnpuQGKyFlODgSJl7bOJZWsHIOI3Ivr9p0xY8b0PzKllM+4B3t09Lz/SoHRHV6nAJ1rpVk5BmPMKmAVuErD+TZMpVR/ZY/PDtsk2ZmTt+e7gYkiMk5EBgI3A5s6HbMJuKNtFP0qoNYYo7XTlFJBy7GepjGmRUQeADYDUcDLxpi/isiCtvdXAq8D3wCOAF8C33MqHqWU8gVHJ7cbY17HlRg7tq3s8LsB7ncyBqWU8iUt2KGUUjZo0lRKKRs0aSqllA2aNJVSygZNmkopZUPI7XsuIqeAv/VwyAXAZ34Kx1/0mkJHOF5XOF4TdL2ufzLGDO/tQyGXNHsjInusbPgeSvSaQkc4Xlc4XhP0/br09lwppWzQpKmUUjaEY9JcFegAHKDXFDrC8brC8Zqgj9cVds80lVLKSeHY01RKKceEZNIM1w3bLFzXbW3XUyIiO0RkaiDitKO3a+pw3BUi0ioiN/kzvr6wck0icp2IfCAifxWRP/s7xr6w8O9fgogUisiHbdcV9FXJRORlETkpIge6ed9+rjDGhNQfXGXmjgLjgYHAh8CUTsd8A3gDV2X4q4BdgY7bR9d1NTC07fc5wX5dVq6pw3HbcFXEuinQcfvg7ykR+AgY0/Z6RKDj9tF1/Rj4Wdvvw4FqYGCgY+/luv4XkA4c6OZ927kiFHua4bphW6/XZYzZYYz5vO3le7gq3QczK39XAP8G/BE46c/g+sjKNd0KbDDG/B3AGBMu12WAISIiQDyupNni3zDtMca8jSvO7tjOFaGYNMN1wza7Md+N6/+QwazXaxKRUcC3gJWEBit/T5OAoSLylojsFZE7/BZd31m5rueAi3FtSbMfyDXGnPVPeI6xnSscLULsEJ9t2BZkLMcsIjNxJc1rHY2o/6xc0zPAw8aYVlcHJuhZuaZo4HJgNhAH7BSR94wxh5wOrh+sXFcW8AEwC5gA/D8ReccY84XDsTnJdq4IxaTpsw3bgoylmEUkFXgRmGOMqfJTbH1l5ZoygLVtCfMC4Bsi0mKMKfBLhPZZ/ffvM2NMPVAvIm8DU4FgTppWrut7wDLjehh4REQ+BS4C3vdPiI6wnysC/aC2Dw92o4FjwDjOPbC+pNMx2Xg+3H0/0HH76LrG4NpP6epAx+ura+p0/CsE/0CQlb+ni4GtbceeBxwALg107D64rheAvLbfvwqUARcEOnYL1zaW7geCbOeKkOtpmjDdsM3idS0Fzgd+2dYzazFBXEjB4jWFFCvXZIz5WETeBEqAs8CLxhivU16ChcW/qyeAV0RkP64k87AxJqirH4nI74DrgAtEpBT4TyAG+p4rdEWQUkrZEIqj50opFTCaNJVSygZNmkopZYMmTaWUskGTplJK2aBJU6keiMhFIrJTRJpE5EeBjkcFXsjN01SqMxGJNsY4VTiiGngQuNGh86sQo0lTBZyIjAXeBHYB03AtN7zDGPOliCwFcnCt4d4B3GeMMSLyVtvra4BNInII+Amu1SxVwG3GmH+ISB6uVS5JuApp/DuulR9zcK1oyTHGNHcXm3FVKDopItm+vm4VmvT2XAWLycAqY0wq8AXwv9vanzPGXGGMuRRX4vxmh88kGmP+2Rjzc+AvwFXGmGm4ypo91OG4CbiWy80DfgNsN8ZcBjS0tStlmSZNFSxOGGPebfv9N5yr4DRTRHa1Ld2bBVzS4TO/7/B7CrC57bjFnY57o603uR/XEsE329r341qXrJRlmjRVsOi8nteISCzwS1xFPC4DfgXEdjimvsPvv8DVK70MuK/TcU0AxlX7sdmcWzt8Fn1EpWzSpKmCxRgRmdH2+y24brfdie8zEYkHeto/KAHXM0qAO50JUSlNmip4fAzcKSIlwDDgBWNMDa7e5X6gANjdw+fzgD+IyDuA7co7IvK4iMz10j6yrTrOvwM/EZFSEfmK3fOr8KFVjlTAtY2ev9Y22KNUUNOeplJK2aA9TaWUskF7mkopZYMmTaWUskGTplJK2aBJUymlbNCkqZRSNmjSVEopG/4/5GPGodB6/1AAAAAASUVORK5CYII=\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -212,34 +212,34 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 9,
+   "execution_count": 7,
    "id": "a2e104a4",
    "metadata": {},
    "outputs": [],
    "source": [
-    "sampler = RSequenceSampler(batch_size=50, internal_seed=0)\n",
+    "sampler = RSequenceSampler(batch_size=50, random_state=0)\n",
     "new_params = sampler.sample(param_grid, np.zeros((0, 2)), np.zeros((0, 2)))"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 10,
+   "execution_count": 8,
    "id": "214f7dd7",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2e4dccb10>"
+       "<matplotlib.legend.Legend at 0x7fe9bd7894c0>"
       ]
      },
-     "execution_count": 10,
+     "execution_count": 8,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -282,7 +282,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 11,
+   "execution_count": 9,
    "id": "2bb09e7f",
    "metadata": {},
    "outputs": [],
@@ -290,13 +290,17 @@
     "# In the folliwing we will assume that the value of the loss function\n",
     "# is known on a grid of points in parameter space\n",
     "\n",
-    "xs = np.linspace(0, 1, 6)\n",
-    "ys = np.linspace(0, 1, 6)\n",
+    "xs = np.linspace(0, 1, 6) \n",
+    "ys = np.linspace(0, 1, 6) \n",
     "xys = []\n",
     "losses = []\n",
     "\n",
     "for x in xs:\n",
     "    for y in ys:\n",
+    "        # a small noise is needed to avoid \n",
+    "        # unrealistically simmetric sampling\n",
+    "        x = x + np.random.normal(0, 1e-2)\n",
+    "        y = y + np.random.normal(0, 1e-2)\n",
     "        xys.append([x, y])\n",
     "        losses.append(5 * (x**2 + y**2))\n",
     "\n",
@@ -306,23 +310,25 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 12,
+   "execution_count": 10,
    "id": "db83cf9c",
-   "metadata": {},
+   "metadata": {
+    "scrolled": true
+   },
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.colorbar.Colorbar at 0x7fc2e4f81850>"
+       "<matplotlib.colorbar.Colorbar at 0x7fe9bd901790>"
       ]
      },
-     "execution_count": 12,
+     "execution_count": 10,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 432x288 with 2 Axes>"
       ]
@@ -351,7 +357,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 13,
+   "execution_count": 11,
    "id": "b96d77f1",
    "metadata": {},
    "outputs": [
@@ -364,29 +370,29 @@
     }
    ],
    "source": [
-    "sampler = RandomForestSampler(batch_size=16, internal_seed=0)\n",
+    "sampler = RandomForestSampler(batch_size=16, random_state=0)\n",
     "new_params = sampler.sample(param_grid, xys, losses)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": 14,
+   "execution_count": 12,
    "id": "af8da581",
    "metadata": {},
    "outputs": [
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2e500c550>"
+       "<matplotlib.legend.Legend at 0x7fe9bd9b2ca0>"
       ]
      },
-     "execution_count": 14,
+     "execution_count": 12,
      "metadata": {},
      "output_type": "execute_result"
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -419,7 +425,7 @@
   },
   {
    "cell_type": "code",
-   "execution_count": 15,
+   "execution_count": 13,
    "id": "0ee170a4",
    "metadata": {
     "scrolled": true
@@ -429,28 +435,46 @@
      "name": "stderr",
      "output_type": "stream",
      "text": [
-      " /Users/aldoglielmo/miniconda3/envs/py37bbc/lib/python3.7/site-packages/GPy/kern/src/stationary.py:168: RuntimeWarning:overflow encountered in true_divide\n",
-      " /Users/aldoglielmo/miniconda3/envs/py37bbc/lib/python3.7/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:overflow encountered in multiply\n",
-      " /Users/aldoglielmo/miniconda3/envs/py37bbc/lib/python3.7/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:overflow encountered in square\n",
-      " /Users/aldoglielmo/miniconda3/envs/py37bbc/lib/python3.7/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:invalid value encountered in multiply\n"
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:168: RuntimeWarning:overflow encountered in true_divide\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:overflow encountered in multiply\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:overflow encountered in square\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:581: RuntimeWarning:invalid value encountered in multiply\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:584: RuntimeWarning:overflow encountered in multiply\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:584: RuntimeWarning:invalid value encountered in subtract\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:584: RuntimeWarning:overflow encountered in square\n",
+      " /Users/aldoglielmo/Library/Caches/pypoetry/virtualenvs/black-it-3F5nO-b3-py3.8/lib/python3.8/site-packages/GPy/kern/src/stationary.py:584: RuntimeWarning:invalid value encountered in multiply\n"
      ]
     },
     {
      "name": "stdout",
      "output_type": "stream",
      "text": [
-      "Warning: Repeated samples still found after 5 duplication passes. This is probably due to a small search space.\n",
-      "Warning: Repeated samples still found after 5 duplication passes. This is probably due to a small search space.\n",
-      "(6174,)\n"
+      "Warning: Repeated samples still found after 5 duplication passes. This is probably due to a small search space.\n"
+     ]
+    }
+   ],
+   "source": [
+    "sampler = GaussianProcessSampler(batch_size=8, random_state=0, acquisition=\"mean\")\n",
+    "new_params_mean_acquisition = sampler.sample(param_grid, xys, losses)\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 15,
+   "id": "9844bf84",
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Warning: Repeated samples still found after 5 duplication passes. This is probably due to a small search space.\n"
      ]
     }
    ],
    "source": [
-    "sampler = GaussianProcessSampler(batch_size=8, internal_seed=0, acquisition=\"mean\")\n",
-    "new_params_mean_acquisition = sampler.sample(param_grid, xys, losses)\n",
-    "\n",
     "sampler = GaussianProcessSampler(\n",
-    "    batch_size=8, internal_seed=0, acquisition=\"expected_improvement\"\n",
+    "    batch_size=8, random_state=0, acquisition=\"expected_improvement\"\n",
     ")\n",
     "new_params_EI_acquisition = sampler.sample(param_grid, xys, losses)"
    ]
@@ -464,7 +488,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2e50ca250>"
+       "<matplotlib.legend.Legend at 0x7fe9bdb31310>"
       ]
      },
      "execution_count": 16,
@@ -473,7 +497,7 @@
     },
     {
      "data": {
-      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAE9CAYAAABtDit8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAo+ElEQVR4nO3deXRU9f3/8eebQAA3qID+HJYGPYhLFsSwKLIoWlGxilKUYlv0a61a2p72p63dKMWf51hta8WNr1pFbb8qVqW4INZda1WCQlgsfkGNxGkFRqEKwQR4//6YZExCkjshczOTy+txzpzkLnPv551JXrnr55q7IyIizeuU7QaIiOQ6BaWISAAFpYhIAAWliEgABaWISAAFpYhIgM7ZbkBr9e7d2wsKCrLdDBGJmKVLl25y9z5NTetwQVlQUEBZWVm2myEiEWNmFc1N0663iEgABaWISAAFpYhIAAWliEgABaWISAAFpYhIAAWliEiA0K6jNLO7gInABncvbGK6ATcCpwPbgOnu/mYm25BIJIjH41RXV5Ofn08sFqNXr16ZXEW7iUotUakDVEuuCqOWMLco5wETWph+GjCo9nUJcFsmV55IJKioqKC6uhqA6upqKioqSCQSmVxNu4hKLVGpA1RLrgqrltCC0t1fAj5uYZazgHs96TWgp5kdkqn1x+NxGvfe7u7E4/FMraLdRKWWqNQBqiVXhVVLNo9R9gXW1xuurB23GzO7xMzKzKxs48aNaS287j9KuuNzWVRqiUodoFpyVVi1ZDMorYlxTT7Ax91vd/dSdy/t06fJe9Z3k5+f36rxuSwqtUSlDlAtuSqsWrIZlJVA/3rD/YCMbevHYjGS54u+YGbEYrFMraLd1K/lS5XPUPjM+Qx9bDxHPT0FyudnuXXpi+pnUke1ZF9YtWSz96CFwAwzewAYAWxx939lauF1Z7micCavrs1bX5tH3/LfkbfzcwDyPo3DY99PzlQ8JVvNS1sUPxPVklvCqsXCelytmd0PjAN6Ax8BvwK6ALj73NrLg24meWZ8G3Chuwf2n1ZaWup7bTdrNxTClvW7j+/RH364sv3bIxIhZrbU3UubmhbaFqW7Tw2Y7sB3w1p/JG2pbN14EckI3ZnTkfTo17rxIpIRCsqOZPxM6NK94bgu3ZPjRSQ0CsqOpHgKnDkneUwSS349c06HOJEj0pF1uGfm7PWKpygYRdqZtihFRAIoKEVEAigoJdrK5yevP53VM/m1A93JJLlDxyglusrnJ+9cqqlKDm9Z36HuZJLcoS1Kia5nZ38RknVqqpLjRVpBQSnRpTuZJEMUlBJdupNJMkRBKdGlO5kkQxSUEl26k0kyRGe9Jdp0J5NkgLYoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAIoKEVEAigoRUQCKChFRAKEGpRmNsHM1pjZWjO7qonpPczsMTNbbmarzOzCMNsjIrInOoe1YDPLA24BTgEqgSVmttDdV9eb7bvAanc/08z6AGvM7M/uXp2JNiQSCeLxONXV1eTn5xOLxejVq1cmFt3uolJLVOoA1ZKrwqgltKAEhgNr3f1dADN7ADgLqB+UDuxvZgbsB3wM7MjEyhOJBBUVFbg7ANXV1VRUVAB0uF+AqNQSlTpAteSqsGoJc9e7L7C+3nBl7bj6bgaOBOLACuAH7r4rEyuPx+OpH1Yddycej2di8e0qKrVEpQ5QLbkqrFrCDEprYpw3Gj4VWAbEgCHAzWZ2wG4LMrvEzMrMrGzjxo1prby6uum99+bG57Ko1BKVOkC15KqwagkzKCuB/vWG+5HccqzvQuART1oLvAcc0XhB7n67u5e6e2mfPn3SWnl+fn6rxueyqNQSlTpAteSqsGoJMyiXAIPMbKCZ5QPnAwsbzfMBMB7AzA4GBgPvZmLlsViM5KHPL5gZsVgsE4tvV1GpJSp1gGrJVWHVEtrJHHffYWYzgMVAHnCXu68ys0trp88FrgbmmdkKkrvqP3H3TZlYf92B2yicyYtKLVGpA1RLrgqrFmt84DPXlZaWellZWbabISIRY2ZL3b20qWm6M0dEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglKkoyifDzcUwqyeya/l87Pdor1G52w3QETSUD4fHvs+1FQlh7esTw4DFE/JXrv2EtqiFOkInp39RUjWqalKjpfQKShFOoItla0bLxkValCa2QQzW2Nma83sqmbmGWdmy8xslZm9GGZ7RDqsHv1aN14yKrRjlGaWB9wCnAJUAkvMbKG7r643T0/gVmCCu39gZgdlsg2JRIJ4PE51dTX5+fnEYjF69eqVyVW0m6jUEpU6oJ1rGT+z4TFKgC7dk+MzQJ9Ly8I8mTMcWOvu7wKY2QPAWcDqevN8HXjE3T8AcPcNmVp5IpGgoqICdwegurqaiooKgA73CxCVWqJSB2ShlroTNs/OTu5u9+iXDMkMnMjR5xIszKDsC6yvN1wJjGg0z+FAFzN7AdgfuNHd783EyuPxeOqHVcfdicfjHe7Dj0otUakDslRL8ZRQznDrcwkWZlBaE+O80XBn4FhgPNAd+IeZvebu7zRYkNklwCUAAwYMSGvl1dXVrRqfy6JSS1TqANWSq8KqJcygrAT61xvuB8SbmGeTu28FtprZS0AJ0CAo3f124HaA0tLSxmFLTU0NlZWVbN++PTWuc+fmS3v77bdbVUi2RaWW9qqjW7du9OvXjy5dumRsmY3l5+c3+ceXn58f2jrDolqChRmUS4BBZjYQ+BA4n+Qxyfr+CtxsZp2BfJK75je0dkWVlZXsv//+FBQUYJbckN2xYweff/75bvN27dq1xT/YXBSVWtqjDncnkUhQWVnJwIEDM7LMpsRisQbHwgDMjFgsFto6w6JagoX2V+buO8xsBrAYyAPucvdVZnZp7fS57v62mT0FlAO7gDvdfWVr17V9+/YGIQlfbL1UV1fj7pgZ+fn5HSpY6kSllvaow8zo1asXGzduzNgym1J3vCsKZ4pVS7BQ/9Lc/UngyUbj5jYavh64vq3rqh+SdTp37tzhwqQ5UamlPepo6nchDL169eqQYdIU1dKyZi84N7MiM3vNzNab2e1m9qV6097IaCukWaeffjqbN2/O2PLmzZvHjBkzMra8THrhhReYOHFiq94zbtw4ysrKQmqRSFJLd+bcBswCikieXHnFzA6rnRbeUfII27lzZ6vf8+STT9KzZ8/MN0ZE0tZSUO7n7k+5+2Z3/y0wA3jKzEay+2U+HUoikWDFihUsXbqUFStWkEgk2rS8999/nyOOOIJvfetbFBcXM3nyZLZt2wZAQUEBs2fP5oQTTuChhx7i6aef5rjjjmPo0KF87Wtf47PPPmPRokVMmfLF9XEvvPACZ555Zur9mzZtAuD3v/89hYWFFBYW8oc//CG17sLCwtR7f/vb3zJr1iwA5syZw1FHHUVxcTHnn39+gzZ/+umnDBw4kJqaGgD+85//UFBQkBqu89BDD1FYWEhJSQljxoxJrXP06NEMHTqUoUOH8uqrr6baPXbsWKZMmcLhhx/OVVddxZ///GeGDx9OUVER69atA2D69OlceumljB49msMPP5zHH398t5/p1q1bueiiixg2bBjHHHMMf/3rXwGoqqri/PPPp7i4mPPOO4+qqqrd3iuSaS0dLDIz6+HuWwDc/XkzOxd4GDiwXVoXgrCu3F+zZg1//OMfGTVqFBdddBG33norV1xxBZC8XOWVV15h06ZNnHPOOTzzzDPsu+++/OY3v+H3v/89P/vZz/jOd77D1q1b2XfffXnwwQc577zzGix/6dKl3H333bz++uu4OyNGjGDs2LF86Utfaqo5AFx77bW89957dO3adbfd9/33359x48bxxBNPcPbZZ/PAAw9w7rnn7nZJzezZs1m8eDF9+/ZNLeOggw7ib3/7G926deN///d/mTp1amr3d/ny5bz99tsceOCBHHrooVx88cW88cYb3Hjjjdx0000NAv7FF19k3bp1nHjiiaxdu7bBeq+55hpOOukk7rrrLjZv3szw4cM5+eST+e///m/22WcfysvLKS8vZ+jQoa39qERaraUtyt8AR9Yf4e7lJC8OfyTMRoWppSv326J///6MGjUKgAsuuIBXXnklNa0u9F577TVWr17NqFGjGDJkCPfccw8VFRV07tyZCRMm8Nhjj7Fjxw6eeOIJzjrrrAbLf+WVV5g0aRL77rsv++23H+eccw4vv/xyi20qLi5m2rRp/OlPf2ryBMrFF1/M3XffDcDdd9/NhRdeuNs8o0aNYvr06dxxxx2pQwc1NTV8+9vfpqioiK997WusXv3FXanDhg3jkEMOoWvXrhx22GF85StfAaCoqIj3338/Nd+UKVPo1KkTgwYN4tBDD+Wf//xng/U+/fTTXHvttQwZMoRx48axfft2PvjgA1566SUuuOCCVH3FxcUt/gxEMqHZLUp3/59mxn8AfDu0FoUsrCv3G59prT+87777AslAPuWUU7j//vt3e/95553HLbfcwoEHHsiwYcPYf//9G0xvHO51OnfuzK5du1LD9S+6f+KJJ3jppZdYuHAhV199NatWrWrw3lGjRqW27Hbu3NlgF77O3Llzef3113niiScYMmQIy5Yt46abbuLggw9m+fLl7Nq1i27duqXm79q1a+r7Tp06pYY7derEjh07mvz5NDXs7jz88MMMHjx4tza1+ax2+fxQ7pmW6Nrr+qNs7gr9tl65/8EHH/CPf/wDgPvvv58TTjhht3lGjhzJ3//+99Ru5rZt23jnneRNSOPGjePNN9/kjjvu2G23G2DMmDEsWLCAbdu2sXXrVh599FFGjx7NwQcfzIYNG0gkEnz++eep4327du1i/fr1nHjiiVx33XVs3ryZzz77bLflfvOb32Tq1KlNbk0CrFu3jhEjRjB79mx69+7N+vXr2bJlC4cccgidOnXivvvu26OTVA899BC7du1i3bp1vPvuu7sF4qmnnspNN92U+gfx1ltvpX4Of/7znwFYuXIl5eXlrVtxXU/hW9YD/kVP4XqsgrRgrwvKWCzW5NZMW6/cP/LII7nnnnsoLi7m448/5rLLLtttnj59+jBv3jymTp1KcXExI0eOTO1y5uXlMXHiRBYtWtTkJTJDhw5l+vTpDB8+nBEjRnDxxRdzzDHH0KVLF2bOnMmIESOYOHEiRxxxBJA8w37BBRdQVFTEMcccww9/+MMmz55PmzaNTz75hKlTpzZZ15VXXklRURGFhYWMGTOGkpISLr/8cu655x5GjhzJO++8k9pibo3BgwczduxYTjvtNObOndtgqxTgl7/8JTU1NRQXF1NYWMgvf/lLAC677DI+++wziouLue666xg+fHjrVqyewmUPWHO7dLmqtLTUG1839/bbb3PkkUc2847dZbq/uvfff5+JEyeycmWrbyrKur/85S/89a9/5b777mu3dU6fPp2JEycyefLk0NbR7O/ErJ40fdGGwazNobVHcp+ZLXX30qam7dEtEmY20d13v6ajg4jSXQht8b3vfY9Fixbx5JNPBs8cFT361e52NzFepBl7ei/ZMKDDBmWmFRQUdMityZtuuikr6503b15W1guE3lO4RNMeHaN0919luiEi7aJ4Cpw5B3r0Byz59cw5OustLQrcoqx99s0ZQEH9+d399+E1SyREIfUULtGVzq73Y8B2YAXJrtBERPYq6QRlP3fX7Q8istdK5xjlIjP7SugtkZxWd+3nDTe0ugN6kQ4vnS3K14BHzawTUEPyoWHu7geE2jLJGf/+97959dVXU52HiOxt0tmi/B1wHLCPux/g7vt39JBc8NaHjLr2OQZe9QSjrn2OBW992Kbl1XWzdvHFF1NYWMi0adN45plnGDVqFIMGDeKNN5L9HDfXdVhL3ZaNGzeOyZMnc8QRRzBt2rQm7/m+4447GDZsGCUlJZx77rmpLt4++ugjJk2aRElJCSUlJanlXnPNNQwePJiTTz6ZqVOn8tvf/rbF+r7yla+wYcMGhgwZwssvv9ygs9xNmzZRUFAAJC/7Oeecc5gwYQKDBg3ixz/+cWoZTz31FEOHDqWkpITx48e34actkgXu3uKL5DNvOgXN116vY4891htbvXr1buOa8+iblX7ELxb5l3/yeOp1xC8W+aNvVqa9jMbee+89z8vL8/Lyct+5c6cPHTrUL7zwQt+1a5cvWLDAzzrrLHd3/+lPf+r33Xefu7t/8sknPmjQIP/ss89869atXlVV5e7u77zzjtfV+Pzzz/sBBxzg69ev9507d/rIkSP95Zdf3m39mzZtSn3/85//3OfMmePu7lOmTPEbbrjB3d137Njhmzdv9rKyMi8sLPStW7f6li1b/LDDDvPrr78+sL6jjz46NTx27FhfsmSJu7tv3LjRv/zlL7u7+9133+0DBw70zZs3e1VVlQ8YMMA/+OAD37Bhg/fr18/fffddd3dPJBKt+fHukdb8Toi4uwNl3kzupLPr/S/gBTNbBKQeoecd9PKg6xevoaqmYScOVTU7uX7xGs4+pu8eL3fgwIEUFRUBcPTRRzN+/HjMrEH3Yk8//TQLFy5MbcHVdR0Wi8WYMWMGy5YtIy8vL9VRBsDw4cPp1y9518iQIUN4//33d+twY+XKlfziF79IdXxx6qmnAvDcc89x7733Asl7yXv06MHLL7/MpEmT2GeffQD46le/usc1N2X8+PH06NEDgKOOOoqKigo++eQTxowZk3oq4oEHdtjuTGUvlU5Qvlf7yq99dWjxzU33iN3c+HSl072YN9N12KxZs9LqtiwvL69BV2V1pk+fzoIFCygpKWHevHm88MILLba1rd2U1e/arX63bs2112ufuCjSUQUeo3T3Xzf1ao/GhSHWs3urxmdSc12HtbXbsk8//ZRDDjmEmpqaVBdkkNy6u+2224Bkb0L/+c9/GDNmDI8++ihVVVV8+umnPPbYY62uo6CggKVLlwLJTjWCHHfccbz44ou89957AHz88cetXqdINgUGpZn1MbPrzexJM3uu7tUejQvDlacOpnuXvAbjunfJ48pTd+8gNtOa6zqsrd2WXX311YwYMYJTTjkl1c0awI033sjzzz9PUVERxx57LKtWrWLo0KGcd955DBkyhHPPPZfRo0en5p87dy5z585tahUNXHHFFdx2220cf/zxqef5tKRPnz7cfvvtnHPOOZSUlKT62ywrK+Piiy9uVa0i2RDYzZqZPQ08CFwBXAp8C9jo7j8Jv3m7y0Q3awve+pDrF68hvrmKWM/uXHnq4DYdn+zIZs2axX777Zd6vk9UtPZ3QqSt3az1cvc/mtkP3P1F4EUzezGzTWxfZx/Td68NRhFpvXSCsu75pf8yszOAOKDO+yKi7tG2ItK8dILy/5lZD+D/AjcBBwA/DLVVIiI5pMWgrO1ibZAnezPfApzYLq0SEckhLZ71dvedQGavSBYR6WDS2fV+1cxuJnnme2vdSHd/M7RWiYjkkHQ6xTgeOBqYTbKDjN8BLfeisBfKy8tjyJAhqde1114L0KADifb0+eefc/LJJzNkyBAefPDBdl+/SJQEblG6u45LpqF79+4sW7Ys281Ieeutt6ipqcmpNol0VGk9XMzMzjCzH5vZzLpX2A0LVfl8uKEw+YznGwqTw+1s9uzZDBs2jMLCQi655JLUbY1r167l5JNPpqSkhKFDh7Ju3TrcnRkzZnDUUUdxxhlncPrpp7d46+CGDRu44IILWLZsGUOGDGHdunUUFBSk7qIpKytj3LhxQPLyoIsuuohx48Zx6KGHMmfOnNRy7r33XoqLiykpKeEb3/hGeD8MkRyXzi2Mc4HzgO+R7LT3a8CXQ25XeMrnJx9XumU94Mmvj32/zWFZVVXVYNc7aHd3xowZLFmyhJUrV1JVVcXjjyef/jtt2jS++93vsnz5cl599VUOOeQQHn30UdasWcOKFSu44447Uv1KNueggw7izjvvZPTo0SxbtozDDjusxfn/+c9/snjxYt544w1+/etfU1NTw6pVq7jmmmt47rnnWL58OTfeeGPrfiAiEZLOyZzj3b3YzMrd/ddm9jvgkbAbFppnZzd8pjMkh5+d3aYn87V21/v555/nuuuuY9u2bXz88cccffTRjBs3jg8//JBJkyYBpHoReumll5g6dSp5eXnEYjFOOumkPW5nU8444wy6du1K165dOeigg/joo4947rnnmDx5Mr179wbUNZrs3dIJyrpU2WZmMSABDAyvSSHbUtm68SHYvn07l19+OWVlZfTv359Zs2axffv2Jnsvr6Ou0USyJ51jlI+bWU/geuBN4H3g/hDbFK4ezdx92dz4ENQFVe/evfnss89SxxsPOOAA+vXrx4IFC4Dkmett27YxZswYHnjgAXbu3Mm//vUvnn/++Vavs37XaA8//HDg/OPHj2f+/PkkEglAXaPJ3i2d/iivdvfN7v4wyWOTR7h7xz2ZM34mdGnU92SX7snxbdD4GOVVV13V7Lw9e/bk29/+NkVFRZx99tkMGzYsNe2+++5jzpw5FBcXc/zxx/Pvf/+bSZMmMWjQIIqKirjssssYO3Zsav6ZM2eycOHCwPb96le/4gc/+AGjR48mLy8vcP6jjz6an//854wdO5aSkhJ+9KMfAbBw4UJmzuy4H7/Inkinm7VuwOXACYADrwC3ufv2Ft8Ykkx0s0b5/OQxyS2VyS3J8TPbdHyyvU2fPp2JEycyefLkbDclZ6mbNWmttnazdi/wKckOMQCmAveRPPvdMRVP6VDBKCLZlU5QDnb3knrDz5vZ8rAaJMHmzZuX7SaI7FXSOZnzlpmNrBswsxHA39NZuJlNMLM1ZrbWzJo9aGdmw8xsp5lpX1JEck46W5QjgG+a2Qe1wwOAt81sBeDuXtzUm2q7aLsFOAWoBJaY2UJ3X93EfL8h+fzwPdbU5Sw7duyguro6NS0/P5/OndMpOfdEpZb2qCPouHumJBIJ4vE41dXV5OfnE4vF6NWrV7usO9NUS8vS+Q2dsIfLHg6sdfd3AczsAeAsYHWj+b4HPAwMYw9169aNRCJBr169UmG5Y8cOPv889Rhy3D013NECJiq1tEcd7k4ikWjwyN8wJBIJKioqUqFcXV1NRUUFQIcLGNUSLJ1OMSr2cNl9gfX1hitJbp2mmFlfYBJwEm0Iyn79+lFZWcnGjRtT46qrq5udPz+/Yz2ePCq1tFcd3bp1o1+/cK+Ljcfju225ujvxeLzDhYtqCRbm5khTt3U03if6A/ATd9/Z0l0gZnYJcAnAgAEDdpvepUsXBg5seLNQ3cXVTSkpKWl2Wi6KSi1RqQOaD/2W/hnkKtUSLK3eg/ZQJdC/3nA/kg8mq68UeMDM3gcmA7ea2dmNF+Tut7t7qbuX9unTJ62VN7eF0pG2wOpEpZao1AGqJVeFVUuYQbkEGGRmA80sHzgfaHALibsPdPcCdy8A/gJc7u4LMrHyWCy228kdMyMWi2Vi8e0qKrVEpQ5QLbkqrFpC2/V29x1mNoPk2ew84C53X2Vml9ZOnxvWuuGLA7dROJMXlVqiUgeollwVVi2BtzDmmqZuYRQRaauWbmEMc9dbRCQSFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJQiIgEUlCIiARSUIiIBFJS5onw+3FAIs3omv5bPz3aLRKRW52w3QEiG4mPfh5qq5PCW9clhgOIp2WuXiADaoswNz87+IiTr1FQlx4tI1ikoc8GWytaNF5F2paDMBT36tW68iLQrBWUuGD8TunRvOK5L9+R4Ecm6UIPSzCaY2RozW2tmVzUxfZqZlde+XjWzkjDbk7OKp8CZc6BHf8CSX8+coxM5IjkitLPeZpYH3AKcAlQCS8xsobuvrjfbe8BYd//EzE4DbgdGZKoNiUSCeDxOdXU1+fn5xGIxevXqlanFZ1bxlBaDsUPV0oKo1AGqJVeFUUuYlwcNB9a6+7sAZvYAcBaQCkp3f7Xe/K8BGTsol0gkqKiowN0BqK6upqKiAqDD/QJEpZao1AGqJVeFVUuYu959gfX1hitrxzXnv4BFmVp5PB5P/bDquDvxeDxTq2g3UaklKnWAaslVYdUS5halNTHOmxiHmZ1IMihPaGb6JcAlAAMGDEhr5dXV1a0an8uiUktU6gDVkqvCqiXMLcpKoH+94X7AbrFuZsXAncBZ7p5oakHufru7l7p7aZ8+fdJaeX5+fqvG57Ko1BKVOkC15KqwagkzKJcAg8xsoJnlA+cDC+vPYGYDgEeAb7j7O5lceSwWw6zhRq2ZEYvFMrmadhGVWqJSB6iWXBVWLaHterv7DjObASwG8oC73H2VmV1aO30uMBPoBdxaW9wOdy/NxPrrDtxG4UxeVGqJSh2gWnJVWLVY4wOfua60tNTLysqy3QwRiRgzW9rchpruzBERCaCgFBEJoKAUEQmgoBQRCaCgFNkb6FEjbaJHQYhEnR410mbaohSJOj1qpM0UlCJRp0eNtJmCUiTq9KiRNlNQikSdHjXSZgpKkajTo0baTGe9RfYGAY8akZZpi1JEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkgIJSRDqW8vlwQyHM6pn8Wj4/9FXqKYwi0nGUz4fHvg81VcnhLeuTwxDqUyb3iqBc8NaHXL94DfHNVcR6dufKUwdz9jF9s90sEWmtZ2d/EZJ1aqqS4xWUe27BWx/y00dWUFWzE4APN1fx00dWACgsRTqaLZWtG58hkT9Gef3iNamQrFNVs5PrF6/JUotEZI/16Ne68RkS+aCMb65qcvyHm6sYde1zLHjrw3ZukYjssfEzoUv3huO6dE+OD1Hkg7LnPl2anVa3G66wFOkgiqfAmXOgR3/Akl/PnBPq8UmI+DHKBW99yOZtNS3OU1Wzk/87fzmgY5YiHULxlNCDsbHIblHWncTxNObd6a4tSxFpVqhblGY2AbgRyAPudPdrG0232umnA9uA6e7+ZibW3dRJnJbUneDJ1a3KRCJBPB6nurqa/Px8YrEYvXr1ynazWi1jdZTPT14SsqUyeSB//Mx238qIymcCqiVIaEFpZnnALcApQCWwxMwWuvvqerOdBgyqfY0Abqv92mbNncRpyYd78J72kEgkqKiowD25fVxdXU1FRQVAh/plzlgdWbrouL6ofCagWtIR5q73cGCtu7/r7tXAA8BZjeY5C7jXk14DeprZIZlYee998lr9njyzTKw64+LxeOqDr+PuxOPxLLVoz2SsjpYuOm4nUflMQLWkI8yg7AusrzdcWTuutfNgZpeYWZmZlW3cuDGtlX+9cF+6tjIrd3o6RzTbX3V1davG56qM1ZGli47ri8pnAqolHWEGZVObZ42TKJ15cPfb3b3U3Uv79OmT1spPHtSTS489gE6t2Ejs27N78ExZkJ+f36rxuSpjdWTpouP6ovKZgGpJR5hBWQn0rzfcD2i8/ZvOPHskFosxtmBfvjfsgN22LLt0MrrkNUzQ7l3yuPLUwZlYdcbFYjGs0WEBMyMWi2WpRXsmY3Vk6aLj+qLymYBqSUeYZ72XAIPMbCDwIXA+8PVG8ywEZpjZAyRP4mxx939lYuV1B25P7pLM3f9ZuZVN23amOsUAOkxHGXW1dPSzkhmro+6ETRbPekflMwHVkg5rfOAzk8zsdOAPJC8PusvdrzGzSwHcfW7t5UE3AxNIXh50obuXtbTM0tJSLytrcRYRkVYzs6XuXtrUtFCvo3T3J4EnG42bW+97B74bZhtERNoqsnfmiIhkioJSRCSAglJEJICCUkQkgIJSRCSAglJEJICCUkQkQKgXnIfBzDYCFa18W29gUwjNyYao1BKVOkC15KrW1vJld2+yM4kOF5R7wszKmrvivqOJSi1RqQNUS67KZC3a9RYRCaCgFBEJsLcE5e3ZbkAGRaWWqNQBqiVXZayWveIYpYhIW+wtW5QiInssUkFpZhPMbI2ZrTWzq5qYbmY2p3Z6uZkNzUY7g6RRx7Ta9peb2atmVpKNdqYjqJZ68w0zs51mNrk929ca6dRiZuPMbJmZrTKzF9u7jelI4/erh5k9ZmbLa+u4MBvtTIeZ3WVmG8xsZTPTM/M37+6ReJHsHHgdcCiQDywHjmo0z+nAIpLP6hkJvJ7tdu9hHccDX6r9/rRcrCPdWurN9xzJvksnZ7vdbfhcegKrgQG1wwdlu917WMfPgN/Uft8H+BjIz3bbm6lnDDAUWNnM9Iz8zUdpizKrj8fNoMA63P1Vd/+kdvA1ks8aykXpfCYA3wMeBja0Z+NaKZ1avg484u4fALh7LtaTTh0O7F/7BIL9SAbljvZtZnrc/SWS7WtORv7moxSUGXs8bpa1to3/RfI/Zi4KrMXM+gKTgLnktnQ+l8OBL5nZC2a21My+2W6tS186ddwMHEnyQX8rgB+4+672aV7GZeRvPtRHQbSzjD0eN8vSbqOZnUgyKE8ItUV7Lp1a/gD8xN13Nn56Xo5Jp5bOwLHAeKA78A8ze83d3wm7ca2QTh2nAsuAk4DDgL+Z2cvu/p+Q2xaGjPzNRykos/p43AxKq41mVgzcCZzm7ol2altrpVNLKfBAbUj2Bk43sx3uvqBdWpi+dH+/Nrn7VmCrmb0ElAC5FJTp1HEhcK0nD/KtNbP3gCOAN9qniRmVmb/5bB+MzeBB3c7Au8BAvjhIfXSjec6g4YHdN7Ld7j2sYwCwFjg+2+1tay2N5p9H7p7MSedzORJ4tnbefYCVQGG2274HddwGzKr9/mCSj5vune22t1BTAc2fzMnI33xktijdfYeZzQAW88XjcVfVfzwuybOqp5MMmW0k/3PmlDTrmAn0Am6t3RLb4TnYkUGatXQI6dTi7m+b2VNAObALuNPdm7xsJVvS/EyuBuaZ2QqSAfMTd8/JHoXM7H5gHNDbzCqBXwFdILN/87ozR0QkQJTOeouIhEJBKSISQEEpIhJAQSkiEkBBKSISQEEp0gIzO8LM/mFmn5vZFdluj2RHZK6jlL2XmXV297A6bfgY+D5wdkjLlw5AQSlZZ2YFwFPA68AxJG/5+6a7bzOzmcCZJO+dfhX4jru7mb1QOzwKWGhm7wC/IHm3SQKY5u4fmdksknehHEKy04ofkbxD4zSSd5yc6e41zbXNkz0AbTCzMzJdt3Qc2vWWXDEYuN3di4H/AJfXjr/Z3Ye5eyHJsJxY7z093X2su/8OeAUY6e7HkOw67Mf15juM5K1sZwF/Ap539yKgqna8SIsUlJIr1rv732u//xNf9Ih0opm9Xns73UnA0fXe82C97/sBi2vnu7LRfItqtxpXkLxt76na8StI3ics0iIFpeSKxvfSupl1A24l2VFGEXAH0K3ePFvrfX8Tya3PIuA7jeb7HMCTfSrW+Bf37e5Ch58kDQpKyRUDzOy42u+nktyVrgu7TWa2H9DS83R6kDzmCPCtcJooeysFpeSKt4FvmVk5cCBwm7tvJrkVuQJYACxp4f2zgIfM7GWg1T3dmNlsM/tqE+P/T22vND8CfmFmlWZ2QGuXLx2beg+SrKs96/147QkbkZyjLUoRkQDaohQRCaAtShGRAApKEZEACkoRkQAKShGRAApKEZEACkoRkQD/H5RBpPA9VC4uAAAAAElFTkSuQmCC\n",
+      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAUoAAAE9CAYAAABtDit8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8qNh9FAAAACXBIWXMAAAsTAAALEwEAmpwYAAArh0lEQVR4nO3dfXgU5b3/8feXwAJahBof6hoI6A8VCAnECFqqoGh9KBXxAaFaD1rrqS21V3u0tUdLKa3XD2uPHrFWqq2PrVVsK8VHPK3409qqBB+IUvWAEglpK66QCkQT4Pv7YzdrEpLMbtjJPuTzuq5cydw7O/O9szPfueee2XvM3RERkc71yXYAIiK5TolSRCSAEqWISAAlShGRAEqUIiIBlChFRAL0zXYA6dpvv/18+PDh2Q5DRArMqlWr3nP3/Tt6Le8S5fDhw6murs52GCJSYMystrPXdOotIhJAiVJEJIASpYhIgLzro5Rgzc3N1NXV8eGHH2Y7FMkBAwYMoKSkhH79+mU7lLylRFmA6urqGDRoEMOHD8fMsh2OZJG7E4vFqKurY8SIEdkOJ2/p1LsAffjhhxQXFytJCmZGcXGxzi72kBJlgVKSlBbaFvacEqXkldNOO40tW7ZkbHl33nknc+fOzdjyMumpp55i2rRpab1nypQp3brPOBaLUVNTw6pVq6ipqSEWi6W9jEKmPkrJmp07d1JUVJTWex599NGQoum9YrEYtbW1tAzi3dTURG1t/N7r4uLibIaWM0JrUZrZ7Wb2rpm92snrZmaLzGytma02s8qwYpGuZbo1sX79eo444gjOO+88Ro0axdlnn8327duB+DervvOd71BZWckDDzzAE088wTHHHENlZSXnnHMOW7du5fHHH+ecc85JLq91y2r48OG89957AFx//fWUlZVRVlbGf//3fyfXXVZWlnzvT37yE+bPnw/AokWLGD16NOXl5cyaNatNzB988AEjRoygubkZgH/9619tpls88MADlJWVUVFRwXHHHZdc57HHHktlZSWVlZX85S9/ScY9efJkpk+fziGHHMKVV17Jr3/9ayZMmMDYsWNZt24dAHPmzOErX/kKVVVVHHbYYTz88MO7/U+3bdvGRRddxIQJExg/fjx/+MMfAGhsbGTWrFmMGjWKGTNm0NjYmOanBfX19bR/0oG7U19fn/ayClWYLco7gZ8Cd3fy+qnAyMTPROCWxO9eKxaLUV9fT1NTE5FIhGg0GvoRPazWxBtvvMEvf/lLJk2axEUXXcTPfvYzLr/88uRyX3zxRd577z3OPPNM/vjHP7L33ntz7bXXcv311/Of//mfXHLJJWzbto29996b+++/f7fEtmrVKu644w6ef/553J2JEycyefJkPvnJT3Ya08KFC3n77bfp37//bqfvgwYNYsqUKTzyyCOcccYZ3HfffZx55pm73VKzYMECli9fzsEHH5xcxgEHHMD//M//MGDAAP73f/+X2bNnU11dzc6dO3nllVdYtWoV++67L2VlZVx88cW88MIL3Hjjjdx0001tEvwLL7zAunXrOP7441m7dm2b9V5zzTWccMIJ3H777WzZsoUJEyZw4okn8vOf/5y99tqLv/3tb6xevZrKyvTbG01NTWmV55Ke2mdCa1G6+9PA+13MMh242+OeA4aY2UFhxdMiV/tiWhJWy8bZkrDCji+s1sTQoUOZNGkSAOeffz5//vOfk6+de+65ADz33HOsWbOGSZMmMW7cOO666y5qa2vp27cvp5xyCg899BA7duzgkUceYfr06W2W/+c//5kZM2aw995784lPfIIzzzyTZ555psuYysvLOe+88/jVr35F3767txEuvvhi7rjjDgDuuOMOLrzwwt3mmTRpEnPmzOG2225j586dQPy+1S9/+cuMHTuWc845hzVr1rBjxw6ampqorKzkU5/6FJFIhOHDh3PCCScAMHbsWNavX59c7syZM+nTpw8jR47kkEMO4fXXX2+z3ieeeIKFCxcybtw4pkyZwocffsg777zD008/zfnnn5+sX3l5eZf/g45EIpG0ynNFT+4z2eyjPBjY0Gq6LlH297BWmMt9MV0lrDBjC6s10f5Ka+vpvffeG4jX76STTuI3v/nNbu+fNWsWP/3pT9l3332pqqpi0KBBKa23b9++7Nq1Kznd+raYRx55hKeffpqHHnqIa665hpqamjbvnTRpEuvXr+epp55i586dbU7hWyxevJjnn3+eRx55hCOPPJJVq1Zx0003ceCBB/LKK6+wa9cuBgwYkPz/9e/fP/nePn36JPtk+/Tpw44dOzr8/3Q07e787ne/4/DDD0/p/5COaDTaZr9oWX80Gs34ujKpJ/eZvLjqbWaXmFm1mVVv2rSp28vJ5b6YbJ3+hNWaeOedd/jrX/8KwL333stnPvOZ3eY5+uijefbZZ5Onmdu2bePNN98EYPLkybz44ovcdtttu512Axx77LEsXbqU7du3s23bNh588EGOPfZYDjzwQN59911isRgfffRRsr9v165dbNiwgeOPP55rr72WhoYGtm7duttyL7jgAr7whS902JoEWLduHRMnTmTBggXsv//+bNiwgYaGBg466CD69OnDPffcw86dO3fbzlp0Vv7AAw+wa9cu1q1bx1tvvbVbQjz55JO56aabku9/6aWXADjuuOO49957AXj11VdZvXp1h8vvSnFxMaWlpcnPPBKJUFpamvXGQ5Ce3GeymSg3AkNbTZckynbj7re6e5W7V+2/f4fDxaUkl/tisnX6E41GO2zN7Glr4vDDD+fmm29m1KhRbN68mUsvvTT52o4dO9i+fTt77bUXixcvZtasWZSXl3PMMcckTzmLioqYNm0ajz32WIe3yFRWVjJnzhwmTJjAxIkTufjiixk/fjz9+vVj3rx5TJgwgZNOOokjjjgCiF9hP//88xk7dizjx4/nsssuY8iQIbst97zzzmPz5s3Mnj27w3pdccUVjB07lrKyMj796U9TUVHBV7/6Ve666y4qKip4/fXX2XvvvTu9d7Gz8mHDhjFhwgROPfVUFi9ezIABA9q8/r3vfY/m5mbKy8sZM2YM3/ve9wC49NJL2bp1K6NGjWLevHkceeSRHS4/SHFxMWPHjuXII49k7NixOZ8koWf3GQvzud5mNhx42N13O4cxs88Bc4HTiF/EWeTuE4KWWVVV5d0dj7KmpqbDpBiJRBg7dmy3ltnG6iXwpwXQUAeDS2DqPCifmdJb23cLQHyn6s6R/W9/+xujRo1Kef5Md4ivX7+eadOm8eqru9/wsGPHDj766KPdyvv3799hv2FP++1vf8sf/vAH7rnnnj1aTjr1nDNnDtOmTePss8/eo3V2Jd1tIh9kcp9JvHeVu1d19FpoW6aZ/QaYAuxnZnXA94F+AO6+GHiUeJJcC2wHOj7XyaBQ+2JWL4GHLoPmxO0ZDRvi05BSsmz5YHv6qnfLunuqBdFVqz7bifLrX/86jz32WEbu1WypS1NTE+6OmRGJRLJex0LSk/tMqC3KMOxJixJCvJ3ghrJ4cmxv8FD4Zoe3koYml1sP27Zt6/S1los8knm5vE3kiqy0KHNVaK2nhrr0ynspM+vwgoa+jyy5LC+ueueFwSXplfdS+XrPnvRuSpSZMnUe9BvYtqzfwHi5JPXt25f+/fsnW5BmljMXckQ6o60zU1ou2HTzqndv0rdvXyVGySvaWjOpfKYSYy8xe/ZsXnvtNS688EK++c1vZjscCZkSpUia/vGPf7By5crdBq6QwqU+SmHpSxuZtPBJRlz5CJMWPsnSlzr8glTKWoZZmzNnDocddhjnnXcef/zjH5k0aRIjR47khRdeADofOqyrYcumTJnC2WefnRzGraMr6LfddhtHHXUUFRUVnHXWWckh3v75z38yY8YMKioqqKioSC73mmuu4bDDDuMzn/kMs2fP5ic/+UmX9fvsZz/Lxo0bGTduHM8880ybwXLfe+89hg8fDsQHBT7zzDM55ZRTGDlyJN/+9reTy3j88ceprKykoqKCqVOn7sF/W3qEu+fVz5FHHunStTVr1qQ874Mv1vkRVz/mpd95OPlzxNWP+YMv1nV7/W+//bYXFRX56tWrfefOnV5ZWekXXnih79q1y5cuXerTp093d/fvfve7fs8997i7++bNm33kyJG+detW37Ztmzc2Nrq7+5tvvuktn/mKFSt8n3328Q0bNvjOnTv96KOP9meeeWa39b/33nvJv6+66ipftGiRu7vPnDnTb7jhBnd337Fjh2/ZssWrq6u9rKzMt23b5g0NDX7ooYf6ddddF1i/MWPGJKcnT57sK1eudHf3TZs2eWlpqbu733HHHT5ixAjfsmWLNzY2+rBhw/ydd97xd99910tKSvytt95yd/dYLJbOv7db0tkmeiug2jvJOzr17uWuW/4Gjc0725Q1Nu/kuuVvcMb4g7u93BEjRiS/FjpmzBimTp2KmbUZXuyJJ55g2bJlyRZcy9Bh0WiUuXPn8vLLL1NUVJQcKANgwoQJlJTEb7kaN24c69ev323AjVdffZWrr76aLVu2sHXrVk4++WQAnnzySe6+Oz48alFREYMHD+aZZ55hxowZ7LXXXgCcfvrp3a5zR6ZOncrgwYMBGD16NLW1tWzevJnjjjsu+VTEfffdN6PrlMxTouzl6rd0PCJ2Z+Wpaj+8WMt06+HFvJOhw+bPn7/bsGUdLbeoqKjNUGUt5syZw9KlS6moqODOO+/kqaee2qO6BGk9tFv7px2mEq/kPvVR9nLRIQPTKs+kzoYO62jYsnR88MEHHHTQQTQ3N/PrX/86WT516lRuueUWID6aUENDA8cddxxLly6lsbGRDz74gIceeijtegwfPpxVq1YB8UE1ghx99NE8/fTTvP322wC8/35X41tLLlCi7OWuOPlwBvZr+4Cvgf2KuOLkzA8Q215nQ4d1NGxZOn74wx8yceJEJk2alBxmDeDGG29kxYoVyeHE1qxZQ2VlJeeeey4VFRWceuqpHHXUUcn5Fy9ezOLFiwPXd/nll3PLLbcwfvz45PN8urL//vtz6623cuaZZ1JRUZEc8b26upqLL744rbpKz+h1g2L0BukOgLD0pY1ct/wN6rc0Eh0ykCtOPnyP+ifz2fz58/nEJz6RfL5PodCgGME0KIZ06YzxB/faxCiSCiVKkVZaHm0r0pr6KEVEAihRiogEUKIUEQmgRCkiEkCJUkJRVFTEuHHjkj8LFy4EaDOARE/66KOPOPHEExk3bhz3339/j69f8puueksoBg4cyMsvv5ztMJJavvWTSzFJ/lCLUuKP2r2hDOYPif9evaTHQ1iwYAFHHXUUZWVlXHLJJcmvNa5du5YTTzyRiooKKisrWbduHe7O3LlzOfzwwznxxBM57bTTuvzq4Lvvvsv555/PypUrGTduHOvWrWP48OHJb9FUV1czZcoUIH570EUXXcSUKVM45JBDWLRoUXI5d999N+Xl5VRUVPDFL34xvH+G5Bwlyt6u5XnkDRsA//h55HuYLBsbG9uceged7s6dO5eVK1fy6quv0tjYyMMPPwzAeeedx9e+9jVeeeUV/vKXv3DQQQfx4IMP8sYbb7BmzRruvvvu5LiSnTnggAP4xS9+wbHHHsvLL7/MoYce2uX8r7/+OsuXL+eFF17gBz/4Ac3Nzbz22mv86Ec/4sknn+SVV17hxhtvTO8fInlNp9693Z8WQHO7kYKaG+Ple/BYi3RPvVesWMGPf/xjtm/fzvvvv8+YMWOYMmUKGzduZMaMGQDJUYSefvppZs+eTVFREdFolBNOOKHbcXbkc5/7HP3796d///4ccMAB/POf/+TJJ5/knHPOYb/99gM0NFpvo0TZ2+XA88g//PBDvvrVr1JdXc3QoUOZP3/+bsOVZZqGRpN06NS7t8uB55G3JKr99tuPrVu3JvsbBw0aRElJCUuXLgXiV663b9/Occcdx/3338/OnTv5+9//zooVK9JeZ+uh0X73u98Fzn/CCSfwwAMPEIvFAA2N1tsoUfZ2IT2PvH0f5ZVXXtnpvEOGDOHLX/4yZWVlnHzyyW2GOrvnnntYtGgR5eXlfPrTn+Yf//gHM2bMYOTIkYwePZoLLriAY445Jjn/vHnzWLZsWWB83//+9/nGN75BVVUVRUVFgfOPGTOGq666ismTJ1NRUcG3vvUtAJYtW8a8eXp2e6HTMGsFKO0htVYvyevnkc+ZM4dp06Zx9tlnZzuUnKVh1oJpmDXpmp5HLtIlJUrJe3feeWe2Q5ACpz5KEZEASpQFKt/6niU82hb2nBJlARowYACxWEw7iODuxGKxNo/8lfSpj7IAlZSUUFdXx6ZNm7IdiuSAAQMGUFLSc/fFFiIlygLUr18/RowYke0wRAqGTr1FRAIoUYqIBNCpt8geisVi1NfX09TURCQSIRqNUlxcnO2wJIN6RaLUhixhicVi1NbWJu8waGpqora2FkDbWBaEta+HmijN7BTgRqAI+IW7L2z3+jDgLmBIYp4r3f3RTMagDTm3FNpBq76+frfbsNyd+vr6vK5XPgpzXw+tj9LMioCbgVOB0cBsMxvdbrargSXuPh6YBfws03F0tSFLz2rZkJuamoCPN+SWocvyUUtdUi2X8IS5r4fZopwArHX3twDM7D5gOrCm1TwO7JP4ezCQ8eyVbxtyobW4WivE1lckEulwW4pEIlmIpncLc18PM1EeDGxoNV0HTGw3z3zgCTP7OrA3cGKmg8inDbnQuwny7aCVimg02uYzAzAzotFoFqMKVogH5DD39WzfHjQbuNPdS4DTgHvMbLeYzOwSM6s2s+p0v20SjUYxs/bLy8kNudC7CTrbYHPxoJWq4uJiSktLk3WIRCKUlpbmdNIpxC4QCHdfD7NFuREY2mq6JFHW2peAUwDc/a9mNgDYD3i39UzufitwK8QH7k0niJYNNh+OnoXY4motX1tfQYqLi3Nye+pMIXaBQLj7epiJciUw0sxGEE+Qs4AvtJvnHWAqcKeZjQIGABn/gnK+bMj51E3QHfl00CpkhXxADmtfDy1RuvsOM5sLLCd+68/t7v6amS0Aqt19GfAfwG1m9k3iF3bmeC8e8qZQW1yt5ctBq5AV+gE5DKHeR5m4J/LRdmXzWv29BpgUZgz5JCMtrjx//o2ErzcckDOtV3wzJ5/sUYtr9RJ46DJoboxPN2yIT4OSpSSpCyR9SpSF5E8LPk6SLZob4+VKlNKKukDSk+3bgySTGurSKxeRlChRFpLBnYxi3Vm5iKREibKQTJ0H/Qa2Les3MF4uIt2mRFlIymfC5xfB4KGAxX9/fpH6J0X2kC7mFJrymUqMIhmmFqWISAAlShGRAEqUIiIBlChFRAIoUYqIBFCiFBEJoEQpErbVS+CGMpg/JP579ZJsRyRp0n2UImHSiE4FQS1KkTB1NaKT5A0lSpEwaUSngqBEKRImjehUEJQoRcKkEZ0KghKlSJg0olNB0FVvkbBpRKe8pxaliEgAJUoRkQBKlCIiAZQoRUQCKFGKiARQohQRCaBEKSISQIlSRCSAEqWISAAlShHJvhwf3FhfYRSR7MqDwY3VohSR7MqDwY2VKEUku/JgcGMlShHJrjwY3FiJUkSyKw8GN1aiFJHsyoPBjXXVWyQDYrEY9fX1NDU1EYlEiEajFBcXZzus/JHjgxuHmijN7BTgRqAI+IW7L+xgnpnAfMCBV9z9C2HGlOu0w+WfWCxGbW0t7g5AU1MTtbW1APrsCkRoidLMioCbgZOAOmClmS1z9zWt5hkJfBeY5O6bzeyAsOLJB4W+wxXqQaC+vj75mbVwd+rr6wuifhJui3ICsNbd3wIws/uA6cCaVvN8GbjZ3TcDuPu7YQWTDztpIe9whXwQaGpqSqtc8k+YifJgYEOr6TpgYrt5DgMws2eJn57Pd/fHMx1IvuykhbzDFfJBIBKJdPgZRSKRLESTunxoPOSKbF/17guMBKYAs4HbzGxI+5nM7BIzqzaz6k2bNqW9kq520lzS2Y6V6ztcKgr5IBCNRjGzNmVmRjQazVJEwVoaDy3//5bGQywWy3JkuSnMRLkRGNpquiRR1lodsMzdm939beBN4omzDXe/1d2r3L1q//33TzuQfNlJ83GHS1UhHwSKi4spLS1N1iUSiVBaWprTrbN8aTykKxaLUVNTw6pVq6ipqclY4g/z1HslMNLMRhBPkLOA9le0lxJvSd5hZvsRPxV/K9OB5MupUcuOVYinQ9FotE33BxTOQQDin10+fU750nhIR5hdbKElSnffYWZzgeXE+x9vd/fXzGwBUO3uyxKvfdbM1gA7gSvcPeNt/3zaSfNth0tVIR8E8lG+NB7SEWY/eKj3Ubr7o8Cj7crmtfrbgW8lfkKjnTQ3FOpBIB/lU+MhVWG2knvNN3O0k4p8rBAbD2G2kjtNlGY2FriN+G0+jwHfabnf0cxecPcJe7x2EcmaQms8hNlK7uqq9y3Ev1o4lvjV6D+b2aGJ1/rt8ZpFRDIozLsPujr1HtTq5u+fmNkq4HEz+yLx72WLiOSUsFrJXfZRmtlgd28AcPcVZnYW8Dtg34xHIiKSo7o69b4WGNW6wN1XA1OB34cZlIhILum0Renu93ZS/g7xwSxERHqFbH/XW0Qk5ylRiogEUKIUEQnQrURpZtMyHYiISK7qbovyqIxGISKSw7qVKN39+5kOREQkVwUOipF4SNjngOGt53f368MLS0Qkd6QyetBDwIdADbAr3HBERHJPKomyxN3LQ49ERCRHpdJH+ZiZfTb0SEREclQqLcrngAfNrA/QDBjxwcn3CTUyEZEckUqivB44Bqjx9g+kEBHpBVI59d4AvKokKSK9VSotyreAp8zsMeCjlkLdHiQivUUqifLtxE8k8SMi0qsEJkp3/0FPBCIikqtS+WbO/sC3gTHAgJZydz8hxLhERHJGKhdzfg28DowAfgCsB1aGGJOISE5JJVEWu/svgWZ3/3/ufhGg1mRvtnoJ3FAG84fEf69eku2IREKVysWc5sTvv5vZ54B69BTG3mv1EnjoMmhujE83bIhPA5TPzF5cIiFKpUX5IzMbDPwHcDnwC+CboUYluetPCz5Oki2aG+PlIgUq6LneRcBId38YaACO75GoJHc11KVXLlIAumxRuvtOYHYPxSL5YHBJeuUiBSCVU+9nzeynZnasmVW2/IQemeSmqfOg38C2Zf0GxstFClQqF3PGJX637oRydOW7d2q5YPOnBfHT7cEl8SSpCzlSwFL5Zo76JaWt8plKjNKrpNKiJHFbUPtv5ugyp4j0CoF9lGa2GDgX+DrxQXvPAUpDjktEJGekcjHn0+5+AbA5MUDGMcBh4YYlIpI7UkmULXcXbzezKPFv6hwUXkgiIrkllT7Kh81sCHAd8CLxK963hRmUiEi6YrEY9fX1NDU1EYlEiEajFBcXZ2TZqVz1/mHiz9+Z2cPAAHdvyMjaRUQyIBaLUVtbS8sTa5qamqitrQXISLJM5WLOADP7lpn9HrgXuMjMBgS9L/HeU8zsDTNba2ZXdjHfWWbmZlaVeugiInH19fW0f6yXu1NfX5+R5ady6n038AFwU2L6C8A9xK9+dyrxPfGbgZOAOmClmS1z9zXt5hsEfAN4Pr3QRWRPhHmq2tOamprSKk9XKomyzN1Ht5peYWZrOp37YxOAte7+FoCZ3QdMB9q/94fAtcAVKSyz4BXSxtub5NvnFvapak+LRCIdJsVIJDOP+UrlqveLZnZ0y4SZTQSqU3jfwcQfdduiLlGWlPjO+FB3fySF5WVELBajpqaGVatWUVNTQywW66lVB2rZeFs+8JaNN5dilN3l4+cW9qlqT4tGo5hZmzIzIxqNZmT5qbQojwT+YmbvJKaHAW+YWQ3g7l7enRWbWR/gemBOCvNeAlwCMGzYsO6sDsj9o2hXG28uxCcdy8fPLexT1Z7W8n/O2lVv4JRuLnsjMLTVdEmirMUgoIz4M8MBPgUsM7PT3b1Ni9XdbwVuBaiqqmq7RaYh1zfoQtt4O5Nvp6lB8vFzC/tUNRuKi4tD245SuT2otpvLXgmMNLMRxBPkLOIXglqW2wDs1zJtZk8Bl7dPkpmU6xt0IW687eV6q7478vFzi0ajbT4HyOypaqFJpY+yW9x9BzAXWA78DVji7q+Z2QIzOz2s9Xalsw03VzbosPtZckGh9Y1Bfn5uxcXFlJaWJrf9SCRCaWlp3h6swpbS6EHd5e6PAo+2K+twhFd3nxJmLJD7R9Gw+1lyQa636rsjXz+3ME9VC02oiTLX5MMGXegbbz6epqai0D+33q5XJUrQBp1tud6qF+lIr0uUkl350KoXaU+JsrdbvaTHn3+jVr3kGyXK3mz1EnjoMmhODDnasCE+DXomjkgrod0eJHngTws+TpItmhvj5SKSpETZmzXUpVcu0kspUfZmg0vSKxfppZQoe7Op86DfwLZl/QbGy0UkSYmyNyufCZ9fBIOHAhb//flFupAj0o6uevd25TOVGEUCqEUpIhJAiVJEJIASpYhIACVKEZEASpQiIgGUKEVEAihRiogEUKIUEQmgRCkiEkCJUkQkgBKliEgAJcrOrF4CN5TB/CHx36uXZDsiEckSDYrRET0iQURaUYuyI3pEgoi0okTZET0iQURaUaLsiB6RICKtKFF2RI9IEJFWlCg7okckiEgruurdGT0iQUQS1KIUEQmgRCkiEkCJUkQkgBKliEgAJUoRkQBKlCIiAZQoRUQCKFGKiAQI9YZzMzsFuBEoAn7h7gvbvf4t4GJgB7AJuMjda8OMSXJDLBajvr6epqYmIpEI0WiU4uLibIcl0qHQEqWZFQE3AycBdcBKM1vm7mtazfYSUOXu283sUuDHwLlhxJNvO2a+xZuOWCxGbW0t7g5AU1MTtbXx42Oh1FEKS5in3hOAte7+lrs3AfcB01vP4O4r3H17YvI5IJTheVp2zKamJuDjHTMWi4Wxuj2Wb/Gmq76+PpkkW7g79fX1WYpIpGthJsqDgQ2tpusSZZ35EvBYGIHk246Zb/Gmq+UAkGq5SLblxKAYZnY+UAVM7uT1S4BLAIYNG5b28vNtx8y3eNMViUQ6rEskEslCNCLBwkyUG4GhraZLEmVtmNmJwFXAZHf/qKMFufutwK0AVVVV3tE8Xcm3HTPf4k1XNBpt00cJYGZEo9EsRtU9hdSXXAh1CasOYZ56rwRGmtkIM4sAs4BlrWcws/HAz4HT3f3dsAKJRqOYWZuyXN4x8y3edBUXF1NaWppM/JFIhNLS0rzcKQulL7kQ6hJmHUJrUbr7DjObCywnfnvQ7e7+mpktAKrdfRlwHfAJ4IFEYnjH3U/PdCwtO2C+HC3zLd7uKC4uzvv6dNWXnG91K4S6hFmHUPso3f1R4NF2ZfNa/X1imOtvLd92zHyLtzcqpL7kQqhLmHXQN3NEuqmzPuN87EsuhLqEWQclSpFuKqS+5EKoS5h1yInbg0TyUSH1JRdCXcKsgxKlyB4opL7kQqhLWHXQqbeISAAlShGRAEqUIiIBlChFRAIoUYqIBFCiFBEJoEQpIhJAiVJEJIASpYhIACVKEZEASpQiIgGUKEVEAihRiogEUKIUEQmgRCkiEkCJUkQkgBKlSCatXgI3lMH8IfHfq5dkOyLJAI1wLpIpq5fAQ5dBc2N8umFDfBqgfGb24pI9phalSKb8acHHSbJFc2O8XPKaEqVIpjTUpVcueUOJUiRTBpekVy55Q4lSJFOmzoN+A9uW9RsYL5e8pkQpkinlM+Hzi2DwUMDivz+/SBdyCoCueotkUvlMJcYC1KsT5dVLa/jN8xvY6U6RGbMnDuVHZ4zNdlgikmN6baK8emkNv3runeT0TvfktJKliLTW6xLl0pc2ct3yN9i4pbHD13/13DtUle7LGeMP7uHIRCRX9apEufSljXz39zU0Nu/scr7v/r4GQMlSRIACT5Qtrcf6LY0M2asfW7Y34ym8r7F5J9ctf0OJUkSAAk6U7VuPm7c3p/X++k5OzUWk9ynY+yivW/5G4Cl2V6JDBgbPJCK9QsEmylRbhP36GP2KrE3ZwH5FXHHy4WGEJSJ5qGBPvYfs1S/wdLvIjOvOqQBI9mVGhwzkipMPV/+kiCQVbKL0gKs2A/sV8X/PHJtMiEqMItKZgk2UDY2dtyYPVqtRRNIQaqI0s1OAG4Ei4BfuvrDd6/2Bu4EjgRhwrruvz8S6D9wnwj/+1bRb+af2ifDslSdkYhU9IhaLUV9fT1NTE5FIhGg0SnFxcbbDEulVQkuUZlYE3AycBNQBK81smbuvaTXbl4DN7v5/zGwWcC1wbibWX3lgPx7tIFFWHtgvE4vvEbFYjNraWjzRj9DU1ERtbS1AwSVLHRAkl4XZopwArHX3twDM7D5gOtA6UU4H5if+/i3wUzMz96AexmAvbOz4qndn5bmovr6e9v8Kd6e+vr6gkkg+HxCU4HuHMG8POhjY0Gq6LlHW4TzuvgNoAHbbyszsEjOrNrPqTZs2pbTy2PZdaZXnoqam3VvEXZXnq64OCLmsJcG3fB4tCT4Wi2U5Msm0vLiY4+63ArcCVFVVpdTa7KyP8sB9IpkNLkSRSKTDpBiJ5E8dUpGvB4RCbPGrhdyxMFuUG4GhraZLEmUdzmNmfYHBxC/q7LErTx3NgL5tqzegbx+uPHV0JhbfI6LRKGZtb4Y3M6LRaJYiCkdniT/XDwj5muA7oxZy58JMlCuBkWY2wswiwCxgWbt5lgH/lvj7bODJTPRPQvy+yIVnlXPwkIEY8VuCFp5Vnle3BBUXF1NaWppMGJFIhNLS0oI7wufrASFfE3xn8rULpCeEdurt7jvMbC6wnPjtQbe7+2tmtgCodvdlwC+Be8xsLfA+8WSaMWeMPzivEmNHiouLCy4xttdSv3w75YtGo20uQkF+JPjOFEILOayug1D7KN39UeDRdmXzWv39IXBOmDFIfsjHA0K+JvjO5HufeJh3T+TFxRyRXJWPCb4z+d5CDvPimhKliAD530IOs+tAiVJEkvK5hRxm10HBjkcpIr1LmHdPqEUpIgUhzK4DJUoRKRhhdR3o1FtEJIASpYhIACVKEZEASpQiIgGUKEVEAihRiogEUKIUEQmgRCkiEsAyNE5ujzGzTUBtmm/bD3gvhHCyoVDqUij1gMKpS6HUA7pXl1J337+jF/IuUXaHmVW7e1W248iEQqlLodQDCqcuhVIPyHxddOotIhJAiVJEJEBvSZS3ZjuADCqUuhRKPaBw6lIo9YAM16VX9FGKiOyJ3tKiFBHptoJKlGZ2ipm9YWZrzezKDl7vb2b3J15/3syGZyHMQCnU41tmtsbMVpvZn8ysNBtxpiKoLq3mO8vM3Mxy8qprKvUws5mJz+U1M7u3p2NMVQrb1zAzW2FmLyW2sdOyEWcQM7vdzN41s1c7ed3MbFGinqvNrLLbK3P3gvgh/uzwdcAhQAR4BRjdbp6vAosTf88C7s923N2sx/HAXom/L83FeqRal8R8g4CngeeAqmzH3c3PZCTwEvDJxPQB2Y57D+pyK3Bp4u/RwPpsx91JXY4DKoFXO3n9NOAxwICjgee7u65CalFOANa6+1vu3gTcB0xvN8904K7E378Fplr7h2xkX2A93H2Fu29PTD4HlPRwjKlK5TMB+CFwLfBhTwaXhlTq8WXgZnffDODu7/ZwjKlKpS4O7JP4ezBQ34Pxpczdnwbe72KW6cDdHvccMMTMDurOugopUR4MbGg1XZco63Aed98BNAC59si5VOrR2peIHzVzUWBdEqdDQ939kZ4MLE2pfCaHAYeZ2bNm9pyZndJj0aUnlbrMB843szrgUeDrPRNaxqW7L3VKz8zJY2Z2PlAFTM52LN1hZn2A64E5WQ4lE/oSP/2eQryF/7SZjXX3LdkMqptmA3e6+3+Z2THAPWZW5u67sh1YthRSi3IjMLTVdEmirMN5zKwv8dOKWI9El7pU6oGZnQhcBZzu7h/1UGzpCqrLIKAMeMrM1hPvR1qWgxd0UvlM6oBl7t7s7m8DbxJPnLkmlbp8CVgC4O5/BQYQ/+50vklpX0pFISXKlcBIMxthZhHiF2uWtZtnGfBvib/PBp70RK9vDgmsh5mNB35OPEnmal8YBNTF3RvcfT93H+7uw4n3t57u7tXZCbdTqWxbS4m3JjGz/Yifir/VgzGmKpW6vANMBTCzUcQT5aYejTIzlgEXJK5+Hw00uPvfu7WkbF+5yvBVsNOIH8nXAVclyhYQ3/kg/oE/AKwFXgAOyXbM3azHH4F/Ai8nfpZlO+bu1qXdvE+Rg1e9U/xMjHg3whqgBpiV7Zj3oC6jgWeJXxF/GfhstmPupB6/Af4ONBNv0X8J+ArwlVafyc2Jetbsybalb+aIiAQopFNvEZFQKFGKiARQohQRCaBEKSISQIlSRCSAEqVIF8zsCDP7q5l9ZGaXZzseyQ59hVHynpn19fh398PwPnAZcEZIy5c8oEQpWZcYF/RxYBXxYbNeAy5w9+1mNg/4PDAQ+Avw7+7uZvYU8ZuhPwP8xszeBK4mPnRYDDjP3f9pZvOBEcSHFRsGfJP4VyVPJf51ts+7e3NnsXn8m0/vmtnnMlxtySM69ZZccTjwM3cfBfyL+NihAD9196PcvYx4spzW6j0Rd69y9/8C/gwc7e7jiQ8d9u1W8x0KnACcDvwKWOHuY4FGQAlQAilRSq7Y4O7PJv7+FfGWIsDxidHoa4gnuzGt3nN/q79LgOWJ+a5oN99jiVZjDfGBax9PlNcAwzNaCylISpSSK9p/l9bNbADwM+DsRAvwNuLf12+xrdXfNxFvfY4F/r3dfB8BeHyYsGb/+Hu7u1D3k6RAiVJyxbDE2IcAXyB+Kt2S7N4zs08QH/GpM4P5eAitf+tiPpG0KVFKrngD+JqZ/Q34JHCLxwe9vQ14FVhOfIiwzswHHjCzVcB76a7czBaY2ekdlH8qMdL3t4CrzazOzPbZfQlSyDR6kGRd4qr3w4kLNiI5Ry1KEZEAalGKiARQi1JEJIASpYhIACVKEZEASpQiIgGUKEVEAihRiogE+P/rfrEBGuOHEwAAAABJRU5ErkJggg==\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -523,7 +547,7 @@
    "metadata": {},
    "outputs": [],
    "source": [
-    "sampler = BestBatchSampler(batch_size=16, internal_seed=0)\n",
+    "sampler = BestBatchSampler(batch_size=16, random_state=0)\n",
     "new_params = sampler.sample(param_grid, xys, losses)"
    ]
   },
@@ -536,7 +560,7 @@
     {
      "data": {
       "text/plain": [
-       "<matplotlib.legend.Legend at 0x7fc2dc923ed0>"
+       "<matplotlib.legend.Legend at 0x7fe9bf99ff10>"
       ]
      },
      "execution_count": 18,
@@ -545,7 +569,7 @@
     },
     {
      "data": {
-      "image/png": "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\n",
+      "image/png": "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\n",
       "text/plain": [
        "<Figure size 360x360 with 1 Axes>"
       ]
@@ -593,7 +617,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.4"
+   "version": "3.8.12"
   },
   "toc": {
    "base_numbering": 1,
@@ -611,4 +635,4 @@
  },
  "nbformat": 4,
  "nbformat_minor": 5
-}
\ No newline at end of file
+}
diff --git a/scripts/whitelists/package_whitelist.py b/scripts/whitelists/package_whitelist.py
index b568356b..86fd3396 100644
--- a/scripts/whitelists/package_whitelist.py
+++ b/scripts/whitelists/package_whitelist.py
@@ -2,7 +2,6 @@
 # type: ignore
 # pylint: skip-file
 _.random_state  # unused attribute (black_it/samplers/best_batch.py:47)
-_.set_internal_seed  # unused method (black_it/samplers/base.py:162)
 plot_losses_interact  # unused function (black_it/plot/plot_results.py:152)
 plot_sampling_interact  # unused function (black_it/plot/plot_results.py:218)
 plot_convergence  # unused function (black_it/plot/plot_results.py:21)


Test patch:
diff --git a/tests/conftest.py b/tests/conftest.py
index 18da6f28..d04bb884 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -26,4 +26,4 @@
 PLOT_DIR = FIXTURES_DIR / "plots"
 EXAMPLE_SAVING_FOLDER = ROOT_DIR / "examples" / "saving_folder"
 
-DEFAULT_SUBPROCESS_TIMEOUT = 45.0
+DEFAULT_SUBPROCESS_TIMEOUT = 60.0
diff --git a/tests/test_calibrator.py b/tests/test_calibrator.py
index dfed1a80..d19e62cb 100644
--- a/tests/test_calibrator.py
+++ b/tests/test_calibrator.py
@@ -62,6 +62,9 @@ def setup(self) -> None:
         # generate a synthetic dataset to test the calibrator
         self.real_data = self.model(self.true_params, N=100, seed=0)
 
+        # set calibrator initial random seed
+        self.random_state = 0
+
         # define a loss
         self.loss = MethodOfMomentsLoss()
 
@@ -70,58 +73,58 @@ def test_calibrator_calibrate(self, n_jobs: int) -> None:
         """Test the Calibrator.calibrate method, positive case, with different number of jobs."""
         expected_params = np.array(
             [
-                [0.7, 0.61],
-                [0.86, 0.75],
-                [0.86, 0.64],
-                [0.82, 0.76],
-                [0.91, 0.68],
-                [0.02, 0.64],
-                [0.88, 0.65],
-                [0.75, 0.12],
-                [0.51, 0.34],
-                [0.52, 0.78],
-                [0.48, 0.52],
-                [0.84, 0.27],
-                [0.77, 0.22],
-                [0.82, 0.09],
-                [0.13, 0.45],
-                [0.99, 0.99],
-                [0.02, 0.02],
-                [0.26, 0.67],
-                [1.0, 0.98],
-                [0.26, 0.08],
-                [0.72, 0.96],
-                [0.01, 0.02],
-                [0.9, 0.76],
-                [0.86, 0.7],
+                [0.53, 0.41],
+                [0.55, 0.48],
+                [0.95, 0.7],
+                [0.53, 0.46],
+                [0.42, 0.77],
+                [0.9, 0.69],
+                [0.06, 0.15],
+                [0.04, 0.4],
+                [0.92, 0.6],
+                [0.04, 0.01],
+                [0.66, 0.21],
+                [0.05, 0.02],
+                [0.58, 0.45],
+                [0.16, 0.07],
+                [0.89, 0.96],
+                [0.43, 0.5],
+                [0.57, 0.53],
+                [0.9, 0.64],
+                [0.97, 0.23],
+                [0.01, 0.03],
+                [0.91, 0.83],
+                [0.04, 0.04],
+                [0.3, 0.81],
+                [0.71, 0.74],
             ]
         )
 
         expected_losses = [
-            0.3972552,
-            0.42686962,
-            0.43481878,
-            0.73160366,
-            0.73603323,
-            0.8516071,
-            0.90245126,
-            0.97365625,
-            1.06424397,
-            1.11547266,
-            1.17847713,
-            1.2153038,
-            1.25877588,
-            1.26424663,
-            1.49182603,
-            1.60069072,
-            1.60835184,
-            1.69164426,
-            1.71154007,
-            2.00411593,
-            2.28922901,
-            2.36455155,
-            2.61220382,
-            3.60022745,
+            0.18717979,
+            0.49858541,
+            0.52827096,
+            0.66038152,
+            0.66998437,
+            0.99106997,
+            1.17061966,
+            1.18826265,
+            1.39383134,
+            1.42949217,
+            1.54123579,
+            1.61444394,
+            1.61633296,
+            1.71192916,
+            1.78157112,
+            1.7833771,
+            1.82346312,
+            2.19303187,
+            2.28332458,
+            2.32757743,
+            2.33589996,
+            2.55056468,
+            3.28218462,
+            3.64581369,
         ]
 
         cal = Calibrator(
@@ -140,6 +143,7 @@ def test_calibrator_calibrate(self, n_jobs: int) -> None:
             ensemble_size=3,
             loss_function=self.loss,
             saving_folder=None,
+            random_state=self.random_state,
             n_jobs=n_jobs,
         )
 
@@ -229,6 +233,11 @@ def test_calibrator_restore_from_checkpoint_and_set_sampler() -> None:
                 type(vars_cal["param_grid"]).__name__
                 == type(cal_restored.param_grid).__name__  # noqa
             )
+        elif key == "_random_generator":
+            assert (
+                vars_cal[key].bit_generator.state
+                == cal_restored.random_generator.bit_generator.state
+            )
         # otherwise check the equality of numerical values
         else:
             assert vars_cal[key] == pytest.approx(getattr(cal_restored, key))
@@ -266,7 +275,7 @@ def single_sample(
             """Do a single sample."""
 
     cal = Calibrator(
-        samplers=[MyCustomSampler(MagicMock(), MagicMock(), MagicMock())],
+        samplers=[MyCustomSampler(batch_size=2)],
         real_data=MagicMock(),
         model=MagicMock(),
         parameters_bounds=np.array([MagicMock(), MagicMock()]),
diff --git a/tests/test_examples/test_main.py b/tests/test_examples/test_main.py
index 5d941b31..2d5172ad 100644
--- a/tests/test_examples/test_main.py
+++ b/tests/test_examples/test_main.py
@@ -24,7 +24,7 @@
 
 
 TRUE_PARAMETERS_STR = "True parameters:       [0.2, 0.2, 0.75]"
-BEST_PARAMETERS_STR = "Best parameters found: [0.21 0.2  0.76]"
+BEST_PARAMETERS_STR = "Best parameters found: [0.18 0.19 0.75]"
 
 
 @pytest.mark.e2e
@@ -35,7 +35,7 @@ class TestMainExample(  # pylint: disable=too-few-public-methods
 
     script_path = EXAMPLE_MAIN_SCRIPT_PATH
     timeout = DEFAULT_SUBPROCESS_TIMEOUT
-    nb_batches = 4
+    nb_batches = 5
     expected_lines = [
         "PARAMS SAMPLED: 0",
         "METHOD: HaltonSampler",
diff --git a/tests/test_samplers/test_base.py b/tests/test_samplers/test_base.py
index 3b8ab760..58bab6f6 100644
--- a/tests/test_samplers/test_base.py
+++ b/tests/test_samplers/test_base.py
@@ -36,8 +36,8 @@ def test_find_and_get_duplicates() -> None:
     assert duplicates == [0, 1, 2, 4, 5]
 
 
-class TestSetInternalSeed:  # pylint: disable=attribute-defined-outside-init,too-many-instance-attributes
-    """Test 'BaseSampler.set_internal_seed'."""
+class TestSetRandomState:  # pylint: disable=attribute-defined-outside-init,too-many-instance-attributes
+    """Test 'BaseSampler.random_state' setter."""
 
     class MyCustomSampler(BaseSampler):
         """
@@ -63,24 +63,24 @@ def setup(self) -> None:
         self.bounds_step = np.asarray([0.01, 0.01, 0.01])
         self.default_seed = 42
         self.batch_size = 32
-        self.sampler = TestSetInternalSeed.MyCustomSampler(
-            self.batch_size, internal_seed=self.default_seed
+        self.sampler = TestSetRandomState.MyCustomSampler(
+            self.batch_size, random_state=self.default_seed
         )
         self.search_space = SearchSpace(self.bounds, self.bounds_step, False)
         self.existing_points = np.zeros((0, self.bounds.shape[1]))
         self.existing_losses = np.zeros(0)
 
-    def test_set_internal_seed_gives_same_result(self) -> None:
-        """Test sampler gives same result after setting internal seed."""
+    def test_set_random_state_gives_same_result(self) -> None:
+        """Test sampler gives same result after setting random state."""
         seed = 11
-        self.sampler.set_internal_seed(seed)
+        self.sampler.random_state = seed
         expected_result_1 = self.sampler.sample(
             self.search_space, self.existing_points, self.existing_losses
         )
         expected_result_2 = self.sampler.sample(
             self.search_space, self.existing_points, self.existing_losses
         )
-        self.sampler.set_internal_seed(seed)
+        self.sampler.random_state = seed
         actual_result_1 = self.sampler.sample(
             self.search_space, self.existing_points, self.existing_losses
         )
@@ -90,8 +90,8 @@ def test_set_internal_seed_gives_same_result(self) -> None:
         assert (expected_result_1 == actual_result_1).all()
         assert (expected_result_2 == actual_result_2).all()
 
-    def test_set_internal_seed_works_correctly(self) -> None:
-        """Test 'BaseSampler.set_internal_seed' actually sets the internal seed."""
-        assert self.sampler.internal_seed == self.default_seed
-        self.sampler.set_internal_seed(1)
-        assert self.sampler.internal_seed == 1
+    def test_set_random_state_works_correctly(self) -> None:
+        """Test 'BaseSampler.set_random_state' setter actually sets the internal random state."""
+        assert self.sampler.random_state == self.default_seed
+        self.sampler.random_state = 1
+        assert self.sampler.random_state == 1
diff --git a/tests/test_samplers/test_best_batch.py b/tests/test_samplers/test_best_batch.py
index 625db2bf..904e2a6c 100644
--- a/tests/test_samplers/test_best_batch.py
+++ b/tests/test_samplers/test_best_batch.py
@@ -50,7 +50,7 @@ def test_best_batch_2d() -> None:
     xys = np.array(xys_list)
     losses = np.array(losses_list)
 
-    sampler = BestBatchSampler(batch_size=8, internal_seed=0)
+    sampler = BestBatchSampler(batch_size=8, random_state=0)
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
         parameters_precision=np.array([0.01, 0.01]),
@@ -64,7 +64,7 @@ def test_best_batch_2d() -> None:
 def test_best_batch_clipping() -> None:
     """Test the best-batch clipping when sampling."""
     lower_bound, upper_bound = 0.499, 0.5
-    sampler = BestBatchSampler(batch_size=8, internal_seed=0)
+    sampler = BestBatchSampler(batch_size=8, random_state=0)
     param_grid = SearchSpace(
         parameters_bounds=np.array(
             [[lower_bound, upper_bound], [lower_bound, upper_bound]]
@@ -91,7 +91,7 @@ def test_best_batch_sample_requires_batch_size_existing_points() -> None:
         parameters_precision=np.array([0.01, 0.01]),
         verbose=False,
     )
-    sampler = BestBatchSampler(batch_size=batch_size, internal_seed=0)
+    sampler = BestBatchSampler(batch_size=batch_size, random_state=0)
     with pytest.raises(
         ValueError,
         match="best-batch sampler requires a number of "
diff --git a/tests/test_samplers/test_gaussian_process.py b/tests/test_samplers/test_gaussian_process.py
index 1a267883..b2e0139e 100644
--- a/tests/test_samplers/test_gaussian_process.py
+++ b/tests/test_samplers/test_gaussian_process.py
@@ -40,10 +40,14 @@ def _construct_fake_grid(cls) -> Tuple[NDArray[np.float64], NDArray[np.float64]]
         xys_list = []
         losses_list = []
 
+        np.random.seed(0)
         for x in xs:
             for y in ys:
+                x = x + np.random.normal(0, 1e-2)
+                y = y + np.random.normal(0, 1e-2)
                 xys_list.append([x, y])
                 losses_list.append(x**2 + y**2)
+
         return np.asarray(xys_list), np.asarray(losses_list)
 
     @pytest.mark.parametrize(
@@ -52,22 +56,22 @@ def _construct_fake_grid(cls) -> Tuple[NDArray[np.float64], NDArray[np.float64]]
             [
                 "mean",
                 1,
-                np.array([[0.01, 0.0], [0.01, 0.01], [0.02, 0.0], [0.01, 0.02]]),
+                np.array([[0.0, 0.0], [0.01, 0.01], [0.0, 0.02], [0.02, 0.02]]),
             ],
             [
                 "mean",
-                5,
-                np.array([[0.01, 0.0], [0.01, 0.01], [0.02, 0.0], [0.01, 0.02]]),
+                3,
+                np.array([[0.0, 0.0], [0.01, 0.01], [0.0, 0.02], [0.02, 0.02]]),
             ],
             [
                 "expected_improvement",
                 1,
-                None,  # skip this due to reproducibility issue
+                np.array([[0.68, 0.51], [0.84, 0.12], [0.76, 0.6], [1.0, 0.57]]),
             ],
             [
                 "expected_improvement",
-                5,
-                None,  # skip this due to reproducibility issue
+                3,
+                np.array([[0.68, 0.51], [0.84, 0.12], [0.76, 0.6], [1.0, 0.57]]),
             ],
         ],
     )
@@ -80,7 +84,7 @@ def test_gaussian_process_2d(
         """Test the Gaussian process sampler, 2d."""
         sampler = GaussianProcessSampler(
             batch_size=4,
-            internal_seed=0,
+            random_state=0,
             optimize_restarts=optimize_restarts,
             acquisition=acquisition,
         )
@@ -91,11 +95,6 @@ def test_gaussian_process_2d(
         )
         new_params = sampler.sample(param_grid, self.xys, self.losses)
 
-        if expected_params is None:
-            pytest.skip(
-                "The test with acquisition=expected_improvement is temporarily "
-                "skipped due to reproducibility issues."
-            )
         assert np.allclose(cast(NDArray, expected_params), new_params)
 
 
@@ -111,7 +110,7 @@ def test_gaussian_process_single_sample_raises_not_implemented_error() -> None:
 
 def test_gaussian_process_sample_warning_too_large_dataset() -> None:
     """Test GaussianProcessSampler.sample wiht too many existing points."""
-    sampler = GaussianProcessSampler(batch_size=4, internal_seed=0, acquisition="mean")
+    sampler = GaussianProcessSampler(batch_size=4, random_state=0, acquisition="mean")
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
         parameters_precision=np.array([0.01, 0.01]),
diff --git a/tests/test_samplers/test_halton.py b/tests/test_samplers/test_halton.py
index a922005b..e28000c9 100644
--- a/tests/test_samplers/test_halton.py
+++ b/tests/test_samplers/test_halton.py
@@ -35,7 +35,7 @@
 
 def test_halton_2d() -> None:
     """Test the Halton sampler, 2d."""
-    sampler = HaltonSampler(batch_size=8, internal_seed=0)
+    sampler = HaltonSampler(batch_size=8, random_state=0)
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
         parameters_precision=np.array([0.01, 0.01]),
diff --git a/tests/test_samplers/test_random_forest.py b/tests/test_samplers/test_random_forest.py
index 4f3a0d7a..abcfcce3 100644
--- a/tests/test_samplers/test_random_forest.py
+++ b/tests/test_samplers/test_random_forest.py
@@ -41,7 +41,7 @@ def test_random_forest_2d() -> None:
     xys = np.array(xys_list)
     losses = np.array(losses_list)
 
-    sampler = RandomForestSampler(batch_size=4, internal_seed=0)
+    sampler = RandomForestSampler(batch_size=4, random_state=0)
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
         parameters_precision=np.array([0.01, 0.01]),
@@ -54,7 +54,7 @@ def test_random_forest_2d() -> None:
 
 def test_random_forest_single_sample_raises_error() -> None:
     """Test that 'RandomForestSampler.single_sample' raises NotImplementedError."""
-    sampler = RandomForestSampler(batch_size=4, internal_seed=0)
+    sampler = RandomForestSampler(batch_size=4, random_state=0)
     with pytest.raises(
         NotImplementedError,
         match="for RandomForestSampler the parallelization is hard coded in sample",
diff --git a/tests/test_samplers/test_random_uniform.py b/tests/test_samplers/test_random_uniform.py
index 079ee015..dafc6409 100644
--- a/tests/test_samplers/test_random_uniform.py
+++ b/tests/test_samplers/test_random_uniform.py
@@ -35,7 +35,7 @@
 
 def test_random_uniform() -> None:
     """Test the random uniform sampler."""
-    sampler = RandomUniformSampler(batch_size=8, internal_seed=0)
+    sampler = RandomUniformSampler(batch_size=8, random_state=0)
 
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
@@ -52,7 +52,7 @@ def test_random_uniform_uniqueness() -> None:
     existing_points = expected_params[:1]
     expected_params_unique = np.vstack((np.array([[0.72, 0.33]]), expected_params[1:]))
 
-    sampler = RandomUniformSampler(batch_size=8, internal_seed=0)
+    sampler = RandomUniformSampler(batch_size=8, random_state=0)
 
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
diff --git a/tests/test_samplers/test_rseq.py b/tests/test_samplers/test_rseq.py
index 1057f1cf..b766375f 100644
--- a/tests/test_samplers/test_rseq.py
+++ b/tests/test_samplers/test_rseq.py
@@ -35,12 +35,11 @@
 
 def test_rsequence_2d() -> None:
     """Test the r-sequence sampler, 2d."""
-    sampler = RSequenceSampler(batch_size=8, internal_seed=0)
+    sampler = RSequenceSampler(batch_size=8, random_state=0)
     param_grid = SearchSpace(
         parameters_bounds=np.array([[0, 1], [0, 1]]).T,
         parameters_precision=np.array([0.01, 0.01]),
         verbose=False,
     )
     new_params = sampler.sample(param_grid, np.zeros((0, 2)), np.zeros((0, 2)))
-    print(new_params)
     assert np.allclose(expected_params, new_params)
diff --git a/tests/test_utils/test_pandas_json_checkpointing.py b/tests/test_utils/test_pandas_json_checkpointing.py
index 38139c40..da63ec72 100644
--- a/tests/test_utils/test_pandas_json_checkpointing.py
+++ b/tests/test_utils/test_pandas_json_checkpointing.py
@@ -36,7 +36,10 @@ def test_save_and_load_calibrator_state() -> None:  # pylint: disable=too-many-l
     convergence_precision = 0.1
     verbose = True
     saving_folder = "saving_folder"
-    model_seed = 0
+    initial_random_seed = 0
+    random_generator_state = np.random.default_rng(
+        initial_random_seed
+    ).bit_generator.state
     model_name = "model"
     samplers = ["method_a", "method_b"]  # list of objects
     loss_function = "loss_a"  # object
@@ -61,7 +64,8 @@ def test_save_and_load_calibrator_state() -> None:  # pylint: disable=too-many-l
         convergence_precision,
         verbose,
         saving_folder,
-        model_seed,
+        initial_random_seed,
+        random_generator_state,
         model_name,
         samplers,  # type: ignore
         loss_function,  # type: ignore
@@ -87,20 +91,21 @@ def test_save_and_load_calibrator_state() -> None:  # pylint: disable=too-many-l
     assert np.allclose(loaded_state[6], convergence_precision)
     assert np.allclose(loaded_state[7], verbose)
     assert loaded_state[8] == saving_folder
-    assert np.allclose(loaded_state[9], model_seed)
-    assert loaded_state[10] == model_name
-    assert loaded_state[11] == samplers
-    assert loaded_state[12] == loss_function
-    assert np.allclose(loaded_state[13], current_batch_index)
-    assert np.allclose(loaded_state[14], n_sampled_params)
-    assert np.allclose(loaded_state[15], n_jobs)
+    assert np.allclose(loaded_state[9], initial_random_seed)
+    assert loaded_state[10] == random_generator_state
+    assert loaded_state[11] == model_name
+    assert loaded_state[12] == samplers
+    assert loaded_state[13] == loss_function
+    assert np.allclose(loaded_state[14], current_batch_index)
+    assert np.allclose(loaded_state[15], n_sampled_params)
+    assert np.allclose(loaded_state[16], n_jobs)
 
     # results of calibration
-    assert np.allclose(loaded_state[16], params_samp)
-    assert np.allclose(loaded_state[17], losses_samp)
-    assert np.allclose(loaded_state[18], series_samp)
-    assert np.allclose(loaded_state[19], batch_num_samp)
-    assert np.allclose(loaded_state[20], method_samp)
+    assert np.allclose(loaded_state[17], params_samp)
+    assert np.allclose(loaded_state[18], losses_samp)
+    assert np.allclose(loaded_state[19], series_samp)
+    assert np.allclose(loaded_state[20], batch_num_samp)
+    assert np.allclose(loaded_state[21], method_samp)
 
     # remove the test folder
     files = glob.glob("saving_folder/*")
diff --git a/tests/test_utils/test_sqlite3_checkpointing.py b/tests/test_utils/test_sqlite3_checkpointing.py
index 0367b388..e93c8d93 100644
--- a/tests/test_utils/test_sqlite3_checkpointing.py
+++ b/tests/test_utils/test_sqlite3_checkpointing.py
@@ -40,7 +40,10 @@ def test_sqlite3_checkpointing() -> None:  # pylint: disable=too-many-locals
     convergence_precision = 0.1
     verbose = True
     saving_file = "test"
-    model_seed = 0
+    initial_random_seed = 0
+    random_generator_state = np.random.default_rng(
+        initial_random_seed
+    ).bit_generator.state
     model_name = "model"
     samplers = ["method_a", "method_b"]  # list of objects
     loss_function = "loss_a"  # object
@@ -64,7 +67,8 @@ def test_sqlite3_checkpointing() -> None:  # pylint: disable=too-many-locals
             convergence_precision,
             verbose,
             saving_file,
-            model_seed,
+            initial_random_seed,
+            random_generator_state,
             model_name,
             samplers,  # type: ignore
             loss_function,  # type: ignore
@@ -78,11 +82,11 @@ def test_sqlite3_checkpointing() -> None:  # pylint: disable=too-many-locals
 
         loaded_state = load_calibrator_state(checkpoint_dir)
 
-        assert np.allclose(loaded_state[14], params_samp)
-        assert np.allclose(loaded_state[15], losses_samp)
-        assert np.allclose(loaded_state[16], series_samp)
-        assert np.allclose(loaded_state[17], batch_num_samp)
-        assert np.allclose(loaded_state[18], method_samp)
+        assert np.allclose(loaded_state[15], params_samp)
+        assert np.allclose(loaded_state[16], losses_samp)
+        assert np.allclose(loaded_state[17], series_samp)
+        assert np.allclose(loaded_state[18], batch_num_samp)
+        assert np.allclose(loaded_state[19], method_samp)
 
 
 @patch("sqlite3.connect")
@@ -118,6 +122,6 @@ def test_sqlite3_checkpointing_saving_when_error_occurs(
     connection_mock = MagicMock()
     connection_mock.cursor.side_effect = ValueError(error_message)
     connect_mock.return_value = connection_mock
-    mock_args = [MagicMock()] * 20
+    mock_args = [MagicMock()] * 21
     with pytest.raises(ValueError, match=error_message):
         save_calibrator_state(*mock_args)