code: def _parse_sklearn_stacking(topology, model, inputs):
      """
      Taken from https://github.com/onnx/sklearn-onnx/blob/9939c089a467676f4ffe9f3cb91098c4841f89d8/skl2onnx/_parse.py#L238.
      :param topology: Topology object
      :param model: A *scikit-learn* *Stacking* object
      :param inputs: A list of Variable objects
      :return: A list of output variables produced by column transformer
      """
      # Output variable name of each estimator. It's a list of variables.
      transformed_result_names = []
      # Encode each estimator as our IR object.
      for op, method in zip(model.estimators_, model.stack_method_):
          var_out = _parse_sklearn_api(topology, op, inputs)
          if method not in ["predict_proba", "predict"]:
              raise ValueError(
                  "Ensemble method {} not supported. Please fill an issue at https://github.com/microsoft/hummingbird.".format(
                      method
                  )
              )
          index = 0
          if method == "predict_proba":
              index = 1
          array_feature_extractor_operator = (
              topology.declare_logical_operator(
                  "SklearnArrayFeatureExtractor"
              )
          )
          array_feature_extractor_operator.inputs = var_out
          array_feature_extractor_operator.column_indices = [index]
          output_variable_name = topology.declare_logical_variable(
              "extracted_feature_columns", var_out[0].type
          )
          array_feature_extractor_operator.outputs.append(
              output_variable_name
          )
          transformed_result_names.append(output_variable_name)
  
      if model.passthrough:
          transformed_result_names.extend(inputs)
      if len(transformed_result_names) > 1:
          concat_operator = topology.declare_logical_operator(
              "SklearnConcat"
          )
          concat_operator.inputs = transformed_result_names
  
          # Declare output name of scikit-learn ColumnTransformer
          transformed_column_name = topology.declare_logical_variable(
              "transformed_column"
          )
          concat_operator.outputs.append(transformed_column_name)
          transformed_result_names = [transformed_column_name]
  
      op = model.final_estimator_
      var_out = _parse_sklearn_api(
          topology, op, transformed_result_names
      )
  
      return var_out
  
imports: from collections import OrderedDict
  from copy import deepcopy
  import pprint
  from uuid import uuid4
  import numpy
  from onnxconverter_common.optimizer import LinkedNode, _topological_sort
  from sklearn import pipeline
  from sklearn.compose import ColumnTransformer
  from sklearn.ensemble import BaggingClassifier, BaggingRegressor
  from sklearn.model_selection import GridSearchCV, RandomizedSearchCV
  from sklearn.multioutput import MultiOutputRegressor, RegressorChain
  from sklearn.preprocessing import OneHotEncoder
  from .containers import CommonSklearnModelContainer, CommonONNXModelContainer, CommonSparkMLModelContainer
  from ._topology import Topology
  from ._utils import sklearn_installed, sparkml_installed
  from .operator_converters import constants
  from .supported import get_sklearn_api_operator_name, get_onnxml_api_operator_name, get_sparkml_api_operator_name
label_desc: Use image node_id 15 for calling a global function with example usage: _parse_sklearn_stacking(topology, model, inputs) and returns: var_out