Use numpy.random's Generator instead of legacy RandomState (#821)

Updated tests to use fixed RNG algorithms where seed is important

Author: rharish101

docs/templates/getting-started/minimizing_functions.md

@@ -84,7 +84,7 @@ date-times, you'll be fine.
 them as attachments.
 
 **HINT:** If you need to replicate the results of the stochastic search (e.g. for a demonstration),
-pass an object of type `np.random.RandomState` into the `fmin` function, using the `rstate` optional parameter.
+pass an object of type `np.random.Generator` into the `fmin` function, using the `rstate` optional parameter.
 
 Writing the function above in dictionary-returning style, it
 would look like this:

hyperopt/algobase.py

@@ -223,10 +223,10 @@ def __init__(self, domain, trials, seed):
             n: l for l, n in list(self.domain.vh.vals_by_label().items())
         }
         self._seed = seed
-        self.rng = np.random.RandomState(seed)
+        self.rng = np.random.default_rng(seed)
 
     def __call__(self, new_id):
-        self.rng.seed(self._seed + new_id)
+        self.rng = np.random.default_rng(self._seed + new_id)
         memo = self.eval_nodes(
             memo={self.domain.s_new_ids: [new_id], self.domain.s_rng: self.rng}
         )
@@ -246,7 +246,7 @@ def on_node(self, memo, node):
 
     def batch(self, new_ids):
         new_ids = list(new_ids)
-        self.rng.seed([self._seed] + new_ids)
+        self.rng = np.random.default_rng([self._seed] + new_ids)
         memo = self.eval_nodes(
             memo={self.domain.s_new_ids: new_ids, self.domain.s_rng: self.rng}
         )

hyperopt/atpe.py

@@ -698,7 +698,7 @@ def __init__(self):
     def recommendNextParameters(
         self, hyperparameterSpace, results, currentTrials, lockedValues=None
     ):
-        rstate = numpy.random.RandomState(seed=int(random.randint(1, 2 ** 32 - 1)))
+        rstate = numpy.random.default_rng(seed=int(random.randint(1, 2 ** 32 - 1)))
 
         params = {"param": {}}
 

hyperopt/criteria.py

@@ -19,7 +19,7 @@ def EI_gaussian_empirical(mean, var, thresh, rng, N):
 
     (estimated empirically)
     """
-    return EI_empirical(rng.randn(N) * np.sqrt(var) + mean, thresh)
+    return EI_empirical(rng.standard_normal(N) * np.sqrt(var) + mean, thresh)
 
 
 def EI_gaussian(mean, var, thresh):

hyperopt/fmin.py

@@ -276,7 +276,7 @@ def get_n_unfinished():
                     # `new_trials`. This is the core of `run`, all the rest is just
                     # processes orchestration
                     new_trials = algo(
-                        new_ids, self.domain, trials, self.rstate.randint(2 ** 31 - 1)
+                        new_ids, self.domain, trials, self.rstate.integers(2 ** 31 - 1)
                     )
                     assert len(new_ids) >= len(new_trials)
 
@@ -441,11 +441,11 @@ def fmin(
         a trials object, then that trials object will be affected by
         side-effect of this call.
 
-    rstate : numpy.RandomState, default numpy.random or `$HYPEROPT_FMIN_SEED`
+    rstate : numpy.random.Generator, default numpy.random or `$HYPEROPT_FMIN_SEED`
         Each call to `algo` requires a seed value, which should be different
         on each call. This object is used to draw these seeds via `randint`.
         The default rstate is
-        `numpy.random.RandomState(int(env['HYPEROPT_FMIN_SEED']))`
+        `numpy.random.default_rng(int(env['HYPEROPT_FMIN_SEED']))`
         if the `HYPEROPT_FMIN_SEED` environment variable is set to a non-empty
         string, otherwise np.random is used in whatever state it is in.
 
@@ -513,9 +513,9 @@ def fmin(
     if rstate is None:
         env_rseed = os.environ.get("HYPEROPT_FMIN_SEED", "")
         if env_rseed:
-            rstate = np.random.RandomState(int(env_rseed))
+            rstate = np.random.default_rng(int(env_rseed))
         else:
-            rstate = np.random.RandomState()
+            rstate = np.random.default_rng()
 
     validate_timeout(timeout)
     validate_loss_threshold(loss_threshold)

hyperopt/ipy.py

@@ -136,7 +136,7 @@ def fmin(self, fn, space, **kw):
 
             if idles:
                 new_ids = self.new_trial_ids(len(idles))
-                new_trials = algo(new_ids, domain, self, rstate.randint(2 ** 31 - 1))
+                new_trials = algo(new_ids, domain, self, rstate.integers(2 ** 31 - 1))
                 if len(new_trials) == 0:
                     break
                 assert len(idles) >= len(new_trials)

hyperopt/mix.py

@@ -25,10 +25,10 @@ def suggest(new_ids, domain, trials, seed, p_suggest):
         sum(probabilities) must be [close to] 1.0
 
     """
-    rng = np.random.RandomState(seed)
+    rng = np.random.default_rng(seed)
     ps, suggests = list(zip(*p_suggest))
     assert len(ps) == len(suggests) == len(p_suggest)
     if not np.isclose(sum(ps), 1.0):
         raise ValueError("Probabilities should sum to 1", ps)
     idx = rng.multinomial(n=1, pvals=ps).argmax()
-    return suggests[idx](new_ids, domain, trials, seed=rng.randint(2 ** 31))
+    return suggests[idx](new_ids, domain, trials, seed=rng.integers(2 ** 31))

hyperopt/pyll/stochastic.py

@@ -24,7 +24,7 @@ def implicit_stochastic(f):
 
 @scope.define
 def rng_from_seed(seed):
-    return np.random.RandomState(seed)
+    return np.random.default_rng(seed)
 
 
 # -- UNIFORM
@@ -95,9 +95,9 @@ def qlognormal(mu, sigma, q, rng=None, size=()):
 def randint(low, high=None, rng=None, size=()):
     """
     See np.random.randint documentation.
-    rng = random number generator, typically equals np.random.mtrand.RandomState
+    rng = random number generator, typically equals np.random.Generator
     """
-    return rng.randint(low, high, size)
+    return rng.integers(low, high, size)
 
 
 @implicit_stochastic
@@ -107,7 +107,7 @@ def randint_via_categorical(p, rng=None, size=()):
     Only used in tpe because of the chaotic API based on names.
     # ideally we would just use randint above, but to use priors this is a wrapper of
     categorical
-    rng = random number generator, typically equals np.random.mtrand.RandomState
+    rng = random number generator, typically equals np.random.Generator
     """
 
     return scope.categorical(p, rng, size)
@@ -177,7 +177,7 @@ def recursive_set_rng_kwarg(expr, rng=None):
     uniform(0, 1) -> uniform(0, 1, rng=rng)
     """
     if rng is None:
-        rng = np.random.RandomState()
+        rng = np.random.default_rng()
     lrng = as_apply(rng)
     for node in dfs(expr):
         if node.name in implicit_stochastic_symbols:
@@ -195,14 +195,14 @@ def sample(expr, rng=None, **kwargs):
     Parameters:
     expr - a pyll expression to be evaluated
 
-    rng - a np.random.RandomState instance
-          default: `np.random.RandomState()`
+    rng - a np.random.Generator instance
+          default: `np.random.default_rng()`
 
     **kwargs - optional arguments passed along to
                `hyperopt.pyll.rec_eval`
 
     """
     if rng is None:
-        rng = np.random.RandomState()
+        rng = np.random.default_rng()
     foo = recursive_set_rng_kwarg(clone(as_apply(expr)), as_apply(rng))
     return rec_eval(foo, **kwargs)

hyperopt/pyll/tests/test_stochastic.py

@@ -7,7 +7,7 @@
 def test_recursive_set_rng_kwarg():
     uniform = scope.uniform
     a = as_apply([uniform(0, 1), uniform(2, 3)])
-    rng = np.random.RandomState(234)
+    rng = np.random.default_rng(234)
     recursive_set_rng_kwarg(a, rng)
     print(a)
     val_a = rec_eval(a)
@@ -46,16 +46,16 @@ def test_lnorm():
 def test_sample_deterministic():
     aa = as_apply([0, 1])
     print(aa)
-    dd = sample(aa, np.random.RandomState(3))
+    dd = sample(aa, np.random.default_rng(3))
     assert dd == (0, 1)
 
 
 def test_repeatable():
     u = scope.uniform(0, 1)
     aa = as_apply(dict(u=u, n=scope.normal(5, 0.1), l=[0, 1, scope.one_of(2, 3), u]))
-    dd1 = sample(aa, np.random.RandomState(3))
-    dd2 = sample(aa, np.random.RandomState(3))
-    dd3 = sample(aa, np.random.RandomState(4))
+    dd1 = sample(aa, np.random.default_rng(3))
+    dd2 = sample(aa, np.random.default_rng(3))
+    dd3 = sample(aa, np.random.default_rng(4))
     assert dd1 == dd2
     assert dd1 != dd3
 
@@ -64,7 +64,7 @@ def test_sample():
     u = scope.uniform(0, 1)
     aa = as_apply(dict(u=u, n=scope.normal(5, 0.1), l=[0, 1, scope.one_of(2, 3), u]))
     print(aa)
-    dd = sample(aa, np.random.RandomState(3))
+    dd = sample(aa, np.random.default_rng(3))
     assert 0 < dd["u"] < 1
     assert 4 < dd["n"] < 6
     assert dd["u"] == dd["l"][3]

hyperopt/rand.py

@@ -12,7 +12,7 @@
 
 
 def suggest(new_ids, domain, trials, seed):
-    rng = np.random.RandomState(seed)
+    rng = np.random.default_rng(seed)
     rval = []
     for ii, new_id in enumerate(new_ids):
         # -- sample new specs, idxs, vals
@@ -28,7 +28,7 @@ def suggest(new_ids, domain, trials, seed):
 
 def suggest_batch(new_ids, domain, trials, seed):
 
-    rng = np.random.RandomState(seed)
+    rng = np.random.default_rng(seed)
     # -- sample new specs, idxs, vals
     idxs, vals = pyll.rec_eval(
         domain.s_idxs_vals, memo={domain.s_new_ids: new_ids, domain.s_rng: rng}