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.
code: def __init__(self, n_splits=5, *, shuffle=False, random_state=None):
      super().__init__(
          n_splits=n_splits, shuffle=shuffle, random_state=random_state
      )
  
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 1 to create a new KFold object from inherited base classes: _BaseKFold with example: obj = KFold(n_splits)