code: def main():
      # See all possible arguments in src/transformers/training_args.py
      # or by passing the --help flag to this script.
      # We now keep distinct sets of args, for a cleaner separation of concerns.
  
      parser = HfArgumentParser(
          (ModelArguments, DataTrainingArguments, TrainingArguments)
      )
      (
          model_args,
          data_args,
          training_args,
      ) = parser.parse_args_into_dataclasses()
  
      if (
          os.path.exists(training_args.output_dir)
          and os.listdir(training_args.output_dir)
          and training_args.do_train
          and not training_args.overwrite_output_dir
      ):
          raise ValueError(
              f"Output directory ({training_args.output_dir}) already exists and is not empty. Use"
              " --overwrite_output_dir to overcome."
          )
  
      # Setup logging
      logging.basicConfig(
          format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
          datefmt="%m/%d/%Y %H:%M:%S",
          level=logging.INFO
          if training_args.local_rank in [-1, 0]
          else logging.WARN,
      )
      logger.warning(
          "Process rank: %s, device: %s, n_gpu: %s, distributed training: %s, 16-bits training: %s",
          training_args.local_rank,
          training_args.device,
          training_args.n_gpu,
          bool(training_args.local_rank != -1),
          training_args.fp16,
      )
      # Set the verbosity to info of the Transformers logger (on main process only):
      if is_main_process(training_args.local_rank):
          transformers.utils.logging.set_verbosity_info()
          transformers.utils.logging.enable_default_handler()
          transformers.utils.logging.enable_explicit_format()
      logger.info("Training/evaluation parameters %s", training_args)
  
      # Set seed
      set_seed(training_args.seed)
  
      try:
          processor = processors[data_args.task_name]()
          label_list = processor.get_labels()
          num_labels = len(label_list)
      except KeyError:
          raise ValueError("Task not found: %s" % (data_args.task_name))
  
      # Load pretrained model and tokenizer
      #
      # Distributed training:
      # The .from_pretrained methods guarantee that only one local process can concurrently
      # download model & vocab.
  
      config = AutoConfig.from_pretrained(
          model_args.config_name
          if model_args.config_name
          else model_args.model_name_or_path,
          num_labels=num_labels,
          finetuning_task=data_args.task_name,
          cache_dir=model_args.cache_dir,
      )
      tokenizer = AutoTokenizer.from_pretrained(
          model_args.tokenizer_name
          if model_args.tokenizer_name
          else model_args.model_name_or_path,
          cache_dir=model_args.cache_dir,
      )
      model = AutoModelForMultipleChoice.from_pretrained(
          model_args.model_name_or_path,
          from_tf=bool(".ckpt" in model_args.model_name_or_path),
          config=config,
          cache_dir=model_args.cache_dir,
      )
  
      # Get datasets
      train_dataset = (
          MultipleChoiceDataset(
              data_dir=data_args.data_dir,
              tokenizer=tokenizer,
              task=data_args.task_name,
              max_seq_length=data_args.max_seq_length,
              overwrite_cache=data_args.overwrite_cache,
              mode=Split.train,
          )
          if training_args.do_train
          else None
      )
      eval_dataset = (
          MultipleChoiceDataset(
              data_dir=data_args.data_dir,
              tokenizer=tokenizer,
              task=data_args.task_name,
              max_seq_length=data_args.max_seq_length,
              overwrite_cache=data_args.overwrite_cache,
              mode=Split.dev,
          )
          if training_args.do_eval
          else None
      )
  
      def compute_metrics(p: EvalPrediction) -> Dict:
          preds = np.argmax(p.predictions, axis=1)
          return {"acc": simple_accuracy(preds, p.label_ids)}
  
      # Data collator
      data_collator = (
          DataCollatorWithPadding(tokenizer, pad_to_multiple_of=8)
          if training_args.fp16
          else None
      )
  
      # Initialize our Trainer
      trainer = Trainer(
          model=model,
          args=training_args,
          train_dataset=train_dataset,
          eval_dataset=eval_dataset,
          compute_metrics=compute_metrics,
          data_collator=data_collator,
      )
  
      # Training
      if training_args.do_train:
          trainer.train(
              model_path=model_args.model_name_or_path
              if os.path.isdir(model_args.model_name_or_path)
              else None
          )
          trainer.save_model()
          # For convenience, we also re-save the tokenizer to the same directory,
          # so that you can share your model easily on huggingface.co/models =)
          if trainer.is_world_master():
              tokenizer.save_pretrained(training_args.output_dir)
  
      # Evaluation
      results = {}
      if training_args.do_eval:
          logger.info("*** Evaluate ***")
  
          result = trainer.evaluate()
  
          output_eval_file = os.path.join(
              training_args.output_dir, "eval_results.txt"
          )
          if trainer.is_world_master():
              with open(output_eval_file, "w") as writer:
                  logger.info("***** Eval results *****")
                  for key, value in result.items():
                      logger.info("  %s = %s", key, value)
                      writer.write("%s = %s\n" % (key, value))
  
                  results.update(result)
  
      return results
  
file_path: H2O/h2o_flexgen/benchmark/third_party/transformers/examples/legacy/multiple_choice/run_multiple_choice.py
imports: import logging
  import os
  from dataclasses import dataclass, field
  from typing import Dict, Optional
  import numpy
  import transformers
  from transformers import AutoConfig, AutoModelForMultipleChoice, AutoTokenizer, DataCollatorWithPadding, EvalPrediction, HfArgumentParser, Trainer, TrainingArguments, set_seed
  from transformers.trainer_utils import is_main_process
  from utils_multiple_choice import MultipleChoiceDataset, Split, processors
label_desc: Use image node_id 2 for calling a global function with example usage: main() and returns: results, dict