code: def stack_models(
      estimator_list: list,
      meta_model=None,
      meta_model_fold: Optional[Union[int, Any]] = 5,
      fold: Optional[Union[int, Any]] = None,
      round: int = 4,
      restack: bool = False,
      choose_better: bool = False,
      optimize: str = "R2",
      fit_kwargs: Optional[dict] = None,
      groups: Optional[Union[str, Any]] = None,
      verbose: bool = True,
      return_train_score: bool = False,
  ):
      """
      This function trains a meta model over select estimators passed in
      the ``estimator_list`` parameter. The output of this function is a
      score grid with CV scores by fold. Metrics evaluated during CV can
      be accessed using the ``get_metrics`` function. Custom metrics
      can be added or removed using ``add_metric`` and ``remove_metric``
      function.
  
  
      Example
      --------
      >>> from pycaret.datasets import get_data
      >>> boston = get_data('boston')
      >>> from pycaret.regression import *
      >>> exp_name = setup(data = boston,  target = 'medv')
      >>> top3 = compare_models(n_select = 3)
      >>> stacker = stack_models(top3)
  
  
      estimator_list: list of scikit-learn compatible objects
          List of trained model objects
  
  
      meta_model: scikit-learn compatible object, default = None
          When None, Linear Regression is trained as a meta model.
  
  
      meta_model_fold: integer or scikit-learn compatible CV generator, default = 5
          Controls internal cross-validation. Can be an integer or a scikit-learn
          CV generator. If set to an integer, will use (Stratifed)KFold CV with
          that many folds. See scikit-learn documentation on Stacking for
          more details.
  
  
      fold: int or scikit-learn compatible CV generator, default = None
          Controls cross-validation. If None, the CV generator in the ``fold_strategy``
          parameter of the ``setup`` function is used. When an integer is passed,
          it is interpreted as the 'n_splits' parameter of the CV generator in the
          ``setup`` function.
  
  
      round: int, default = 4
          Number of decimal places the metrics in the score grid will be rounded to.
  
  
      restack: bool, default = False
          When set to False, only the predictions of estimators will be used as
          training data for the ``meta_model``.
  
  
      choose_better: bool, default = False
          When set to True, the returned object is always better performing. The
          metric used for comparison is defined by the ``optimize`` parameter.
  
  
      optimize: str, default = 'R2'
          Metric to compare for model selection when ``choose_better`` is True.
  
  
      fit_kwargs: dict, default = {} (empty dict)
          Dictionary of arguments passed to the fit method of the model.
  
  
      groups: str or array-like, with shape (n_samples,), default = None
          Optional group labels when GroupKFold is used for the cross validation.
          It takes an array with shape (n_samples, ) where n_samples is the number
          of rows in training dataset. When string is passed, it is interpreted as
          the column name in the dataset containing group labels.
  
  
      verbose: bool, default = True
          Score grid is not printed when verbose is set to False.
  
  
      return_train_score: bool, default = False
          If False, returns the CV Validation scores only.
          If True, returns the CV training scores along with the CV validation scores.
          This is useful when the user wants to do bias-variance tradeoff. A high CV
          training score with a low corresponding CV validation score indicates overfitting.
  
  
      Returns:
          Trained Model
  
      """
  
      return _CURRENT_EXPERIMENT.stack_models(
          estimator_list=estimator_list,
          meta_model=meta_model,
          meta_model_fold=meta_model_fold,
          fold=fold,
          round=round,
          restack=restack,
          choose_better=choose_better,
          optimize=optimize,
          fit_kwargs=fit_kwargs,
          groups=groups,
          verbose=verbose,
          return_train_score=return_train_score,
      )
  
imports: import logging
  import os
  from typing import Any, BinaryIO, Callable, Dict, List, Optional, Union
  import pandas
  from joblib.memory import Memory
  from pycaret.internal.parallel.parallel_backend import ParallelBackend
  from pycaret.loggers.base_logger import BaseLogger
  from pycaret.regression.oop import RegressionExperiment
  from pycaret.utils.constants import DATAFRAME_LIKE, SEQUENCE_LIKE, TARGET_LIKE
  from pycaret.utils.generic import check_if_global_is_not_none
label_desc: Use image node_id 9 for calling a global function with example usage: stack_models(estimator_list, meta_model, meta_model_fold, fold, round, restack, choose_better, optimize, fit_kwargs, groups, verbose, return_train_score) and returns: _CURRENT_EXPERIMENT