code: def main(
      name,
      *,
      variant=None,
      legacy=True,
      new=True,
      start=True,
      iteration=True,
      num_starts=3,
      num_samples=10_000,
      temp_root=None,
      num_workers=0,
  ):
      benchmarks = [
          benchmark
          for benchmark in DATASET_BENCHMARKS
          if benchmark.name == name
          and (variant is None or benchmark.variant == variant)
      ]
      if not benchmarks:
          msg = f"No DatasetBenchmark available for dataset '{name}'"
          if variant is not None:
              msg += f" and variant '{variant}'"
          raise ValueError(msg)
  
      for benchmark in benchmarks:
          print("#" * 80)
          print(
              f"{benchmark.name}"
              + (
                  f" ({benchmark.variant})"
                  if benchmark.variant is not None
                  else ""
              )
          )
  
          if legacy and start:
              print(
                  "legacy",
                  "cold_start",
                  Measurement.time(
                      benchmark.legacy_cold_start(
                          temp_root, num_workers=num_workers
                      ),
                      number=num_starts,
                  ),
              )
              print(
                  "legacy",
                  "warm_start",
                  Measurement.time(
                      benchmark.legacy_warm_start(
                          temp_root, num_workers=num_workers
                      ),
                      number=num_starts,
                  ),
              )
  
          if legacy and iteration:
              print(
                  "legacy",
                  "iteration",
                  Measurement.iterations_per_time(
                      benchmark.legacy_iteration(
                          temp_root,
                          num_workers=num_workers,
                          num_samples=num_samples,
                      )
                  ),
              )
  
          if new and start:
              print(
                  "new",
                  "cold_start",
                  Measurement.time(
                      benchmark.new_cold_start(num_workers=num_workers),
                      number=num_starts,
                  ),
              )
  
          if new and iteration:
              print(
                  "new",
                  "iteration",
                  Measurement.iterations_per_time(
                      benchmark.new_iteration(
                          num_workers=num_workers,
                          num_samples=num_samples,
                      )
                  ),
              )
  
imports: import argparse
  import collections.abc
  import contextlib
  import inspect
  import itertools
  import os
  import os.path
  import pathlib
  import shutil
  import sys
  import tempfile
  import time
  import unittest.mock
  import warnings
  import torch
  from torch.utils.data import DataLoader
  from torch.utils.data.dataloader_experimental import DataLoader2
  from torchvision import datasets
  from torchvision.datasets.utils import extract_archive
  from torchvision.prototype import datasets
  from torchvision.transforms import PILToTensor
label_desc: Use image node_id 1 for calling a global function with example usage: main(name) without return types