class_docstr: K-Folds cross-validator
  
  Provides train/test indices to split data in train/test sets. Split
  dataset into k consecutive folds (without shuffling by default).
  
  Each fold is then used once as a validation while the k - 1 remaining
  folds form the training set.
  
  Parameters
  ----------
  n_splits : int, default=5
      Number of folds. Must be at least 2.
  
      .. versionchanged:: 0.22
          ``n_splits`` default value changed from 3 to 5.
  
  shuffle : bool, default=False
      Whether to shuffle the data before splitting into batches.
      Note that the samples within each split will not be shuffled.
  
  random_state : int, RandomState instance or None, default=None
      When `shuffle` is True, `random_state` affects the ordering of the
      indices, which controls the randomness of each fold. Otherwise, this
      parameter has no effect.
      Pass an int for reproducible output across multiple function calls.
      See :term:`Glossary <random_state>`.
  
  Examples
  --------
  >>> import mars.tensor as mt
  >>> from mars.learn.model_selection import KFold
  >>> X = mt.array([[1, 2], [3, 4], [1, 2], [3, 4]])
  >>> y = mt.array([1, 2, 3, 4])
  >>> kf = KFold(n_splits=2)
  >>> kf.get_n_splits(X)
  2
  >>> print(kf)
  KFold(n_splits=2, random_state=None, shuffle=False)
  >>> for train_index, test_index in kf.split(X):
  ...     print("TRAIN:", train_index, "TEST:", test_index)
  ...     X_train, X_test = X[train_index], X[test_index]
  ...     y_train, y_test = y[train_index], y[test_index]
  TRAIN: [2 3] TEST: [0 1]
  TRAIN: [0 1] TEST: [2 3]
  
  Notes
  -----
  The first ``n_samples % n_splits`` folds have size
  ``n_samples // n_splits + 1``, other folds have size
  ``n_samples // n_splits``, where ``n_samples`` is the number of samples.
  
  Randomized CV splitters may return different results for each call of
  split. You can make the results identical by setting `random_state`
  to an integer.
  
  See Also
  --------
  StratifiedKFold : Takes group information into account to avoid building
      folds with imbalanced class distributions (for binary or multiclass
      classification tasks).
  
  GroupKFold : K-fold iterator variant with non-overlapping groups.
  
  RepeatedKFold : Repeats K-Fold n times.
docstr: Generate indices to split data into training and test set.
  
  Parameters
  ----------
  X : array-like of shape (n_samples, n_features)
      Training data, where n_samples is the number of samples
      and n_features is the number of features.
  
  y : array-like of shape (n_samples,), default=None
      The target variable for supervised learning problems.
  
  groups : array-like of shape (n_samples,), default=None
      Group labels for the samples used while splitting the dataset into
      train/test set.
  
  Yields
  ------
  train : ndarray
      The training set indices for that split.
  
  test : ndarray
      The testing set indices for that split.
docstr_tok: ["Generate","indices","to","split","data","into","training","and","test","set",".","Parameters","--","--","--","--","--","X",":","array-like","of","shape","(","n_samples",",","n_features",")","Training","data",",","where","n_samples","is","the","number","of","samples","and","n_features","is","the","number","of","features",".","y",":","array-like","of","shape","(","n_samples",",",")",",","default=None","The","target","variable","for","supervised","learning","problems",".","groups",":","array-like","of","shape","(","n_samples",",",")",",","default=None","Group","labels","for","the","samples","used","while","splitting","the","dataset","into","train\/test","set",".","Yields","--","--","--","train",":","ndarray","The","training","set","indices","for","that","split",".","test",":","ndarray","The","testing","set","indices","for","that","split","."]
code: def split(self, X, y=None, groups=None):
      """Generate indices to split data into training and test set.
  
      Parameters
      ----------
      X : array-like of shape (n_samples, n_features)
          Training data, where n_samples is the number of samples
          and n_features is the number of features.
  
      y : array-like of shape (n_samples,), default=None
          The target variable for supervised learning problems.
  
      groups : array-like of shape (n_samples,), default=None
          Group labels for the samples used while splitting the dataset into
          train/test set.
  
      Yields
      ------
      train : ndarray
          The training set indices for that split.
  
      test : ndarray
          The testing set indices for that split.
      """
      X, y, groups = indexable(X, y, groups)
      n_samples = _num_samples(X)
      if self.n_splits > n_samples:
          raise ValueError(
              (
                  "Cannot have number of splits n_splits={0} greater"
                  " than the number of samples: n_samples={1}."
              ).format(self.n_splits, n_samples)
          )
  
      indices = mt.arange(n_samples)
      if self.shuffle:
          check_random_state(self.random_state).shuffle(indices)
  
      n_splits = self.n_splits
      fold_sizes = np.full(n_splits, n_samples // n_splits, dtype=int)
      fold_sizes[: n_samples % n_splits] += 1
      current = 0
      for fold_size in fold_sizes:
          start, stop = current, current + fold_size
          train_index = mt.concatenate(
              [indices[:start], indices[stop:]]
          )
          yield train_index, indices[start:stop]
          current = stop
  
imports: import numbers
  from abc import ABCMeta, abstractmethod
  from itertools import chain
  from math import ceil, floor
  import numpy
  from ...core import ExecutableTuple
  from ...None import tensor
  from ...tensor.utils import check_random_state
  from ..utils import shuffle
  from ..utils.validation import indexable, _num_samples
label_desc: Use image node_id 2 for calling the KFold obj's underlying member method code with example usage: obj.split(X, y, groups) without return types