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 data_args.eval_data_file is None and training_args.do_eval:
          raise ValueError(
              "Cannot do evaluation without an evaluation data file. Either supply a file to --eval_data_file "
              "or remove the --do_eval argument."
          )
      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)
  
      # Load pretrained model and tokenizer
      #
      # Distributed training:
      # The .from_pretrained methods guarantee that only one local process can concurrently
      # download model & vocab.
  
      if model_args.config_name:
          config = AutoConfig.from_pretrained(
              model_args.config_name, cache_dir=model_args.cache_dir
          )
      elif model_args.model_name_or_path:
          config = AutoConfig.from_pretrained(
              model_args.model_name_or_path,
              cache_dir=model_args.cache_dir,
          )
      else:
          config = CONFIG_MAPPING[model_args.model_type]()
          logger.warning(
              "You are instantiating a new config instance from scratch."
          )
  
      if model_args.tokenizer_name:
          tokenizer = AutoTokenizer.from_pretrained(
              model_args.tokenizer_name, cache_dir=model_args.cache_dir
          )
      elif model_args.model_name_or_path:
          tokenizer = AutoTokenizer.from_pretrained(
              model_args.model_name_or_path,
              cache_dir=model_args.cache_dir,
          )
      else:
          raise ValueError(
              "You are instantiating a new tokenizer from scratch. This is not supported, but you can do it from another"
              " script, save it,and load it from here, using --tokenizer_name"
          )
  
      if model_args.model_name_or_path:
          model = AutoModelWithLMHead.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,
          )
      else:
          logger.info("Training new model from scratch")
          model = AutoModelWithLMHead.from_config(config)
  
      model.resize_token_embeddings(len(tokenizer))
  
      if (
          config.model_type
          in ["bert", "roberta", "distilbert", "camembert"]
          and not data_args.mlm
      ):
          raise ValueError(
              "BERT and RoBERTa-like models do not have LM heads but masked LM heads. They must be run using the "
              "--mlm flag (masked language modeling)."
          )
  
      if data_args.block_size <= 0:
          data_args.block_size = tokenizer.max_len
          # Our input block size will be the max possible for the model
      else:
          data_args.block_size = min(
              data_args.block_size, tokenizer.max_len
          )
  
      # Get datasets
  
      train_dataset = (
          get_dataset(
              data_args,
              tokenizer=tokenizer,
              cache_dir=model_args.cache_dir,
          )
          if training_args.do_train
          else None
      )
      eval_dataset = (
          get_dataset(
              data_args,
              tokenizer=tokenizer,
              evaluate=True,
              cache_dir=model_args.cache_dir,
          )
          if training_args.do_eval
          else None
      )
      if config.model_type == "xlnet":
          data_collator = DataCollatorForPermutationLanguageModeling(
              tokenizer=tokenizer,
              plm_probability=data_args.plm_probability,
              max_span_length=data_args.max_span_length,
          )
      else:
          if data_args.mlm and data_args.whole_word_mask:
              data_collator = DataCollatorForWholeWordMask(
                  tokenizer=tokenizer,
                  mlm_probability=data_args.mlm_probability,
              )
          else:
              data_collator = DataCollatorForLanguageModeling(
                  tokenizer=tokenizer,
                  mlm=data_args.mlm,
                  mlm_probability=data_args.mlm_probability,
              )
  
      # Initialize our Trainer
      trainer = Trainer(
          model=model,
          args=training_args,
          data_collator=data_collator,
          train_dataset=train_dataset,
          eval_dataset=eval_dataset,
          prediction_loss_only=True,
      )
  
      # Training
      if training_args.do_train:
          model_path = (
              model_args.model_name_or_path
              if model_args.model_name_or_path is not None
              and os.path.isdir(model_args.model_name_or_path)
              else None
          )
          trainer.train(model_path=model_path)
          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 ***")
  
          eval_output = trainer.evaluate()
  
          perplexity = math.exp(eval_output["eval_loss"])
          result = {"perplexity": perplexity}
  
          output_eval_file = os.path.join(
              training_args.output_dir, "eval_results_lm.txt"
          )
          if trainer.is_world_master():
              with open(output_eval_file, "w") as writer:
                  logger.info("***** Eval results *****")
                  for key in sorted(result.keys()):
                      logger.info("  %s = %s", key, str(result[key]))
                      writer.write(
                          "%s = %s\n" % (key, str(result[key]))
                      )
  
          results.update(result)
  
      return results
  
file_path: transformers/examples/legacy/run_language_modeling.py
imports: import logging
  import math
  import os
  from dataclasses import dataclass, field
  from glob import glob
  from typing import Optional
  from torch.utils.data import ConcatDataset
  import transformers
  from transformers import CONFIG_MAPPING, MODEL_WITH_LM_HEAD_MAPPING, AutoConfig, AutoModelWithLMHead, AutoTokenizer, DataCollatorForLanguageModeling, DataCollatorForPermutationLanguageModeling, DataCollatorForWholeWordMask, HfArgumentParser, LineByLineTextDataset, LineByLineWithRefDataset, PreTrainedTokenizer, TextDataset, Trainer, TrainingArguments, set_seed
  from transformers.trainer_utils import is_main_process
label_desc: Use image node_id 2 for calling a global function with example usage: main() and returns: results