code: def make_column_transformer(
      *transformers,
      remainder="drop",
      sparse_threshold=0.3,
      n_jobs=None,
      verbose=False,
  ):
      """Construct a ColumnTransformer from the given transformers.
  
      This is a shorthand for the ColumnTransformer constructor; it does not
      require, and does not permit, naming the transformers. Instead, they will
      be given names automatically based on their types. It also does not allow
      weighting with ``transformer_weights``.
  
      Parameters
      ----------
      *transformers : tuples
          Tuples of the form (transformer, columns) specifying the
          transformer objects to be applied to subsets of the data:
  
          * transformer : {'drop', 'passthrough'} or estimator
              Estimator must support `fit` and `transform`.
              Special-cased strings 'drop' and 'passthrough' are accepted as
              well, to indicate to drop the columns or to pass them through
              untransformed, respectively.
          * columns : str,  array-like of str, int, array-like of int, slice, \
                  array-like of bool or callable
              Indexes the data on its second axis. Integers are interpreted as
              positional columns, while strings can reference DataFrame columns
              by name. A scalar string or int should be used where
              ``transformer`` expects X to be a 1d array-like (vector),
              otherwise a 2d array will be passed to the transformer.
              A callable is passed the input data `X` and can return any of the
              above. To select multiple columns by name or dtype, you can use
              :obj:`make_column_selector`.
  
      remainder : {'drop', 'passthrough'} or estimator, default='drop'
          By default, only the specified columns in `transformers` are
          transformed and combined in the output, and the non-specified
          columns are dropped. (default of ``'drop'``).
          By specifying ``remainder='passthrough'``, all remaining columns that
          were not specified in `transformers` will be automatically passed
          through. This subset of columns is concatenated with the output of
          the transformers.
          By setting ``remainder`` to be an estimator, the remaining
          non-specified columns will use the ``remainder`` estimator. The
          estimator must support `fit` and `transform`.
  
      sparse_threshold : float, default=0.3
          If the transformed output consists of a mix of sparse and dense data,
          it will be stacked as a sparse matrix if the density is lower than this
          value. Use ``sparse_threshold=0`` to always return dense.
          When the transformed output consists of all sparse or all dense data,
          the stacked result will be sparse or dense, respectively, and this
          keyword will be ignored.
  
      n_jobs : int, default=None
          Number of jobs to run in parallel.
          ``None`` means 1 unless in a :obj:`joblib.parallel_backend` context.
          ``-1`` means using all processors. See `Glossary <n_jobs>`
          for more details.
  
      verbose : bool, default=False
          If True, the time elapsed while fitting each transformer will be
          printed as it is completed.
  
      Returns
      -------
      ct : ColumnTransformer
  
      See Also
      --------
      ColumnTransformer : Class that allows combining the
          outputs of multiple transformer objects used on column subsets
          of the data into a single feature space.
  
      Examples
      --------
      >>> from cuml.preprocessing import StandardScaler, OneHotEncoder
      >>> from cuml.compose import make_column_transformer
      >>> make_column_transformer(
      ...     (StandardScaler(), ['numerical_column']),
      ...     (OneHotEncoder(), ['categorical_column']))
      ColumnTransformer(transformers=[('standardscaler', StandardScaler(...),
                                       ['numerical_column']),
                                      ('onehotencoder', OneHotEncoder(...),
                                       ['categorical_column'])])
      """
      # transformer_weights keyword is not passed through because the user
      # would need to know the automatically generated names of the transformers
      transformer_list = _get_transformer_list(transformers)
      return ColumnTransformer(
          transformer_list,
          n_jobs=n_jobs,
          remainder=remainder,
          sparse_threshold=sparse_threshold,
          verbose=verbose,
      )
  
imports: from ..preprocessing import FunctionTransformer
  from ....thirdparty_adapters import check_array
  from ..utils.validation import check_is_fitted
  from ..utils.skl_dependencies import TransformerMixin, BaseComposition, BaseEstimator
  from cuml.internals import _deprecate_pos_args
  from cuml.internals.array_sparse import SparseCumlArray
  from cuml.internals.global_settings import _global_settings_data
  import cuml
  from itertools import chain
  from itertools import compress
  from joblib import Parallel
  import functools
  import timeit
  import numbers
  from cuml.internals.import_utils import has_sklearn
  from contextlib import contextmanager
  from collections import defaultdict
  import warnings
  from cuml.internals.safe_imports import cpu_only_import_from
  from cuml.internals.safe_imports import gpu_only_import_from
  from cuml.internals.safe_imports import cpu_only_import
  from cuml.internals.safe_imports import gpu_only_import
label_desc: Use image node_id 16 for calling a global function with example usage: make_column_transformer() and returns: ColumnTransformer