if ParamSampler is used with all lists, instantiate grid and sample from it.

amueller · amueller · commit 133f3fd0b5ab · 2014-12-17T11:38:14.000-05:00
diff --git a/sklearn/grid_search.py b/sklearn/grid_search.py
@@ -169,30 +169,38 @@ def __iter__(self):
         # in this case we want to sample without replacement
         all_lists = np.all([not hasattr(v, "rvs")
                             for v in self.param_distributions.values()])
+        rnd = check_random_state(self.random_state)
+
         if all_lists:
-            # size of complete grid
-            grid_size = np.prod([len(v) for v in self.param_distributions.values()])
+            param_grid = list(ParameterGrid(self.param_distributions))
+            grid_size = len(param_grid)
+
+        if all_lists and self.n_iter > 0.1 * grid_size:
+            # get complete grid and yield from it
             if grid_size < self.n_iter:
                 raise ValueError("The total space of parameters %d is smaller than n_iter=%d. "
                                  % (grid_size, self.n_iter)
                                  + "For exhaustive searches, use GridSearchCV.")
-        rnd = check_random_state(self.random_state)
-        # Always sort the keys of a dictionary, for reproducibility
-        items = sorted(self.param_distributions.items())
-        while len(samples) < self.n_iter:
-            params = dict()
-            for k, v in items:
-                if hasattr(v, "rvs"):
-                    params[k] = v.rvs()
-                else:
-                    params[k] = v[rnd.randint(len(v))]
-            if all_lists and params in samples:
-                # do sampling without replacement only if all_lists
-                # otherwise distributions with finite support might
-                # cause infinite loops
-                continue
-            samples.append(params)
-            yield params
+            for i in rnd.permutation(grid_size)[:self.n_iter]:
+                yield param_grid[i]
+
+        else:
+            # Always sort the keys of a dictionary, for reproducibility
+            items = sorted(self.param_distributions.items())
+            while len(samples) < self.n_iter:
+                params = dict()
+                for k, v in items:
+                    if hasattr(v, "rvs"):
+                        params[k] = v.rvs()
+                    else:
+                        params[k] = v[rnd.randint(len(v))]
+                if all_lists and params in samples:
+                    # do sampling without replacement only if all_lists
+                    # otherwise distributions with finite support might
+                    # cause infinite loops
+                    continue
+                samples.append(params)
+                yield params
 
     def __len__(self):
         """Number of points that will be sampled."""
@@ -266,7 +274,7 @@ def _check_param_grid(param_grid):
                 raise ValueError("Parameter array should be one-dimensional.")
 
             check = [isinstance(v, k) for k in (list, tuple, np.ndarray)]
-            if not True in check:
+            if True not in check:
                 raise ValueError("Parameter values should be a list.")
 
             if len(v) == 0:
diff --git a/sklearn/tests/test_grid_search.py b/sklearn/tests/test_grid_search.py
@@ -741,6 +741,14 @@ def test_parameters_sampler_replacement():
     for values in ParameterGrid(params):
         assert_true(values in samples)
 
+    # test sampling without replacement in a large grid
+    params = {'a': range(10), 'b': range(10), 'c': range(10)}
+    sampler = ParameterSampler(params, n_iter=99, random_state=42)
+    samples = list(sampler)
+    assert_equal(len(samples), 99)
+    hashable_samples = ["a%db%dc%d" % (p['a'], p['b'], p['c']) for p in samples]
+    assert_equal(len(set(hashable_samples)), 99)
+
     # doesn't go into infinite loops
     params_distribution = {'first': bernoulli(.5), 'second': ['a', 'b', 'c']}
     sampler = ParameterSampler(params_distribution, n_iter=7)
