class_docstr: Recommender that selects a set of configurations differently in the one-
  dimensional and two- dimensional setting.
  
  In the one-dimensional setting, it greedily picks the configurations which
  provide the lowest joint error. In the multi-dimensional setting, it
  greedily picks the configurations which provide the lowest joint
  hypervolume error.
code: def recommend(
      self,
      dataset: DatasetConfig,
      candidates: Optional[List[ModelConfig]] = None,
      max_count: int = 10,
  ) -> List[Recommendation[ModelConfig]]:
      # Since recommendations are independent of the dataset, we could already compute the
      # result of this function in `fit`. However, we don't have access to `max_count` there.
      # First, we get the model configurations and check that they overlap with the ones we know.
      model_configs = self.generator.generate(candidates)
      assert all(c in self.model_indices for c in model_configs), (
          "Greedy recommender can only provide recommendations for known"
          " configurations."
      )
  
      # Greedily pick configurations. For the multi-objective case, we need to compute the
      # hypervolume error. Hence, for each dataset, we need to compute the hypervolume of the
      # true Pareto front.
      if not self.enforce_single_objective and len(self.objectives) > 1:
          reference = np.ones(len(self.objectives))
          hypervolumes = np.array(
              [
                  pygmo.hypervolume(dataset_metrics).compute(reference)  # type: ignore
                  for dataset_metrics in self.metrics
              ]
          )
  
      available_choices = list(range(len(model_configs)))
      result = []
      while len(result) < max_count:
          # Pick the configuration which minimizes the joint error. For this, we need to compute
          # the error for all possible choices.
          errors = []
          for i, choice in enumerate(available_choices):
              # Compute the joint error with the model configuration of the choice
              all_configs = result + [model_configs[choice]]
              all_performances = self.metrics[
                  :, [self.model_indices[c] for c in all_configs]
              ]
  
              if (
                  self.enforce_single_objective
                  or len(self.objectives) == 1
              ):
                  # If we only consider a single objective, we can simply sum together the
                  # minimum observed values of the objective across the dataset
                  error = all_performances.min(1)[
                      :, i % len(self.objectives)
                  ].sum()
              else:
                  # Otherwise, we need to compute the hypervolumes for all datasets
                  reference = np.ones(len(self.objectives))
                  config_hypervolumes = np.array(
                      [
                          pygmo.hypervolume(  # type: ignore
                              dataset_performances,
                          ).compute(reference)
                          for dataset_performances in all_performances
                      ]
                  )
                  # And then compute the cumulative hypervolume error
                  error = (hypervolumes - config_hypervolumes).sum()  # type: ignore
  
              errors.append(error)
  
          # Get the index with the lowest loss
          lowest = np.argmin(errors)
          index = available_choices[lowest]
          del available_choices[lowest]
          result.append(model_configs[index])
  
      # Eventually return the configurations. The performance cannot be predicted by the greedy
      # surrogate.
      return [Recommendation(r, _dummy_performance()) for r in result]
  
file_path: gluonts/src/gluonts/nursery/tsbench/src/tsbench/recommender/greedy.py
imports: from collections import defaultdict
  from typing import Dict, List, Optional
  import numpy
  import pygmo
  from sklearn.preprocessing import QuantileTransformer, StandardScaler
  from tsbench.config import Config, DatasetConfig, ModelConfig
  from tsbench.evaluations.metrics import Performance
  from ._base import Recommendation, Recommender
  from ._factory import register_recommender
  from .generator import CandidateGenerator
label_desc: Use image node_id 3 for calling the GreedyRecommender obj's underlying member method code with example usage: obj.recommend(dataset, candidates, max_count) and returns: unknown