nd the method given by the `method` parameter.

X : {array-like, sparse matrix} of shape (n_samples, n_features)
    The data to fit. Can be, for example a list, or an array at least 2d.

y : {array-like, sparse matrix} of shape (n_samples,) or (n_samples, n_outputs),             default=None
    The target variable to try to predict in the case of
    supervised learning.

groups : array-like of shape (n_samples,), default=None
    Group labels for the samples used while splitting the dataset into
    train/test set. Only used in conjunction with a "Group" :term:`cv`
    instance (e.g., :class:`GroupKFold`).

    .. versionchanged:: 1.4
        ``groups`` can only be passed if metadata routing is not enabled
        via ``sklearn.set_config(enable_metadata_routing=True)``. When routing
        is enabled, pass ``groups`` alongside other metadata via the ``params``
        argument instead. E.g.:
        ``cross_val_predict(..., params={'groups': groups})``.

cv : int, cross-validation generator or an iterable, default=None
    Determines the cross-validation splitting strategy.
    Possible inputs for cv are:

    - None, to use the default 5-fold cross validation,
    - int, to specify the number of folds in a `(Stratified)KFold`,
    - :term:`CV splitter`,
    - An iterable that generates (train, test) splits as arrays of indices.

    For int/None inputs, if the estimator is a classifier and ``y`` is
    either binary or multiclass, :class:`StratifiedKFold` is used. In all
    other cases, :class:`KFold` is used. These splitters are instantiated
    with `shuffle=False` so the splits 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
    predicting 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`` 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:

    - None, in which case all the jobs are immediately created and spawned. Use
      this for lightweight and fast-running jobs, to avoid delays due to on-demand
      spawning of the jobs
    - 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'

method : {'predict', 'predict_proba', 'predict_log_proba',               'decision_function'}, default='predict'
    The method to be invoked by `estimator`.

Returns
-------
predictions : ndarray
    This is the result of calling `method`. Shape:

    - When `method` is 'predict' and in special case where `method` is
      'decision_function' and the target is binary: (n_samples,)
    - When `method` is one of {'predict_proba', 'predict_log_proba',
      'decision_function'} (unless special case above):
      (n_samples, n_classes)
    - If `estimator` is :term:`multioutput`, an extra dimension
      'n_outputs' is added to the end of each shape above.

See Also
--------
cross_val_score : Calculate score for each CV split.
cross_validate : Calculate one or more scores and timings for each CV
    split.

Notes
-----
In the case that one or more classes are absent in a training portion, a
default score needs to be assigned to all instances for that class if
``method`` produces columns per class, as in {'decision_function',
'predict_proba', 'predict_log_proba'}.  For ``predict_proba`` this value is
0.  In order to ensure finite output, we approximate negative infinity by
the minimum finite float value for the dtype in other cases.

Examples
--------
>>> from sklearn import datasets, linear_model
>>> from sklearn.model_selection import cross_val_predict
>>> diabetes = datasets.load_diabetes()
>>> X = diabetes.data[:150]
>>> y = diabetes.target[:150]
>>> lasso = linear_model.Lasso()
>>> y_pred = cross_val_predict(lasso, X, y, cv=3)
Nr(