code: def convert_batch(
      model,
      backend,
      test_input,
      remainder_size=0,
      device="cpu",
      extra_config={},
  ):
      """
      A convert function for batch by batch prediction use cases.
      For some backends such as TVM, a container returned by `convert(...)` function above has a strict requirement on the
      allowable input shape.
      The container returned by this function is more flexible in that it can predict on the input of size
      `test_input.shape[0] * k + remainder_size`, where `k` is any integer.
      `test_input.shape[0]`, the number of rows in the `test_input`, is interpreted as a batch size, and at test time
      prediction proceeds in a batch by batch fashion.
      See the documentation for *convert(...)* above for more information.
  
      Args:
          model: An input model
          backend: The target for the conversion
          test_input: Some input data used to trace the model execution.
                      Multiple inputs can be passed as `tuple` objects or pandas Dataframes.
                      When possible, (`numpy`)`arrays` are suggested.
                      The number of rows becomes the batch size when tracing PyTorch models and compiling with TVM.
          remainder_size: An integer that together with test_input determines the size of test data that can be predicted.
                      The input to the returned container can be of size `test_input.shape[0] * k + remainder_size`, where `k`
                      is any integer.
          device: The target device the model should be run. This parameter is only used by the *torch** backends and *tvm*, and
                  the devices supported are the one supported by PyTorch, i.e., 'cpu' or 'cuda'.
          extra_config: Extra configurations to be used by the individual operator converters.
                        The set of supported extra configurations can be found at `hummingbird.ml.supported`
  
      Examples:
          >>> tvm_model = convert_batch(sklearn_model,`tvm`, X)
          >>> tvm_model = convert_batch(sklearn_model,`tvm`, X, remainder_size=50)
  
      Returns:
          A `BatchContainer` object that wraps one or two containers created by `convert(...)` function above.
      """
      extra_config[constants.REMAINDER_SIZE] = remainder_size
      return _convert_common(
          model, backend, test_input, device, extra_config
      )
  
imports: from copy import deepcopy
  import psutil
  import numpy
  from .operator_converters import constants
  from ._parse import parse_sklearn_api_model, parse_onnx_api_model, parse_sparkml_api_model
  from ._topology import convert
  from ._utils import assert_torch_installed, assert_lightgbm_installed, assert_xgboost_installed, pandas_installed, sparkml_installed, is_pandas_dataframe, is_spark_dataframe, tvm_installed
  from .exceptions import MissingConverter, MissingBackend
  from .supported import backends
  from sklearn.utils import all_estimators
  from sklearn.utils.validation import check_is_fitted
  from .None import operator_converters
  from .supported import xgb_operator_list
  from .supported import lgbm_operator_list
label_desc: Use image node_id 12 for calling a global function with example usage: convert_batch(model, backend, test_input, remainder_size, device, extra_config) and returns: _convert_common