code: def benchmark_one(
      experiment: Dict[str, Union[str, Dict[str, str]]]
  ) -> None:
      """Run a Ludwig exepriment and track metrics given a dataset name.
  
      Args:
          experiment: dictionary containing the dataset name, config path, and experiment name.
      """
      logger.info(
          f"\nRunning experiment *{experiment['experiment_name']}* on dataset *{experiment['dataset_name']}*"
      )
  
      # configuring backend and paths
      model_config = setup_experiment(experiment)
  
      # loading dataset
      # dataset_module = importlib.import_module(f"ludwig.datasets.{experiment['dataset_name']}")
      dataset_module = ludwig.datasets.get_dataset(
          experiment["dataset_name"]
      )
      dataset = load_from_module(
          dataset_module, model_config["output_features"][0]
      )
  
      if experiment["hyperopt"]:
          # run hyperopt
          hyperopt(
              config=model_config,
              dataset=dataset,
              output_directory=experiment["experiment_name"],
              skip_save_model=True,
              skip_save_training_statistics=True,
              skip_save_progress=True,
              skip_save_log=True,
              skip_save_processed_input=True,
              skip_save_unprocessed_output=True,
              skip_save_predictions=True,
              skip_save_training_description=True,
              hyperopt_log_verbosity=0,
          )
          delete_hyperopt_outputs(experiment["experiment_name"])
      else:
          backend = None
          ludwig_profiler_callbacks = None
          if experiment["profiler"]["enable"]:
              ludwig_profiler_callbacks = [
                  LudwigProfilerCallback(experiment)
              ]
              # Currently, only local backend is supported with LudwigProfiler.
              backend = "local"
              logger.info(
                  "Currently, only local backend is supported with LudwigProfiler."
              )
          # run model and capture metrics
          model = LudwigModel(
              config=model_config,
              callbacks=ludwig_profiler_callbacks,
              logging_level=logging.ERROR,
              backend=backend,
          )
          model.experiment(
              dataset=dataset,
              output_directory=experiment["experiment_name"],
              skip_save_processed_input=True,
              skip_save_unprocessed_output=True,
              skip_save_predictions=True,
              skip_collect_predictions=True,
          )
          delete_model_checkpoints(experiment["experiment_name"])
  
file_path: ludwig/ludwig/benchmarking/benchmark.py
imports: import argparse
  import importlib
  import logging
  import os
  import shutil
  from typing import Any, Dict, Tuple, Union
  import ludwig.datasets
  from ludwig.api import LudwigModel
  from ludwig.benchmarking.artifacts import BenchmarkingResult, build_benchmarking_result
  from ludwig.benchmarking.profiler_callbacks import LudwigProfilerCallback
  from ludwig.benchmarking.utils import create_default_config, delete_hyperopt_outputs, delete_model_checkpoints, export_artifacts, load_from_module, populate_benchmarking_config_with_defaults, propagate_global_parameters, save_yaml, validate_benchmarking_config
  from ludwig.contrib import add_contrib_callback_args
  from ludwig.hyperopt.run import hyperopt
  from ludwig.utils.data_utils import load_yaml
label_desc: Use image node_id 2 for calling a global function with example usage: benchmark_one(experiment) without return types