code: def cross_val_multiscore(
      estimator,
      X,
      y=None,
      groups=None,
      scoring=None,
      cv=None,
      n_jobs=None,
      verbose=None,
      fit_params=None,
      pre_dispatch="2*n_jobs",
  ):
      """Evaluate a score by cross-validation.
  
      Parameters
      ----------
      estimator : instance of sklearn.base.BaseEstimator
          The object to use to fit the data.
          Must implement the 'fit' method.
      X : array-like, shape (n_samples, n_dimensional_features,)
          The data to fit. Can be, for example a list, or an array at least 2d.
      y : array-like, shape (n_samples, n_targets,)
          The target variable to try to predict in the case of
          supervised learning.
      groups : array-like, with shape (n_samples,)
          Group labels for the samples used while splitting the dataset into
          train/test set.
      scoring : str, callable | None
          A string (see model evaluation documentation) or
          a scorer callable object / function with signature
          ``scorer(estimator, X, y)``.
          Note that when using an estimator which inherently returns
          multidimensional output - in particular, SlidingEstimator
          or GeneralizingEstimator - you should set the scorer
          there, not here.
      cv : int, cross-validation generator | iterable
          Determines the cross-validation splitting strategy.
          Possible inputs for cv are:
  
          - None, to use the default 5-fold cross validation,
          - integer, to specify the number of folds in a ``(Stratified)KFold``,
          - An object to be used as a cross-validation generator.
          - An iterable yielding train, test splits.
  
          For integer/None inputs, if the estimator is a classifier and ``y`` is
          either binary or multiclass,
          :class:`sklearn.model_selection.StratifiedKFold` is used. In all
          other cases, :class:`sklearn.model_selection.KFold` is used.
      %(n_jobs)s
      %(verbose)s
      fit_params : dict, optional
          Parameters to pass to the fit method of the estimator.
      pre_dispatch : int, or str, optional
          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 string, giving an expression as a function of n_jobs,
            as in '2*n_jobs'
  
      Returns
      -------
      scores : array of float, shape (n_splits,) | shape (n_splits, n_scores)
          Array of scores of the estimator for each run of the cross validation.
      """
      # This code is copied from sklearn
      from sklearn.base import clone, is_classifier
      from sklearn.model_selection._split import check_cv
      from sklearn.utils import indexable
  
      check_scoring = _get_check_scoring()
  
      X, y, groups = indexable(X, y, groups)
  
      cv = check_cv(cv, y, classifier=is_classifier(estimator))
      cv_iter = list(cv.split(X, y, groups))
      scorer = check_scoring(estimator, scoring=scoring)
      # We clone the estimator to make sure that all the folds are
      # independent, and that it is pickle-able.
      # Note: this parallelization is implemented using MNE Parallel
      parallel, p_func, n_jobs = parallel_func(
          _fit_and_score, n_jobs, pre_dispatch=pre_dispatch
      )
      position = hasattr(estimator, "position")
      scores = parallel(
          p_func(
              estimator=clone(estimator),
              X=X,
              y=y,
              scorer=scorer,
              train=train,
              test=test,
              fit_params=fit_params,
              verbose=verbose,
              parameters=dict(position=ii % n_jobs)
              if position
              else None,
          )
          for ii, (train, test) in enumerate(cv_iter)
      )
      return np.array(scores)[:, 0, ...]
  
imports: import datetime
  import numbers
  import numpy
  from ..fixes import BaseEstimator, _check_fit_params, _get_check_scoring
  from ..parallel import parallel_func
  from ..utils import verbose, warn
label_desc: Use image node_id 5 for calling a global function with example usage: cross_val_multiscore(estimator, X, y, groups, scoring, cv, n_jobs, verbose, fit_params, pre_dispatch) and returns: np