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``
docstr: Suggest a number of new sets of parameters.
  
  Parameters
  ----------
  num: int, optional
      Number of trials to suggest. The algorithm may return less than the number of trials
      requested.
  
  Returns
  -------
  list of trials or None
      A list of trials representing values suggested by the algorithm. The algorithm may opt
      out if it cannot make a good suggestion at the moment (it may be waiting for other
      trials to complete), in which case it will return None.
  
  Notes
  -----
  New parameters must be compliant with the problem's domain `orion.algo.space.Space`.
code: def suggest(self, num: int) -> list[Trial]:
      """Suggest a number of new sets of parameters.
  
      Parameters
      ----------
      num: int, optional
          Number of trials to suggest. The algorithm may return less than the number of trials
          requested.
  
      Returns
      -------
      list of trials or None
          A list of trials representing values suggested by the algorithm. The algorithm may opt
          out if it cannot make a good suggestion at the moment (it may be waiting for other
          trials to complete), in which case it will return None.
  
      Notes
      -----
      New parameters must be compliant with the problem's domain `orion.algo.space.Space`.
  
      """
      trials: Trial = []
      while len(trials) < num:
          if self.is_done:
              break
  
          # pylint: disable=protected-access
          job_info: dict = self.dehb._get_next_job()
          job_info["done"] = 0
  
          # We are generating trials for a bracket that is too high
          if (
              self.rung is not None
              and job_info["bracket_id"] >= self.rung
          ):
              break
  
          # Generate Orion trial
          new_trial = self.sample_to_trial(
              job_info["config"], fidelity=job_info["budget"]
          )
  
          # DEHB may sample 2 identical trials if working in a purely discrete spaceI
          # It this case you will have has_suggested(new_trial) is True, and you will
          # discard this trial.
          # It's fine to discard the trial, but we should keep track of the job_info.
          # DEHB does not know that we discarded the trial and will be waiting for the
          # result. We need to keep track of both job_info so that when we have
          # the result of the first trial, we assign it to the second job_info as well.
  
          if not self.has_suggested(new_trial):
              # Store metadata
              self.job_infos[self.get_id(new_trial)].append(job_info)
              self.dehb.register_job(job_info)
  
              # Standard Orion
              self.register(new_trial)
              trials.append(new_trial)
              logger.debug("Suggest new trials %s", new_trial)
          else:
              logger.debug("Already suggested %s", new_trial)
  
              # Do we already have a result for this trial ?
              result = self.job_results.get(self.get_id(new_trial))
  
              # Keep track of duplicated jobs per brackets
              # Bracket is only done after we reach the budget for unique
              # jobs
              self.duplicates[str(job_info["budget"])] += 1
  
              # if so observe it right now and discard
              if result is not None:
                  self.dehb.observe(job_info, *result)
              else:
                  # else we need to keep track of it to observe it later
                  self.job_infos[self.get_id(new_trial)].append(
                      job_info
                  )
  
      return trials
  
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 7 for calling the DEHB obj's underlying member method code with example usage: obj.suggest(num) and returns: trials