code: def _parse_sklearn_column_transformer(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* *ColumnTransformer* object
      :param inputs: A list of Variable objects
      :return: A list of output variables produced by column transformer
      """
      # Output variable name of each transform. It's a list of string.
      transformed_result_names = []
      # Encode each transform as our IR object
      for name, op, column_indices in model.transformers_:
          if op == "drop":
              continue
          if isinstance(column_indices, slice):
              column_indices = list(
                  range(
                      column_indices.start
                      if column_indices.start is not None
                      else 0,
                      column_indices.stop,
                      column_indices.step
                      if column_indices.step is not None
                      else 1,
                  )
              )
          elif isinstance(column_indices, (int, str)):
              column_indices = [column_indices]
          if len(column_indices) == 0:
              continue
          names = _get_column_indices(
              column_indices, inputs, len(inputs) > 1
          )
          transform_inputs = []
          for onnx_var, onnx_is in names.items():
              tr_inputs = _fetch_input_slice(
                  topology, [inputs[onnx_var]], onnx_is
              )
              transform_inputs.extend(tr_inputs)
  
          merged_cols = False
          if len(transform_inputs) > 1:
              if isinstance(op, pipeline.Pipeline):
                  if not isinstance(
                      op.steps[0][1], do_not_merge_columns
                  ):
                      merged_cols = True
              elif not isinstance(op, do_not_merge_columns):
                  merged_cols = True
  
          if merged_cols:
              # Many ONNX operators expect one input vector, the default behaviour is to merge columns.
              ty = transform_inputs[0].type.__class__([None, None])
  
              conc_op = topology.declare_logical_operator(
                  "SklearnConcat"
              )
              conc_op.inputs = transform_inputs
              conc_names = topology.declare_logical_variable(
                  "merged_columns", ty
              )
              conc_op.outputs.append(conc_names)
              transform_inputs = [conc_names]
  
          model_obj = model.named_transformers_[name]
          if isinstance(model_obj, str):
              if model_obj == "passthrough":
                  var_out = transform_inputs[0]
              elif model_obj == "drop":
                  var_out = None
              else:
                  raise RuntimeError(
                      "Unknown operator alias "
                      "'{0}'. These are specified in "
                      "supported.py."
                      "".format(model_obj)
                  )
          else:
              var_out = _parse_sklearn_api(
                  topology, model_obj, transform_inputs
              )[0]
              if (
                  model.transformer_weights is not None
                  and name in model.transformer_weights
              ):
                  # Create a Multiply node
                  multiply_operator = topology.declare_logical_operator(
                      "SklearnMultiply"
                  )
                  multiply_operator.inputs.append(var_out)
                  multiply_operator.operand = model.transformer_weights[
                      name
                  ]
                  var_out = topology.declare_logical_variable(
                      "multiply_output"
                  )
                  multiply_operator.outputs.append(var_out)
          if var_out:
              transformed_result_names.append(var_out)
  
      # Create a Concat node
      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)
          return concat_operator.outputs
      return transformed_result_names
  
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 14 for calling a global function with example usage: _parse_sklearn_column_transformer(topology, model, inputs) and returns: transformed_result_names, concat_operator