ENH use random states everywhere, never call np.random.

Author: amueller

sklearn/cluster/tests/test_hierarchical.py

@@ -17,9 +17,9 @@ def test_structured_ward_tree():
     """
     Check that we obtain the correct solution for structured ward tree.
     """
-    np.random.seed(0)
+    rnd = np.random.RandomState(0)
     mask = np.ones([10, 10], dtype=np.bool)
-    X = np.random.randn(50, 100)
+    X = rnd.randn(50, 100)
     connectivity = grid_to_graph(*mask.shape)
     children, n_components, n_leaves = ward_tree(X.T, connectivity)
     n_nodes = 2 * X.shape[1] - 1
@@ -30,8 +30,8 @@ def test_unstructured_ward_tree():
     """
     Check that we obtain the correct solution for unstructured ward tree.
     """
-    np.random.seed(0)
-    X = np.random.randn(50, 100)
+    rnd = np.random.RandomState(0)
+    X = rnd.randn(50, 100)
     children, n_nodes, n_leaves = ward_tree(X.T)
     n_nodes = 2 * X.shape[1] - 1
     assert_true(len(children) + n_leaves == n_nodes)
@@ -41,9 +41,9 @@ def test_height_ward_tree():
     """
     Check that the height of ward tree is sorted.
     """
-    np.random.seed(0)
+    rnd = np.random.RandomState(0)
     mask = np.ones([10, 10], dtype=np.bool)
-    X = np.random.randn(50, 100)
+    X = rnd.randn(50, 100)
     connectivity = grid_to_graph(*mask.shape)
     children, n_nodes, n_leaves = ward_tree(X.T, connectivity)
     n_nodes = 2 * X.shape[1] - 1
@@ -54,9 +54,9 @@ def test_ward_clustering():
     """
     Check that we obtain the correct number of clusters with Ward clustering.
     """
-    np.random.seed(0)
+    rnd = np.random.RandomState(0)
     mask = np.ones([10, 10], dtype=np.bool)
-    X = np.random.randn(100, 50)
+    X = rnd.randn(100, 50)
     connectivity = grid_to_graph(*mask.shape)
     clustering = Ward(n_clusters=10, connectivity=connectivity)
     clustering.fit(X)
@@ -67,9 +67,9 @@ def test_ward_agglomeration():
     """
     Check that we obtain the correct solution in a simplistic case
     """
-    np.random.seed(0)
+    rnd = np.random.RandomState(0)
     mask = np.ones([10, 10], dtype=np.bool)
-    X = np.random.randn(50, 100)
+    X = rnd.randn(50, 100)
     connectivity = grid_to_graph(*mask.shape)
     ward = WardAgglomeration(n_clusters=5, connectivity=connectivity)
     ward.fit(X)
@@ -98,10 +98,11 @@ def test_scikit_vs_scipy():
     """
     from scipy.sparse import lil_matrix
     n, p, k = 10, 5, 3
+    rnd = np.random.RandomState(0)
 
     connectivity = lil_matrix(np.ones((n, n)))
     for i in range(5):
-        X = .1 * np.random.normal(size=(n, p))
+        X = .1 * rnd.normal(size=(n, p))
         X -= 4 * np.arange(n)[:, np.newaxis]
         X -= X.mean(axis=1)[:, np.newaxis]
 

sklearn/cluster/tests/test_k_means.py

@@ -43,7 +43,8 @@ def test_square_norms():
 
 
 def test_kmeans_dtype():
-    X = np.random.normal(size=(40, 2))
+    rnd = np.random.RandomState(0)
+    X = rnd.normal(size=(40, 2))
     X = (X * 10).astype(np.uint8)
     km = KMeans(n_init=1).fit(X)
     with warnings.catch_warnings(record=True) as w:

sklearn/covariance/tests/test_robust_covariance.py

@@ -72,8 +72,8 @@ def test_outlier_detection():
     """
 
     """
-    np.random.RandomState(0)
-    X = np.random.randn(100, 10)
+    rnd = np.random.RandomState(0)
+    X = rnd.randn(100, 10)
     clf = EllipticEnvelope(contamination=0.1)
     clf.fit(X)
     y_pred = clf.predict(X)

sklearn/decomposition/tests/test_fastica.py

@@ -51,7 +51,7 @@ def test_fastica(add_noise=False):
     """ Test the FastICA algorithm on very simple data.
     """
     # scipy.stats uses the global RNG:
-    np.random.seed(0)
+    rng = np.random.RandomState(0)
     n_samples = 1000
     # Generate two sources:
     s1 = (2 * np.sin(np.linspace(0, 100, n_samples)) > 0) - 1
@@ -67,7 +67,7 @@ def test_fastica(add_noise=False):
     m = np.dot(mixing, s)
 
     if add_noise:
-        m += 0.1 * np.random.randn(2, 1000)
+        m += 0.1 * rng.randn(2, 1000)
 
     center_and_norm(m)
 

sklearn/ensemble/tests/test_forest.py

@@ -30,15 +30,15 @@
 # also load the iris dataset
 # and randomly permute it
 iris = datasets.load_iris()
-np.random.seed([1])
-perm = np.random.permutation(iris.target.size)
+rng = np.random.RandomState(0)
+perm = rng.permutation(iris.target.size)
 iris.data = iris.data[perm]
 iris.target = iris.target[perm]
 
 # also load the boston dataset
 # and randomly permute it
 boston = datasets.load_boston()
-perm = np.random.permutation(boston.target.size)
+perm = rng.permutation(boston.target.size)
 boston.data = boston.data[perm]
 boston.target = boston.target[perm]
 

sklearn/ensemble/tests/test_gradient_boosting.py

@@ -20,17 +20,18 @@
 T = [[-1, -1], [2, 2], [3, 2]]
 true_result = [-1, 1, 1]
 
+rng = np.random.RandomState(0)
 # also load the boston dataset
 # and randomly permute it
 boston = datasets.load_boston()
-perm = np.random.permutation(boston.target.size)
+perm = rng.permutation(boston.target.size)
 boston.data = boston.data[perm]
 boston.target = boston.target[perm]
 
 # also load the iris dataset
 # and randomly permute it
 iris = datasets.load_iris()
-perm = np.random.permutation(iris.target.size)
+perm = rng.permutation(iris.target.size)
 iris.data = iris.data[perm]
 iris.target = iris.target[perm]
 
@@ -248,7 +249,7 @@ def test_check_inputs_predict():
     assert_raises(ValueError, clf.predict, x)
 
     clf = GradientBoostingRegressor(n_estimators=100, random_state=1)
-    clf.fit(X, np.random.rand(len(X)))
+    clf.fit(X, rng.rand(len(X)))
 
     x = np.array([1.0, 2.0])[:, np.newaxis]
     assert_raises(ValueError, clf.predict, x)
@@ -312,6 +313,6 @@ def test_degenerate_targets():
 
     clf = GradientBoostingRegressor(n_estimators=100, random_state=1)
     clf.fit(X, np.ones(len(X)))
-    clf.predict(np.random.rand(2))
+    clf.predict(rng.rand(2))
     assert_array_equal(np.ones((1,), dtype=np.float64),
-                       clf.predict(np.random.rand(2)))
+                       clf.predict(rng.rand(2)))

sklearn/feature_selection/tests/test_feature_select.py

@@ -19,8 +19,9 @@
 
 def test_f_oneway_vs_scipy_stats():
     """Test that our f_oneway gives the same result as scipy.stats"""
-    X1 = np.random.randn(10, 3)
-    X2 = 1 + np.random.randn(10, 3)
+    rng = np.random.RandomState(0)
+    X1 = rng.randn(10, 3)
+    X2 = 1 + rng.randn(10, 3)
     f, pv = stats.f_oneway(X1, X2)
     f2, pv2 = f_oneway(X1, X2)
     assert_true(np.allclose(f, f2))
@@ -67,8 +68,8 @@ def test_f_regression_input_dtype():
     Test whether f_regression returns the same value
     for any numeric data_type
     """
-
-    X = np.random.rand(10, 20)
+    rng = np.random.RandomState(0)
+    X = rng.rand(10, 20)
     y = np.arange(10).astype(np.int)
 
     F1, pv1 = f_regression(X, y)

sklearn/hmm.py

@@ -135,7 +135,7 @@ def __init__(self, n_components=1, startprob=None, transmat=None,
             self._algorithm = algorithm
         else:
             self._algorithm = "viterbi"
-        self.random_state = random_state
+        self.random_state = check_random_state(random_state)
 
     def eval(self, obs):
         """Compute the log probability under the model and compute posteriors
@@ -900,8 +900,8 @@ def _init(self, obs, params='ste'):
         super(MultinomialHMM, self)._init(obs, params=params)
 
         if 'e' in params:
-            emissionprob = normalize(np.random.rand(self.n_components,
-                                                    self.n_symbols), 1)
+            emissionprob = normalize(self.random_state.rand(self.n_components,
+                self.n_symbols), 1)
             self.emissionprob_ = emissionprob
 
     def _initialize_sufficient_statistics(self):

sklearn/linear_model/tests/test_logistic.py

@@ -77,7 +77,8 @@ def test_predict_iris():
 
 def test_inconsistent_input():
     """Test that an exception is raised on inconsistent input"""
-    X_ = np.random.random((5, 10))
+    rng = np.random.RandomState(0)
+    X_ = rng.random_sample((5, 10))
     y_ = np.ones(X_.shape[0])
 
     clf = logistic.LogisticRegression()
@@ -87,9 +88,8 @@ def test_inconsistent_input():
     assert_raises(ValueError, clf.fit, X, y_wrong)
 
     # Wrong dimensions for test data
-    assert_raises(ValueError,
-                  clf.fit(X_, y_).predict,
-                  np.random.random((3, 12)))
+    assert_raises(ValueError, clf.fit(X_, y_).predict,
+            rng.random_sample((3, 12)))
 
 
 @raises(ValueError)

sklearn/linear_model/tests/test_ridge.py

@@ -17,11 +17,11 @@
 
 from sklearn.cross_validation import KFold
 
+rng = np.random.RandomState(0)
 diabetes = datasets.load_diabetes()
-
 X_diabetes, y_diabetes = diabetes.data, diabetes.target
 ind = np.arange(X_diabetes.shape[0])
-np.random.shuffle(ind)
+rng.shuffle(ind)
 ind = ind[:200]
 X_diabetes, y_diabetes = X_diabetes[ind], y_diabetes[ind]
 
@@ -30,8 +30,6 @@
 X_iris = sp.csr_matrix(iris.data)
 y_iris = iris.target
 
-np.random.seed(0)
-
 DENSE_FILTER = lambda X: X
 SPARSE_FILTER = lambda X: sp.csr_matrix(X)
 
@@ -46,8 +44,8 @@ def test_ridge():
 
     # With more samples than features
     n_samples, n_features = 6, 5
-    y = np.random.randn(n_samples)
-    X = np.random.randn(n_samples, n_features)
+    y = rng.randn(n_samples)
+    X = rng.randn(n_samples, n_features)
 
     ridge = Ridge(alpha=alpha)
     ridge.fit(X, y)
@@ -59,8 +57,8 @@ def test_ridge():
 
     # With more features than samples
     n_samples, n_features = 5, 10
-    y = np.random.randn(n_samples)
-    X = np.random.randn(n_samples, n_features)
+    y = rng.randn(n_samples)
+    X = rng.randn(n_samples, n_features)
     ridge = Ridge(alpha=alpha)
     ridge.fit(X, y)
     assert_greater(ridge.score(X, y), .9)
@@ -73,8 +71,8 @@ def test_ridge_shapes():
     """Test shape of coef_ and intercept_
     """
     n_samples, n_features = 5, 10
-    X = np.random.randn(n_samples, n_features)
-    y = np.random.randn(n_samples)
+    X = rng.randn(n_samples, n_features)
+    y = rng.randn(n_samples)
     Y1 = y[:, np.newaxis]
     Y = np.c_[y, 1 + y]
 
@@ -97,8 +95,8 @@ def test_ridge_intercept():
     """Test intercept with multiple targets GH issue #708
     """
     n_samples, n_features = 5, 10
-    X = np.random.randn(n_samples, n_features)
-    y = np.random.randn(n_samples)
+    X = rng.randn(n_samples, n_features)
+    y = rng.randn(n_samples)
     Y = np.c_[y, 1. + y]
 
     ridge = Ridge()
@@ -140,9 +138,8 @@ def test_ridge_vs_lstsq():
 
     # we need more samples than features
     n_samples, n_features = 5, 4
-    np.random.seed(0)
-    y = np.random.randn(n_samples)
-    X = np.random.randn(n_samples, n_features)
+    y = rng.randn(n_samples)
+    X = rng.randn(n_samples, n_features)
 
     ridge = Ridge(alpha=0., fit_intercept=False)
     ols = LinearRegression(fit_intercept=False)