class_docstr: Implementation of HpoExecutor Interface, where our custom logic is used as the backend
code: def get_hpo_results(
      self, model_name, model_path_root, time_start, **kwargs
  ):
      assert (
          self.scheduler is not None
      ), "Call `execute()` before `get_hpo_results()`"
      # Store results / models from this HPO run:
      best_hp = (
          self.scheduler.get_best_config()
      )  # best_hp only contains searchable stuff
      hpo_results = {
          "best_reward": self.scheduler.get_best_reward(),
          "best_config": best_hp,
          "total_time": time.time() - time_start,
          "metadata": self.scheduler.metadata,
          "training_history": self.scheduler.training_history,
          "config_history": self.scheduler.config_history,
          "reward_attr": self.scheduler._reward_attr,
      }
  
      hpo_models = (
          {}
      )  # stores all the model names and file paths to model objects created during this HPO run.
      hpo_model_performances = {}
      for trial in sorted(hpo_results["config_history"].keys()):
          # TODO: ignore models which were killed early by scheduler (eg. in Hyperband). How to ID these?
          file_id = f"T{trial+1}"  # unique identifier to files from this trial
          trial_model_name = os.path.join(model_name, file_id)
          trial_model_path = os.path.join(
              model_path_root, trial_model_name
          )
          trial_reward = self.scheduler.searcher.get_reward(
              hpo_results["config_history"][trial]
          )
          if trial_reward is None or trial_reward == float("-inf"):
              continue
          hpo_models[trial_model_name] = dict(
              path=trial_model_path,
              val_score=trial_reward,
              trial=trial,
              hyperparameters=hpo_results["config_history"][trial],
          )
  
          hpo_model_performances[trial_model_name] = trial_reward
  
      hpo_results["hpo_model_performances"] = hpo_model_performances
  
      logger.log(
          15,
          "Time for %s model HPO: %s"
          % (model_name, str(hpo_results["total_time"])),
      )
      logger.log(
          15,
          "Best hyperparameter configuration for %s model: "
          % model_name,
      )
      logger.log(15, str(best_hp))
  
      return hpo_models, hpo_results
  
imports: from __future__ import annotations
  import copy
  import logging
  import math
  import os
  import time
  from abc import ABC, abstractmethod
  from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional, Tuple, Union
  import pandas
  from autogluon.common import space
  from autogluon.common.utils.resource_utils import ResourceManager
  from autogluon.common.utils.s3_utils import is_s3_url
  from ..ray.resources_calculator import ResourceCalculator
  from ..scheduler.scheduler_factory import scheduler_factory
  from ..utils.savers import save_pkl
  from .constants import CUSTOM_BACKEND, RAY_BACKEND
  from .exceptions import EmptySearchSpace
label_desc: Use image node_id 10 for calling the CustomHpoExecutor obj's underlying member method code with example usage: obj.get_hpo_results(model_name, model_path_root, time_start) and returns: hpo_models,  hpo_results