ENH allow y to be a list in GridSearchCV, cross_val_score and train_test_split.

Author: amueller

sklearn/cross_validation.py

@@ -22,7 +22,7 @@
 import scipy.sparse as sp
 
 from .base import is_classifier, clone
-from .utils import check_arrays, check_random_state, safe_mask
+from .utils import check_arrays, check_random_state, safe_indexing
 from .utils.validation import _num_samples
 from .externals.joblib import Parallel, delayed, logger
 from .externals.six import with_metaclass
@@ -1136,8 +1136,6 @@ def cross_val_score(estimator, X, y=None, scoring=None, cv=None, n_jobs=1,
     """
     X, y = check_arrays(X, y, sparse_format='csr', allow_lists=True,
                         allow_nans=True, allow_nd=True)
-    if y is not None:
-        y = np.asarray(y)
 
     cv = _check_cv(cv, X, y, classifier=is_classifier(estimator))
     scorer = check_scoring(estimator, score_func=score_func, scoring=scoring)
@@ -1278,10 +1276,10 @@ def _safe_split(estimator, X, y, indices, train_indices=None):
             else:
                 X_subset = X[np.ix_(indices, train_indices)]
         else:
-            X_subset = X[safe_mask(X, indices)]
+            X_subset = safe_indexing(X, indices)
 
     if y is not None:
-        y_subset = y[safe_mask(y, indices)]
+        y_subset = safe_indexing(y, indices)
     else:
         y_subset = None
 
@@ -1527,12 +1525,12 @@ def train_test_split(*arrays, **options):
            [0, 1],
            [6, 7]])
     >>> b_train
-    array([2, 0, 3])
+    [2, 0, 3]
     >>> a_test
     array([[2, 3],
            [8, 9]])
     >>> b_test
-    array([1, 4])
+    [1, 4]
 
     """
     n_arrays = len(arrays)
@@ -1544,18 +1542,21 @@ def train_test_split(*arrays, **options):
     random_state = options.pop('random_state', None)
     options['sparse_format'] = 'csr'
     options['allow_nans'] = True
+    if not "allow_lists" in options:
+        options["allow_lists"] = True
 
     if test_size is None and train_size is None:
         test_size = 0.25
 
     arrays = check_arrays(*arrays, **options)
-    n_samples = arrays[0].shape[0]
+    n_samples = _num_samples(arrays[0])
     cv = ShuffleSplit(n_samples, test_size=test_size,
                       train_size=train_size,
                       random_state=random_state)
 
     train, test = next(iter(cv))
-    return list(chain.from_iterable((a[train], a[test]) for a in arrays))
+    return list(chain.from_iterable((safe_indexing(a, train),
+                                     safe_indexing(a, test)) for a in arrays))
 
 
 train_test_split.__test__ = False  # to avoid a pb with nosetests

sklearn/grid_search.py

@@ -355,7 +355,6 @@ def _fit(self, X, y, parameter_iterable):
                 raise ValueError('Target variable (y) has a different number '
                                  'of samples (%i) than data (X: %i samples)'
                                  % (len(y), n_samples))
-            y = np.asarray(y)
         cv = check_cv(cv, X, y, classifier=is_classifier(estimator))
 
         if self.verbose > 0:

sklearn/tests/test_cross_validation.py

@@ -42,14 +42,20 @@
 class MockListClassifier(BaseEstimator):
     """Dummy classifier to test the cross-validation.
 
-    Checks that GridSearchCV didn't convert X to array.
+    Checks that GridSearchCV didn't convert X or Y to array.
     """
-    def __init__(self, foo_param=0):
+    def __init__(self, foo_param=0, check_y=False, check_X=True):
         self.foo_param = foo_param
+        self.check_y = check_y
+        self.check_X = check_X
 
     def fit(self, X, Y):
         assert_true(len(X) == len(Y))
-        assert_true(isinstance(X, list))
+        if self.check_X:
+            assert_true(isinstance(X, list))
+        if self.check_y:
+            assert_true(isinstance(Y, list))
+
         return self
 
     def predict(self, T):
@@ -513,6 +519,9 @@ def test_cross_val_score():
     clf = MockListClassifier()
     scores = cval.cross_val_score(clf, X.tolist(), y.tolist())
 
+    clf = MockListClassifier(check_X=False, check_y=True)
+    scores = cval.cross_val_score(clf, X, y.tolist())
+
     assert_raises(ValueError, cval.cross_val_score, clf, X, y,
                   scoring="sklearn")
 
@@ -596,7 +605,7 @@ def test_train_test_split():
     X = np.arange(100).reshape((10, 10))
     X_s = coo_matrix(X)
     y = range(10)
-    split = cval.train_test_split(X, X_s, y)
+    split = cval.train_test_split(X, X_s, y, allow_lists=False)
     X_train, X_test, X_s_train, X_s_test, y_train, y_test = split
     assert_array_equal(X_train, X_s_train.toarray())
     assert_array_equal(X_test, X_s_test.toarray())
@@ -606,6 +615,11 @@ def test_train_test_split():
     X_train, X_test, y_train, y_test = split
     assert_equal(len(y_test), len(y_train))
 
+    split = cval.train_test_split(X, X_s, y)
+    X_train, X_test, X_s_train, X_s_test, y_train, y_test = split
+    assert_true(isinstance(y_train, list))
+    assert_true(isinstance(y_test, list))
+
 
 def test_cross_val_score_with_score_func_classification():
     iris = load_iris()
@@ -911,7 +925,7 @@ def test_train_test_split_allow_nans():
     X = np.arange(200, dtype=np.float64).reshape(10, -1)
     X[2, :] = np.nan
     y = np.repeat([0, 1], X.shape[0]/2)
-    split = cval.train_test_split(X, y, test_size=0.2, random_state=42)
+    cval.train_test_split(X, y, test_size=0.2, random_state=42)
 
 
 def test_permutation_test_score_allow_nans():

sklearn/tests/test_grid_search.py

@@ -79,14 +79,20 @@ def set_params(self, **params):
 class MockListClassifier(object):
     """Dummy classifier to test the cross-validation.
 
-    Checks that GridSearchCV didn't convert X to array.
+    Checks that GridSearchCV didn't convert X (or y) to array.
     """
-    def __init__(self, foo_param=0):
+    def __init__(self, foo_param=0, check_y=False, check_X=True):
         self.foo_param = foo_param
+        self.check_y = check_y
+        self.check_X = check_X
 
     def fit(self, X, Y):
         assert_true(len(X) == len(Y))
-        assert_true(isinstance(X, list))
+        if self.check_X:
+            assert_true(isinstance(X, list))
+        if self.check_y:
+            assert_true(isinstance(Y, list))
+
         return self
 
     def predict(self, T):
@@ -100,10 +106,15 @@ def score(self, X=None, Y=None):
         return score
 
     def get_params(self, deep=False):
-        return {'foo_param': self.foo_param}
+        return {'foo_param': self.foo_param, 'check_X': self.check_X,
+                'check_y': self.check_y}
 
     def set_params(self, **params):
         self.foo_param = params['foo_param']
+        if "check_y" in params:
+            self.check_y = params["check_y"]
+        if "check_X" in params:
+            self.check_X = params["check_X"]
         return self
 
 
@@ -478,6 +489,18 @@ def test_X_as_list():
     assert_true(hasattr(grid_search, "grid_scores_"))
 
 
+def test_y_as_list():
+    """Pass y as list in GridSearchCV"""
+    X = np.arange(100).reshape(10, 10)
+    y = np.array([0] * 5 + [1] * 5)
+
+    clf = MockListClassifier(check_X=False, check_y=True)
+    cv = KFold(n=len(X), n_folds=3)
+    grid_search = GridSearchCV(clf, {'foo_param': [1, 2, 3]}, cv=cv)
+    grid_search.fit(X, y.tolist()).score(X, y)
+    assert_true(hasattr(grid_search, "grid_scores_"))
+
+
 def test_unsupervised_grid_search():
     # test grid-search with unsupervised estimator
     X, y = make_blobs(random_state=0)

sklearn/utils/__init__.py

@@ -18,8 +18,12 @@
 
 __all__ = ["murmurhash3_32", "as_float_array", "check_arrays", "safe_asarray",
            "assert_all_finite", "array2d", "atleast2d_or_csc",
-           "atleast2d_or_csr", "warn_if_not_float", "check_random_state",
-           "compute_class_weight", "minimum_spanning_tree", "column_or_1d"]
+           "atleast2d_or_csr",
+           "warn_if_not_float",
+           "check_random_state",
+           "compute_class_weight",
+           "minimum_spanning_tree",
+           "column_or_1d", "safe_indexing"]
 
 
 class deprecated(object):
@@ -129,6 +133,25 @@ def safe_mask(X, mask):
     return mask
 
 
+def safe_indexing(X, indices):
+    """Return items or rows from X using indices.
+
+    Allows simple indexing of lists or arrays.
+
+    Parameters
+    ----------
+    X : array-like, sparse-matrix, list.
+        Data from which to sample rows or items.
+
+    indices : array-like, list
+        Indices according to which X will be subsampled.
+    """
+    if hasattr(X, "shape"):
+        return X[indices]
+    else:
+        return [X[idx] for idx in indices]
+
+
 def resample(*arrays, **options):
     """Resample arrays or sparse matrices in a consistent way