class_docstr: Stack ensemble meta-model which functions identically to :class:`BaggedEnsembleModel` with the additional capability to leverage base models.
  
  By specifying base models during init, stacker models can use the base model predictions as features during training and inference.
  
  This property allows for significantly improved model quality in many situations compared to non-stacking alternatives.
  
  Stacker models can act as base models to other stacker models, enabling multi-layer stack ensembling.
code: def preprocess(
      self,
      X,
      fit=False,
      compute_base_preds=True,
      infer=True,
      model_pred_proba_dict=None,
      **kwargs,
  ):
      if self.stack_column_prefix_lst:
          if infer:
              if set(self.stack_columns).issubset(set(list(X.columns))):
                  compute_base_preds = False  # TODO: Consider removing, this can be dangerous but the code to make this work otherwise is complex (must rewrite predict_proba)
          if compute_base_preds:
              X_stacker = []
              for stack_column_prefix in self.stack_column_prefix_lst:
                  base_model_name = (
                      self.stack_column_prefix_to_model_map[
                          stack_column_prefix
                      ]
                  )
                  if fit:
                      base_model_type = self.base_model_types_dict[
                          base_model_name
                      ]
                      base_model_path = self.base_model_paths_dict[
                          base_model_name
                      ]
                      y_pred_proba = base_model_type.load_oof(
                          path=base_model_path
                      )
                  elif (
                      model_pred_proba_dict
                      and base_model_name in model_pred_proba_dict
                  ):
                      y_pred_proba = model_pred_proba_dict[
                          base_model_name
                      ]
                  else:
                      base_model = self.load_base_model(base_model_name)
                      y_pred_proba = base_model.predict_proba(X)
                  X_stacker.append(
                      y_pred_proba
                  )  # TODO: This could get very large on a high class count problem. Consider capping to top N most frequent classes and merging least frequent
              X_stacker = self.pred_probas_to_df(
                  X_stacker, index=X.index
              )
              if self.params["use_orig_features"]:
                  X = pd.concat([X_stacker, X], axis=1)
              else:
                  X = X_stacker
          elif not self.params["use_orig_features"]:
              X = X[self.stack_columns]
      X = super().preprocess(X, **kwargs)
      return X
  
imports: import copy
  import logging
  import os
  import time
  from collections import defaultdict
  from typing import Dict
  import numpy
  import pandas
  from autogluon.common.features.feature_metadata import FeatureMetadata
  from autogluon.common.features.types import R_FLOAT, S_STACK
  from autogluon.common.utils.path_converter import PathConverter
  from ...constants import MULTICLASS, QUANTILE, SOFTCLASS
  from ..abstract.abstract_model import AbstractModel
  from .bagged_ensemble_model import BaggedEnsembleModel
label_desc: Use image node_id 6 for calling the StackerEnsembleModel obj's underlying member method code with example usage: obj.preprocess(X, fit, compute_base_preds, infer, model_pred_proba_dict) and returns: X