class_docstr: Mutates a block from best trial if no budget to increase depth.
docstr: See the base class for details.
docstr_tok: ["See","the","base","class","for","details","."]
code: def get_suggestion(
      self, trials, hparams, my_trial_id=None, model_dir=None
  ):
      """See the base class for details."""
      if self._phoenix_spec.beam_size < 1:
          raise ValueError("phoenix_spec.beam_size must be >= 1.")
      sorted_trials = (
          self._metadata.get_best_k(
              trials, k=int(1e10), valid_only=True
          )
          or []
      )
      num_completed_trials = len(sorted_trials)
      best_trials = sorted_trials[: self._phoenix_spec.beam_size]
  
      # No feasible trials yet.
      if not best_trials:
          # Getting random architecture here instead of initial_architecture since
          # efficiency check requires the search to have a non-deterministic
          # component
          return (
              common.encode_architecture(
                  common.get_random_architecture(
                      self._phoenix_spec.blocks_to_use,
                      self._phoenix_spec.minimum_depth,
                  ),
                  self._phoenix_spec.problem_type,
              ),
              None,
          )
  
      # Increase depth if possible.
      (
          best_architecture,
          best_trial,
      ) = common.choose_random_trial_and_get_architecture(best_trials)
      allowed_depth = common.get_allowed_depth(
          num_completed_trials,
          depth_thresholds=self._phoenix_spec.increase_complexity_minimum_trials,
          max_depth=self._max_depth,
      )
      logging.info("Maximal depth allowed: %d", allowed_depth)
      explore_mode = common.random(
          self._phoenix_spec.increase_complexity_probability
      )
      new_block = block_builder.BlockType[
          common.get_random_block(self._phoenix_spec.blocks_to_use)
      ]
  
      if best_architecture.size < allowed_depth and explore_mode:
          common.write_fork_edge(model_dir, my_trial_id, best_trial)
          return (
              architecture_utils.increase_structure_depth(
                  best_architecture,
                  new_block,
                  self._phoenix_spec.problem_type,
              ),
              best_trial,
          )
  
      # Otherwise enter evolutionary mode.
      logging.info("using evolution")
  
      output_architecture = common.mutate_replace(
          best_architecture, new_block
      )
      output_architecture = [
          block_builder.BlockType(x) for x in output_architecture
      ]
      common.write_fork_edge(model_dir, my_trial_id, best_trial)
      return (
          np.array(
              architecture_utils.fix_architecture_order(
                  output_architecture, self._phoenix_spec.problem_type
              )
          ),
          best_trial,
      )
  
file_path: model_search/model_search/search/coordinate_descent.py
imports: from absl import logging
  from model_search import block_builder
  from model_search.architecture import architecture_utils
  from model_search.search import common
  from model_search.search import search_algorithm
  import numpy
label_desc: Use image node_id 2 for calling the CoordinateDescent obj's underlying member method code with example usage: obj.get_suggestion(trials, hparams, my_trial_id, model_dir) and returns: np,  best_trial, common,  None, architecture_utils,  best_trial