lits will be the same across calls.

    Refer :ref:`User Guide <cross_validation>` for the various
    cross-validation strategies that can be used here.

    .. versionchanged:: 0.22
        ``cv`` default value if None changed from 3-fold to 5-fold.

n_jobs : int, default=None
    Number of jobs to run in parallel. Training the estimator and computing
    the score are parallelized over the cross-validation splits.
    ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
    ``-1`` means using all processors. See :term:`Glossary <n_jobs>`
    for more details.

verbose : int, default=0
    The verbosity level.

params : dict, default=None
    Parameters to pass to the underlying estimator's ``fit``, the scorer,
    and the CV splitter.

    .. versionadded:: 1.4

pre_dispatch : int or str, default='2*n_jobs'
    Controls the number of jobs that get dispatched during parallel
    execution. Reducing this number can be useful to avoid an
    explosion of memory consumption when more jobs get dispatched
    than CPUs can process. This parameter can be:

    - An int, giving the exact number of total jobs that are spawned
    - A str, giving an expression as a function of n_jobs, as in '2*n_jobs'

return_train_score : bool, default=False
    Whether to include train scores.
    Computing training scores is used to get insights on how different
    parameter settings impact the overfitting/underfitting trade-off.
    However computing the scores on the training set can be computationally
    expensive and is not strictly required to select the parameters that
    yield the best generalization performance.

    .. versionadded:: 0.19

    .. versionchanged:: 0.21
        Default value was changed from ``True`` to ``False``

return_estimator : bool, default=False
    Whether to return the estimators fitted on each split.

    .. versionadded:: 0.20

return_indices : bool, default=False
    Whether to return the train-test indices selected for each split.

    .. versionadded:: 1.3

error_score : 'raise' or numeric, default=np.nan
    Value to assign to the score if an error occurs in estimator fitting.
    If set to 'raise', the error is raised.
    If a numeric value is given, FitFailedWarning is raised.

    .. versionadded:: 0.20

Returns
-------
scores : dict of float arrays of shape (n_splits,)
    Array of scores of the estimator for each run of the cross validation.

    A dict of arrays containing the score/time arrays for each scorer is
    returned. The possible keys for this ``dict`` are:

    ``test_score``
        The score array for test scores on each cv split.
        Suffix ``_score`` in ``test_score`` changes to a specific
        metric like ``test_r2`` or ``test_auc`` if there are
        multiple scoring metrics in the scoring parameter.
    ``train_score``
        The score array for train scores on each cv split.
        Suffix ``_score`` in ``train_score`` changes to a specific
        metric like ``train_r2`` or ``train_auc`` if there are
        multiple scoring metrics in the scoring parameter.
        This is available only if ``return_train_score`` parameter
        is ``True``.
    ``fit_time``
        The time for fitting the estimator on the train
        set for each cv split.
    ``score_time``
        The time for scoring the estimator on the test set for each
        cv split. (Note time for scoring on the train set is not
        included even if ``return_train_score`` is set to ``True``
    ``estimator``
        The estimator objects for each cv split.
        This is available only if ``return_estimator`` parameter
        is set to ``True``.
    ``indices``
        The train/test positional indices for each cv split. A dictionary
        is returned where the keys are either `"train"` or `"test"`
        and the associated values are a list of integer-dtyped NumPy
        arrays with the indices. Available only if `return_indices=True`.

See Also
--------
cross_val_score : Run cross-validation for single metric evaluation.

cross_val_predict : Get predictions from each split of cross-validation for
    diagnostic purposes.

sklearn.metrics.make_scorer : Make a scorer from a performance metric or
    loss function.

Examples
--------
>>> from sklearn import datasets, linear_model
>>> from sklearn.model_selection import cross_validate
>>> from sklearn.metrics import make_scorer
>>> from sklearn.metrics import confusion_matrix
>>> from sklearn.svm import LinearSVC
>>> diabetes = datasets.load_diabetes()
>>> X = diabetes.data[:150]
>>> y = diabetes.target[:150]
>>> lasso = linear_model.Lasso()

Single metric evaluation using ``cross_validate``

>>> cv_results = cross_validate(lasso, X, y, cv=3)
>>> sorted(cv_results.keys())
['fit_time', 'score_time', 'test_score']
>>> cv_results['test_score']
array([0.3315057 , 0.08022103, 0.03531816])

Multiple metric evaluation using ``cross_validate``
(please refer the ``scoring`` parameter doc for more information)

>>> scores = cross_validate(lasso, X, y, cv=3,
...                         scoring=('r2', 'neg_mean_squared_error'),
...                         return_train_score=True)
>>> print(scores['test_neg_mean_squared_error'])
[-3635.5... -3573.3... -6114.7...]
>>> print(scores['train_r2'])
[0.28009951 0.3908844  0.22784907]
NŠ