def METHOD_NAME(
    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]