class_docstr: Differential Evolution with HyperBand
  
  This class is a wrapper around the library DEHB:
  https://github.com/automl/DEHB.
  
  For more information on the algorithm,
  see original paper at https://arxiv.org/abs/2105.09821.
  
  Awad, Noor, Neeratyoy Mallik, and Frank Hutter. "Dehb: Evolutionary hyperband for scalable,
  robust and efficient hyperparameter optimization." arXiv preprint arXiv:2105.09821 (2021).
  
  Parameters
  ----------
  space: `orion.algo.space.Space`
      Optimisation space with priors for each dimension.
  
  seed: None, int or sequence of int
      Seed for the random number generator used to sample new trials.
      Default: ``None``
  
  mutation_factor: float
      Mutation probability
      Default: ``0.5``
  
  crossover_prob: float
      Crossover probability
      Default: ``0.5``
  
  mutation_strategy: str
      Mutation strategy rand1, rand2dir randtobest1 currenttobest1 best1 best2 rand2
      Default: ``'rand1'``
  
  crossover_strategy: str
      Crossover strategy bin or exp
      Default: ``'bin'``
  
  boundary_fix_type: str
      Boundary fix method, clip or random
      Default: ``'random'``
  
  min_clip: float
      Min clip when boundary fix method is clip
      Default: ``None``
  
  max_clip: float
      Max clip when boundary fix method is clip
      Default: ``None``
code: def __init__(
      self,
      space: Space,
      seed: int | None = None,
      mutation_factor: float = 0.5,
      crossover_prob: float = 0.5,
      mutation_strategy: str = "rand1",
      crossover_strategy: str = "bin",
      boundary_fix_type: str = "random",
      min_clip: int | None = None,
      max_clip: int | None = None,
  ):
      import_optional.ensure()
  
      # Sanity Check
      if mutation_strategy not in MUTATION_STRATEGIES:
          raise UnsupportedConfiguration(
              f"Mutation strategy {mutation_strategy} not supported"
          )
  
      if crossover_strategy not in CROSSOVER_STRATEGY:
          raise UnsupportedConfiguration(
              f"Crossover strategy {crossover_strategy} not supported"
          )
  
      if boundary_fix_type not in FIX_MODES:
          raise UnsupportedConfiguration(
              f"Boundary fix type {boundary_fix_type} not supported"
          )
  
      super().__init__(
          space,
          seed=seed,
          mutation_factor=mutation_factor,
          crossover_prob=crossover_prob,
          mutation_strategy=mutation_strategy,
          crossover_strategy=crossover_strategy,
          boundary_fix_type=boundary_fix_type,
          min_clip=min_clip,
          max_clip=max_clip,
      )
  
      # Extract fidelity information
      if self.fidelity_index is None:
          raise RuntimeError(SPACE_ERROR)
  
      fidelity_dim: Fidelity = space[self.fidelity_index]
  
      # NOTE: This isn't a Fidelity, it's a TransformedDimension<Fidelity>
      from orion.core.worker.transformer import TransformedDimension
  
      # NOTE: Currently bypassing (possibly more than one) `TransformedDimension` wrappers to get
      # the 'low', 'high' and 'base' attributes.
      while isinstance(fidelity_dim, TransformedDimension):
          fidelity_dim = fidelity_dim.original_dimension
      assert isinstance(fidelity_dim, Fidelity)
  
      self.rung: int | None = None
      self.seed = seed
      self.job_infos: defaultdict[str, list] = defaultdict(list)
      self.job_results: dict[str, RungResult] = {}
      self.duplicates: defaultdict[str, int] = defaultdict(int)
  
      configspace = convert_space(self.space)
  
      # Initialize
      self.dehb = _CustomDEHBImpl(
          duplicates=self.duplicates,
          cs=configspace,
          configspace=True,
          dimensions=len(configspace.get_hyperparameters()),
          mutation_factor=mutation_factor,
          crossover_prob=crossover_prob,
          strategy=f"{mutation_strategy}_{crossover_strategy}",
          min_clip=min_clip,
          max_clip=max_clip,
          boundary_fix_type=boundary_fix_type,
          max_age=numpy.inf,
          # Derived
          min_budget=fidelity_dim.low,
          max_budget=fidelity_dim.high,
          eta=fidelity_dim.base,
          # Disable their Dask Integration
          n_workers=1,
          client=None,
          # No need for the user function
          f=None,
      )
      self.seed_rng(self.seed)
      self.rung = len(self.dehb.budgets)
  
imports: from __future__ import annotations
  import logging
  from collections import defaultdict
  from copy import deepcopy
  from typing import ClassVar, NamedTuple
  import numpy
  from orion.algo.base import BaseAlgorithm
  from orion.algo.dehb.brackets import SHBracketManager
  from orion.algo.space import Fidelity, Space
  from orion.core.utils import format_trials
  from orion.core.utils.module_import import ImportOptional
  from orion.core.worker.trial import Trial
label_desc: Use image node_id 1 to create a new DEHB object from inherited base classes: BaseAlgorithm with example: obj = DEHB(space, seed, mutation_factor, crossover_prob, mutation_strategy, crossover_strategy, boundary_fix_type, min_clip, max_clip)