scikit-learn
diff --git a/‎sklearn/model_selection/_split.py
Lines changed: 14 additions & 14 deletions b/‎sklearn/model_selection/_split.py
Lines changed: 14 additions & 14 deletions
diff --git a/‎sklearn/utils/validation.py
Lines changed: 2 additions & 0 deletions b/‎sklearn/utils/validation.py
Lines changed: 2 additions & 0 deletions
@@ -17,14 +17,14 @@
 from itertools import chain, combinations
 from collections import Iterable
 from math import ceil, floor
-import numbers
 from abc import ABCMeta, abstractmethod
 
 import numpy as np
 
 from ..utils import indexable, check_random_state, safe_indexing
 from ..utils.validation import _num_samples, column_or_1d
 from ..utils.validation import check_array
+from ..utils.validation import integer_types, floating_types
 from ..utils.multiclass import type_of_target
 from ..externals.six import with_metaclass
 from ..externals.six.moves import zip
@@ -271,7 +271,7 @@ class _BaseKFold(with_metaclass(ABCMeta, BaseCrossValidator)):
 
     @abstractmethod
     def __init__(self, n_splits, shuffle, random_state):
-        if not isinstance(n_splits, (numbers.Integral, np.integer)):
+        if not isinstance(n_splits, integer_types):
             raise ValueError('The number of folds must be of Integral type. '
                              '%s of type %s was passed.'
                              % (n_splits, type(n_splits)))
@@ -989,7 +989,7 @@ class _RepeatedSplits(with_metaclass(ABCMeta)):
         and shuffle.
     """
     def __init__(self, cv, n_repeats=10, random_state=None, **cvargs):
-        if not isinstance(n_repeats, (np.integer, numbers.Integral)):
+        if not isinstance(n_repeats, integer_types):
             raise ValueError("Number of repetitions must be of Integral type.")
 
         if n_repeats <= 0:
@@ -1643,27 +1643,27 @@ def _validate_shuffle_split_init(test_size, train_size):
         raise ValueError('test_size and train_size can not both be None')
 
     if test_size is not None:
-        if isinstance(test_size, (float, np.floating)):
+        if isinstance(test_size, floating_types):
             if test_size >= 1.:
                 raise ValueError(
                     'test_size=%f should be smaller '
                     'than 1.0 or be an integer' % test_size)
-        elif not isinstance(test_size, (numbers.Integral, np.integer)):
+        elif not isinstance(test_size, integer_types):
             # int values are checked during split based on the input
             raise ValueError("Invalid value for test_size: %r" % test_size)
 
     if train_size is not None:
-        if isinstance(train_size, (float, np.floating)):
+        if isinstance(train_size, floating_types):
             if train_size >= 1.:
                 raise ValueError("train_size=%f should be smaller "
                                  "than 1.0 or be an integer" % train_size)
-            elif (isinstance(test_size, (float, np.floating)) and
+            elif (isinstance(test_size, floating_types) and
                     (train_size + test_size) > 1.):
                 raise ValueError('The sum of test_size and train_size = %f, '
                                  'should be smaller than 1.0. Reduce '
                                  'test_size and/or train_size.' %
                                  (train_size + test_size))
-        elif not isinstance(train_size, (numbers.Integral, np.integer)):
+        elif not isinstance(train_size, integer_types):
             # int values are checked during split based on the input
             raise ValueError("Invalid value for train_size: %r" % train_size)
 
@@ -1676,28 +1676,28 @@ def _validate_shuffle_split(n_samples, test_size, train_size):
     test_size, defaults to 0.1
     """
     if (test_size is not None and
-            isinstance(test_size, (numbers.Integral, np.integer)) and
+            isinstance(test_size, integer_types) and
             test_size >= n_samples):
         raise ValueError('test_size=%d should be smaller than the number of '
                          'samples %d' % (test_size, n_samples))
 
     if (train_size is not None and
-            isinstance(train_size, (numbers.Integral, np.integer)) and
+            isinstance(train_size, integer_types) and
             train_size >= n_samples):
         raise ValueError("train_size=%d should be smaller than the number of"
                          " samples %d" % (train_size, n_samples))
 
     if test_size == "default":
         test_size = 0.1
 
-    if isinstance(test_size, (float, np.floating)):
+    if isinstance(test_size, floating_types):
         n_test = ceil(test_size * n_samples)
-    elif isinstance(test_size, (numbers.Integral, np.integer)):
+    elif isinstance(test_size, integer_types):
         n_test = float(test_size)
 
     if train_size is None:
         n_train = n_samples - n_test
-    elif isinstance(train_size, (float, np.floating)):
+    elif isinstance(train_size, floating_types):
         n_train = floor(train_size * n_samples)
     else:
         n_train = float(train_size)
@@ -1902,7 +1902,7 @@ def check_cv(cv=3, y=None, classifier=False):
     if cv is None:
         cv = 3
 
-    if isinstance(cv, (numbers.Integral, np.integer)):
+    if isinstance(cv, integer_types):
         if (classifier and (y is not None) and
                 (type_of_target(y) in ('binary', 'multiclass'))):
             return StratifiedKFold(cv)
 
@@ -24,6 +24,8 @@
 from ..externals.joblib import Memory
 
 
+integer_types = (numbers.Integral, np.integer)
+floating_types = (float, np.floating)
 FLOAT_DTYPES = (np.float64, np.float32, np.float16)
 
 # Silenced by default to reduce verbosity. Turn on at runtime for