class_docstr: The config selector handles the surrogate model and the acquisition function. Based on both components, the next
  configuration is selected.
  
  Parameters
  ----------
  retrain_after : int, defaults to 8
      How many configurations should be returned before the surrogate model is retrained.
  retries : int, defaults to 8
      How often to retry receiving a new configuration before giving up.
  min_trials: int, defaults to 1
      How many samples are required to train the surrogate model. If budgets are involved,
      the highest budgets are checked first. For example, if min_trials is three, but we find only
      two trials in the runhistory for the highest budget, we will use trials of a lower budget
      instead.
code: def __init__(
      self,
      scenario: Scenario,
      *,
      retrain_after: int = 8,
      retries: int = 16,
      min_trials: int = 1,
  ) -> None:
      # Those are the configs sampled from the passed initial design
      # Selecting configurations from initial design
      self._initial_design_configs: list[Configuration] = []
  
      # Set classes globally
      self._scenario = scenario
      self._runhistory: RunHistory | None = None
      self._runhistory_encoder: AbstractRunHistoryEncoder | None = None
      self._model: AbstractModel | None = None
      self._acquisition_maximizer: AbstractAcquisitionMaximizer | None = (
          None
      )
      self._acquisition_function: AbstractAcquisitionFunction | None = (
          None
      )
      self._random_design: AbstractRandomDesign | None = None
      self._callbacks: list[Callback] = []
  
      # And other variables
      self._retrain_after = retrain_after
      self._previous_entries = -1
      self._predict_x_best = True
      self._min_trials = min_trials
      self._considered_budgets: list[float | int | None] = [None]
  
      # How often to retry receiving a new configuration
      # (counter increases if the received config was already returned before)
      self._retries = retries
  
      # Processed configurations should be stored here; this is important to not return the same configuration twice
      self._processed_configs: list[Configuration] = []
  
imports: from __future__ import annotations
  from typing import Any, Iterator
  import copy
  import numpy
  from ConfigSpace import Configuration
  from smac.acquisition.function.abstract_acquisition_function import AbstractAcquisitionFunction
  from smac.acquisition.maximizer.abstract_acqusition_maximizer import AbstractAcquisitionMaximizer
  from smac.callback.callback import Callback
  from smac.initial_design import AbstractInitialDesign
  from smac.model.abstract_model import AbstractModel
  from smac.random_design.abstract_random_design import AbstractRandomDesign
  from smac.runhistory.encoder.abstract_encoder import AbstractRunHistoryEncoder
  from smac.runhistory.runhistory import RunHistory
  from smac.scenario import Scenario
  from smac.utils.logging import get_logger
label_desc: Use image node_id 1 to create a new ConfigSelector object  with example: obj = ConfigSelector(scenario)