class_docstr: This class implements the classification task.
  
  It implements a pipeline, which includes one preprocessing step and one
  classification algorithm. It can render a search space including all known
  classification and preprocessing algorithms.
  
  Contrary to the sklearn API it is not possible to enumerate the
  possible parameters in the __init__ function because we only know the
  available classifiers at runtime. For this reason the user must
  specifiy the parameters by passing an instance of
  ConfigSpace.configuration_space.Configuration.
  
  Parameters
  ----------
  config : ConfigSpace.configuration_space.Configuration
      The configuration to evaluate.
  
  random_state : Optional[int | RandomState]
      If int, random_state is the seed used by the random number generator;
      If RandomState instance, random_state is the random number generator;
      If None, the random number generator is the RandomState instance
      used by `np.random`.
  
  Attributes
  ----------
  _estimator : The underlying scikit-learn classification model. This
      variable is assigned after a call to the
      :meth:`autosklearn.pipeline.classification.SimpleClassificationPipeline
      .fit` method.
  
  _preprocessor : The underlying scikit-learn preprocessing algorithm. This
      variable is only assigned if a preprocessor is specified and
      after a call to the
      :meth:`autosklearn.pipeline.classification.SimpleClassificationPipeline
      .fit` method.
  
  See also
  --------
  
  References
  ----------
  
  Examples
  --------
docstr: predict_proba.
  
  Parameters
  ----------
  X : array-like, shape = (n_samples, n_features)
  
  batch_size: int or None, defaults to None
      batch_size controls whether the pipeline will be
      called on small chunks of the data. Useful when calling the
      predict method on the whole array X results in a MemoryError.
  
  Returns
  -------
  array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)
docstr_tok: ["predict_proba",".","Parameters","--","--","--","--","--","X",":","array-like",",","shape","=","(","n_samples",",","n_features",")","batch_size",":","int","or","None",",","defaults","to","None","batch_size","controls","whether","the","pipeline","will","be","called","on","small","chunks","of","the","data",".","Useful","when","calling","the","predict","method","on","the","whole","array","X","results","in","a","MemoryError",".","Returns","--","--","--","-","array",",","shape=","(","n_samples",",",")","if","n_classes","==","2","else","(","n_samples",",","n_classes",")"]
code: def predict_proba(self, X, batch_size=None):
      """predict_proba.
  
      Parameters
      ----------
      X : array-like, shape = (n_samples, n_features)
  
      batch_size: int or None, defaults to None
          batch_size controls whether the pipeline will be
          called on small chunks of the data. Useful when calling the
          predict method on the whole array X results in a MemoryError.
  
      Returns
      -------
      array, shape=(n_samples,) if n_classes == 2 else (n_samples, n_classes)
      """
      if batch_size is None:
          return super().predict_proba(X)
  
      else:
          if not isinstance(batch_size, int):
              raise ValueError(
                  "Argument 'batch_size' must be of type int, "
                  "but is '%s'" % type(batch_size)
              )
          if batch_size <= 0:
              raise ValueError(
                  "Argument 'batch_size' must be positive, "
                  "but is %d" % batch_size
              )
  
          else:
              # Probe for the target array dimensions
              target = self.predict_proba(X[0:2].copy())
  
              y = np.zeros(
                  (X.shape[0], target.shape[1]), dtype=np.float32
              )
  
              for k in range(
                  max(1, int(np.ceil(float(X.shape[0]) / batch_size)))
              ):
                  batch_from = k * batch_size
                  batch_to = min([(k + 1) * batch_size, X.shape[0]])
                  pred_prob = self.predict_proba(
                      X[batch_from:batch_to], batch_size=None
                  )
                  y[batch_from:batch_to] = pred_prob.astype(np.float32)
  
              return y
  
imports: from typing import Optional, Union
  import copy
  from itertools import product
  import numpy
  from ConfigSpace.configuration_space import Configuration, ConfigurationSpace
  from ConfigSpace.forbidden import ForbiddenAndConjunction, ForbiddenEqualsClause
  from sklearn.base import ClassifierMixin
  from autosklearn.askl_typing import FEAT_TYPE_TYPE
  from autosklearn.pipeline.base import BasePipeline
  from autosklearn.pipeline.components.classification import ClassifierChoice
  from autosklearn.pipeline.components.data_preprocessing import DataPreprocessorChoice
  from autosklearn.pipeline.components.data_preprocessing.balancing.balancing import Balancing
  from autosklearn.pipeline.components.feature_preprocessing import FeaturePreprocessorChoice
  from autosklearn.pipeline.constants import SPARSE
label_desc: Use image node_id 3 for calling the SimpleClassificationPipeline obj's underlying member method code with example usage: obj.predict_proba(X, batch_size) and returns: super, y