class_docstr: The Slurm Evaluator is a class designed to continuously monitor VISSL pretrainings
  and launch evaluations as checkpoints become available. The method takes a
  config dictionary consisting of the training checkpoint directory, an array of
  benchmarks, and information on how often to evaluate the trainings.
code: def _generate_initial_benchmark_results(self):
      default_checkpoint = os.path.join(
          self.evaluation_dir(), "evaluation_metrics.json"
      )
      autoload_slurm_evaluator_checkpoint = (
          self.autoload_slurm_evaluator_checkpoint
          and g_pathmgr.exists(default_checkpoint)
      )
  
      if (
          autoload_slurm_evaluator_checkpoint
          or self.slurm_evaluator_checkpoint
      ):
          return self._load_evaluation_results_checkpoint()
  
      evaluation_configs = {}
  
      for benchmark in self.benchmarks:
          default_evaluation_name = os.path.split(
              benchmark["config_files"][0]
          )[-1]
          evaluation_name = (
              benchmark.get("evaluation_name")
              or default_evaluation_name
          )
  
          last_phase = self.training_config.OPTIMIZER.num_epochs - 1
  
          # TODO: Can we retrieve this from CheckpointWriter?
          if self.evaluate_final_phase:
              # Evaluate Last phase checkpoint
              training_checkpoint = (
                  f"model_final_checkpoint_phase{ last_phase }"
              )
              self._set_initial_benchmark_result(
                  benchmark,
                  training_checkpoint,
                  evaluation_name,
                  evaluation_configs,
              )
  
          if self.evaluation_phase_freq > -1:
              # Evaluate every "evaluation_phase_freq" phase checkpoint.
              evaluate_epochs = range(
                  self.evaluation_phase_freq, last_phase
              )[:: self.evaluation_phase_freq]
              for epoch in evaluate_epochs:
                  training_checkpoint = f"model_phase{epoch}"
                  self._set_initial_benchmark_result(
                      benchmark,
                      training_checkpoint,
                      evaluation_name,
                      evaluation_configs,
                  )
  
          if self.evaluation_iter_freq > -1:
              # Evaluate every "evaluation_iter_freq" iteration checkpoints.
              evaluate_iterations = range(
                  self.evaluation_iter_freq,
                  self.max_training_iterations,
              )[:: self.evaluation_iter_freq]
              for iteration in evaluate_iterations:
                  training_checkpoint = f"model_iteration{iteration}"
                  self._set_initial_benchmark_result(
                      benchmark,
                      training_checkpoint,
                      evaluation_name,
                      evaluation_configs,
                  )
  
      return evaluation_configs
  
imports: import collections
  import json
  import logging
  import os
  import time
  from datetime import datetime
  from pathlib import Path
  from typing import List
  import submitit
  from iopath.common.file_io import g_pathmgr
  from vissl.config.attr_dict import AttrDict
  from vissl.utils.distributed_launcher import launch_distributed_on_slurm
  from vissl.utils.hydra_config import compose_hydra_configuration, convert_to_attrdict
  from vissl.utils.io import load_file, makedir
  from vissl.utils.misc import flatten_dict, retry
label_desc: Use image node_id 20 for calling the BenchmarkSuiteScheduler obj's underlying member method code with example usage: obj._generate_initial_benchmark_results() and returns: evaluation_configs, self