class_docstr: EvolutionES formulates hyperparameter optimization as an evolution.
  
  For more information on the algorithm,
  see original paper at
  https://arxiv.org/pdf/1703.01041.pdf and
  https://arxiv.org/pdf/1901.11117.pdf
  
  Real et al. "Large-Scale Evolution of Image Classifiers"
  So et all. "The Evolved Transformer"
  
  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``
  repetitions: int
      Number of execution of Hyperband. Default is numpy.inf which means to
      run Hyperband until no new trials can be suggested.
  nums_population: int
      Number of population for EvolutionES. Larger number of population often gets better
      performance but causes more computation. So there is a trade-off according to the search
      space and required budget of your problems.
      Default: 20
  mutate: str or dict or None, optional
      In the mutate part, one can define the customized mutate function with its mutate factors,
      such as multiply factor (times/divides by a multiply factor) and add factor
      (add/subtract by a multiply factor). The function must be defined by
      an importable string. If None, default
      mutate function is used: ``orion.algo.evolution_es.mutate_functions.default_mutate``.
code: def __init__(
      self,
      space: Space,
      seed: int | Sequence[int] | None = None,
      repetitions: int | float = np.inf,
      nums_population: int = 20,
      mutate: str | dict | None = None,
      max_retries: int = 1000,
  ):
      self.mutate = mutate
  
      super().__init__(space, seed=seed, repetitions=repetitions)
      pair = nums_population // 2
      mutate_ratio = 0.3
      self.nums_population = nums_population
      self.nums_comp_pairs = pair
      self.max_retries = max_retries
      self.mutate_ratio = mutate_ratio
      self.nums_mutate_gene = (
          int((len(self.space.values()) - 1) * mutate_ratio)
          if int((len(self.space.values()) - 1) * mutate_ratio) > 0
          else 1
      )
  
      self.hurdles: list[float | np.ndarray] = []
  
      self.population: dict[int, list[int]] = {}
      for i, dim in enumerate(self.space.values()):
          if dim.type != "fidelity":
              self.population[i] = [-1] * nums_population
  
      self.performance: np.ndarray = np.inf * np.ones(nums_population)
  
      self.budgets = compute_budgets(
          self.min_resources,
          self.max_resources,
          self.reduction_factor,
          nums_population,
          pair,
      )
  
      self.brackets: list[BracketT] = self.create_brackets()
      self.seed_rng(seed)
  
imports: from __future__ import annotations
  import copy
  import importlib
  import logging
  from typing import Callable, ClassVar, Sequence, TypeVar
  import numpy
  from orion.algo.hyperband import BudgetTuple, Hyperband, HyperbandBracket
  from orion.algo.space import Space
  from orion.core.utils import format_trials
  from orion.core.utils.flatten import flatten
  from orion.core.worker.trial import Trial
label_desc: Use image node_id 1 to create a new EvolutionES object from inherited base classes: Hyperband with example: obj = EvolutionES(space, seed, repetitions, nums_population, mutate, max_retries)