code: def __init__(
      self,
      backend: Backend,
      queue: multiprocessing.Queue,
      metrics: Sequence[Scorer],
      additional_components: Dict[str, ThirdPartyComponents],
      port: Optional[int],
      configuration: Optional[Union[int, Configuration]] = None,
      scoring_functions: Optional[List[Scorer]] = None,
      seed: int = 1,
      output_y_hat_optimization: bool = True,
      num_run: Optional[int] = None,
      include: Optional[List[str]] = None,
      exclude: Optional[List[str]] = None,
      disable_file_output: Union[bool, List[str]] = False,
      init_params: Optional[Dict[str, Any]] = None,
      budget: Optional[float] = None,
      budget_type: Optional[str] = None,
  ):
      # Limit the number of threads that numpy uses
      threadpool_limits(limits=1)
  
      self.starttime = time.time()
  
      self.configuration = configuration
      self.backend = backend
      self.port = port
      self.queue = queue
  
      self.datamanager = self.backend.load_datamanager()
      self.feat_type = self.datamanager.feat_type
      self.include = include
      self.exclude = exclude
  
      self.X_test = self.datamanager.data.get("X_test")
      self.y_test = self.datamanager.data.get("Y_test")
  
      self.metrics = metrics
      self.task_type = self.datamanager.info["task"]
      self.seed = seed
  
      self.output_y_hat_optimization = output_y_hat_optimization
      self.scoring_functions = (
          scoring_functions if scoring_functions else []
      )
  
      if isinstance(disable_file_output, (bool, list)):
          self.disable_file_output: Union[
              bool, List[str]
          ] = disable_file_output
      else:
          raise ValueError(
              "disable_file_output should be either a bool or a list"
          )
  
      if self.task_type in REGRESSION_TASKS:
          if not isinstance(self.configuration, Configuration):
              self.model_class = MyDummyRegressor
          else:
              self.model_class = (
                  autosklearn.pipeline.regression.SimpleRegressionPipeline
              )
          self.predict_function = self._predict_regression
      else:
          if not isinstance(self.configuration, Configuration):
              self.model_class = MyDummyClassifier
          else:
              self.model_class = (
                  autosklearn.pipeline.classification.SimpleClassificationPipeline
              )
          self.predict_function = self._predict_proba
  
      self._init_params = {
          "data_preprocessor:feat_type": self.datamanager.feat_type
      }
  
      if init_params is not None:
          self._init_params.update(init_params)
  
      if num_run is None:
          num_run = 0
      self.num_run = num_run
  
      logger_name = "%s(%d):%s" % (
          self.__class__.__name__.split(".")[-1],
          self.seed,
          self.datamanager.name,
      )
  
      if self.port is None:
          self.logger = logging.getLogger(__name__)
      else:
          self.logger = get_named_client_logger(
              name=logger_name,
              port=self.port,
          )
  
      self.X_optimization: Optional[SUPPORTED_XDATA_TYPES] = None
      self.Y_optimization: Optional[SUPPORTED_TARGET_TYPES] = None
      self.Y_actual_train = None
  
      self.budget = budget
      self.budget_type = budget_type
  
      # Add 3rd-party components to the list of 3rd-party components in case this
      # wasn't done before (this happens if we run in parallel and the components
      # are only passed to the AbstractEvaluator via the TAE and are not there
      # yet because the worker is in its own process).
      for key in additional_components:
          for component_name, component in additional_components[
              key
          ].components.items():
              if component_name not in _addons[key].components:
                  _addons[key].add_component(component)
  
      # Please mypy to prevent not defined attr
      self.model = self._get_model(feat_type=self.feat_type)
  
imports: from __future__ import annotations
  from typing import Any, Dict, List, Optional, Sequence, TextIO, Tuple, Type, Union, cast
  import logging
  import multiprocessing
  import time
  import warnings
  import numpy
  from ConfigSpace import Configuration
  from sklearn.base import BaseEstimator
  from sklearn.dummy import DummyClassifier, DummyRegressor
  from sklearn.ensemble import VotingClassifier, VotingRegressor
  from smac.tae import StatusType
  from threadpoolctl import threadpool_limits
  import autosklearn.pipeline.classification
  import autosklearn.pipeline.regression
  from autosklearn.askl_typing import FEAT_TYPE_TYPE
  from autosklearn.automl_common.common.utils.backend import Backend
  from autosklearn.constants import CLASSIFICATION_TASKS, MULTICLASS_CLASSIFICATION, MULTILABEL_CLASSIFICATION, MULTIOUTPUT_REGRESSION, REGRESSION_TASKS
  from autosklearn.data.target_validator import SUPPORTED_TARGET_TYPES, SUPPORTED_XDATA_TYPES
  from autosklearn.metrics import Scorer, calculate_losses
  from autosklearn.pipeline.components.base import ThirdPartyComponents, _addons
  from autosklearn.pipeline.implementations.util import convert_multioutput_multiclass_to_multilabel
  from autosklearn.util.logging_ import PicklableClientLogger, get_named_client_logger
label_desc: Use image node_id 1 to create a new AbstractEvaluator object from inherited base classes: object with example: obj = AbstractEvaluator(backend, queue, metrics, additional_components, port, configuration, scoring_functions, seed, output_y_hat_optimization, num_run, include, exclude, disable_file_output, init_params, budget, budget_type)