class_docstr: Implements an ML preprocessing operation.
  
  Preprocessors are stateful objects that can be fitted against a Dataset and used
  to transform both local data batches and distributed data. For example, a
  Normalization preprocessor may calculate the mean and stdev of a field during
  fitting, and uses these attributes to implement its normalization transform.
  
  Preprocessors can also be stateless and transform data without needed to be fitted.
  For example, a preprocessor may simply remove a column, which does not require
  any state to be fitted.
  
  If you are implementing your own Preprocessor sub-class, you should override the
  following:
  
  * ``_fit`` if your preprocessor is stateful. Otherwise, set
    ``_is_fittable=False``.
  * ``_transform_pandas`` and/or ``_transform_numpy`` for best performance,
    implement both. Otherwise, the data will be converted to the match the
    implemented method.
code: def _transform_batch(self, data: "DataBatchType") -> "DataBatchType":
      # For minimal install to locally import air modules
      import numpy as np
      import pandas as pd
  
      from ray.air.util.data_batch_conversion import (
          _convert_batch_type_to_numpy,
          _convert_batch_type_to_pandas,
      )
  
      try:
          import pyarrow
      except ImportError:
          pyarrow = None
  
      if not isinstance(
          data,
          (
              pd.DataFrame,
              pyarrow.Table,
              collections.abc.Mapping,
              np.ndarray,
          ),
      ):
          raise ValueError(
              "`transform_batch` is currently only implemented for Pandas "
              "DataFrames, pyarrow Tables, NumPy ndarray and dictionary of "
              f"ndarray. Got {type(data)}."
          )
  
      transform_type = self._determine_transform_to_use()
  
      if transform_type == BatchFormat.PANDAS:
          return self._transform_pandas(
              _convert_batch_type_to_pandas(data)
          )
      elif transform_type == BatchFormat.NUMPY:
          return self._transform_numpy(
              _convert_batch_type_to_numpy(data)
          )
  
imports: import abc
  import base64
  import collections
  import pickle
  import warnings
  from enum import Enum
  from typing import TYPE_CHECKING, Any, Dict, Optional, Union
  from ray.air.util.data_batch_conversion import BatchFormat
  from ray.util.annotations import Deprecated, DeveloperAPI, PublicAPI
label_desc: Use image node_id 12 for calling the Preprocessor obj's underlying member method code with example usage: obj._transform_batch(data) and returns: self, self