


import logging
import os
from dataclasses import dataclass, field
from typing import Dict, Optional

import numpy as np
from utils_multiple_choice import MultipleChoiceDataset, Split, processors

import transformers
from transformers import (
    AutoConfig,
    AutoModelForMultipleChoice,
    AutoTokenizer,
    DataCollatorWithPadding,
    EvalPrediction,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    set_seed,
)
from transformers.trainer_utils import is_main_process


lowercase__				     =		logging.getLogger(__name__)






def __UpperCamelCase   (			__lowerCamelCase		: Dict      ,  __lowerCamelCase		: Union[str, Any]				)      ->     List[str]:







     '''simple docstring'''






     return (preds == labels).mean()





@dataclass
class 						__SCREAMING_SNAKE_CASE					:
     UpperCAmelCase 					=				field(
         metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''} )
     UpperCAmelCase 					=				field(
         default=__a ,			metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''} )
     UpperCAmelCase 					=				field(
         default=__a ,			metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''} )
     UpperCAmelCase 					=				field(
         default=__a ,			metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''} ,			)







@dataclass
class 						__SCREAMING_SNAKE_CASE					:
     UpperCAmelCase 					=				field(metadata={'''help''': '''The name of the task to train on: ''' + ''', '''.join(processors.keys() )} )
     UpperCAmelCase 					=				field(metadata={'''help''': '''Should contain the data files for the task.'''} )
     UpperCAmelCase 					=				field(
         default=128 ,			metadata={
             '''help''': (
                 '''The maximum total input sequence length after tokenization. Sequences longer '''
                 '''than this will be truncated, sequences shorter will be padded.'''
             )
         } ,			)
     UpperCAmelCase 					=				field(
         default=__a ,			metadata={'''help''': '''Overwrite the cached training and evaluation sets'''} )







def __UpperCamelCase   (			)      ->     str:







     '''simple docstring'''






     _a						=		HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)				)
     _a			,			_a			,			_a						=		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.fpaa      ,  )
     # 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"      ,  lowercase__				)

     # Set seed
     set_seed(training_args.seed				)

     try:
          _a						=		processors[data_args.task_name]()
          _a						=		processor.get_labels()
          _a						=		len(lowercase__				)
     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.

     _a						=		AutoConfig.from_pretrained(
         model_args.config_name if model_args.config_name else model_args.model_name_or_path      ,  num_labels=lowercase__      ,  finetuning_task=data_args.task_name      ,  cache_dir=model_args.cache_dir      ,  )
     _a						=		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      ,  )
     _a						=		AutoModelForMultipleChoice.from_pretrained(
         model_args.model_name_or_path      ,  from_tf=bool(".ckpt" in model_args.model_name_or_path				)      ,  config=lowercase__      ,  cache_dir=model_args.cache_dir      ,  )

     # Get datasets
     _a						=		(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir      ,  tokenizer=lowercase__      ,  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
     )
     _a						=		(
         MultipleChoiceDataset(
             data_dir=data_args.data_dir      ,  tokenizer=lowercase__      ,  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(__lowerCamelCase		: Dict				) -> Dict:
          _a						=		np.argmax(p.predictions      ,  axis=1				)
          return {"acc": simple_accuracy(lowercase__      ,  p.label_ids				)}

     # Data collator
     _a						=		DataCollatorWithPadding(lowercase__      ,  pad_to_multiple_of=8				) if training_args.fpaa else None

     # Initialize our Trainer
     _a						=		Trainer(
         model=lowercase__      ,  args=lowercase__      ,  train_dataset=lowercase__      ,  eval_dataset=lowercase__      ,  compute_metrics=lowercase__      ,  data_collator=lowercase__      ,  )

     # 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
     _a						=		{}
     if training_args.do_eval:
          logger.info("*** Evaluate ***"				)

          _a						=		trainer.evaluate()

          _a						=		os.path.join(training_args.output_dir      ,  "eval_results.txt"				)
          if trainer.is_world_master():
               with open(lowercase__      ,  "w"				) as writer:
                    logger.info("***** Eval results *****"				)
                    for key, value in result.items():
                         logger.info("  %s = %s"      ,  lowercase__      ,  lowercase__				)
                         writer.write("%s = %s\n" % (key, value)				)

                    results.update(lowercase__				)

     return results






def __UpperCamelCase   (			__lowerCamelCase		: Optional[int]				)      ->     Dict:







     '''simple docstring'''






     main()


if __name__ == "__main__":
   main()





'''simple docstring'''

import argparse
import os
import pickle
import sys

import torch

from transformers import TransfoXLConfig, TransfoXLLMHeadModel, load_tf_weights_in_transfo_xl
from transformers.models.transfo_xl import tokenization_transfo_xl as data_utils
from transformers.models.transfo_xl.tokenization_transfo_xl import CORPUS_NAME, VOCAB_FILES_NAMES
from transformers.utils import CONFIG_NAME, WEIGHTS_NAME, logging


logging.set_verbosity_info()

# We do this to be able to load python 2 datasets pickles
# See e.g. https://stackoverflow.com/questions/2121874/python-pickling-after-changing-a-modules-directory/2121918#2121918
lowercase__				     =		data_utils.TransfoXLTokenizer
lowercase__				     =		data_utils.TransfoXLCorpus
lowercase__				     =		data_utils
lowercase__				     =		data_utils






def __UpperCamelCase   (			__lowerCamelCase		: str      ,  __lowerCamelCase		: Tuple      ,  __lowerCamelCase		: Optional[int]      ,  __lowerCamelCase		: Tuple				)      ->     Dict:







     '''simple docstring'''






     if transfo_xl_dataset_file:
          # Convert a pre-processed corpus (see original TensorFlow repo)
          with open(__lowerCamelCase      ,  "rb"				) as fp:
               _a						=		pickle.load(__lowerCamelCase      ,  encoding="latin1"				)
          # Save vocabulary and dataset cache as Dictionaries (should be better than pickles for the long-term)
          _a						=		pytorch_dump_folder_path + "/" + VOCAB_FILES_NAMES["pretrained_vocab_file"]
          print(F"Save vocabulary to {pytorch_vocab_dump_path}"				)
          _a						=		corpus.vocab.__dict__
          torch.save(__lowerCamelCase      ,  __lowerCamelCase				)

          _a						=		corpus.__dict__
          corpus_dict_no_vocab.pop("vocab"      ,  __lowerCamelCase				)
          _a						=		pytorch_dump_folder_path + "/" + CORPUS_NAME
          print(F"Save dataset to {pytorch_dataset_dump_path}"				)
          torch.save(__lowerCamelCase      ,  __lowerCamelCase				)

     if tf_checkpoint_path:
          # Convert a pre-trained TensorFlow model
          _a						=		os.path.abspath(__lowerCamelCase				)
          _a						=		os.path.abspath(__lowerCamelCase				)

          print(F"Converting Transformer XL checkpoint from {tf_path} with config at {config_path}."				)
          # Initialise PyTorch model
          if transfo_xl_config_file == "":
               _a						=		TransfoXLConfig()
          else:
               _a						=		TransfoXLConfig.from_json_file(__lowerCamelCase				)
          print(F"Building PyTorch model from configuration: {config}"				)
          _a						=		TransfoXLLMHeadModel(__lowerCamelCase				)

          _a						=		load_tf_weights_in_transfo_xl(__lowerCamelCase      ,  __lowerCamelCase      ,  __lowerCamelCase				)
          # Save pytorch-model
          _a						=		os.path.join(__lowerCamelCase      ,  __lowerCamelCase				)
          _a						=		os.path.join(__lowerCamelCase      ,  __lowerCamelCase				)
          print(F"Save PyTorch model to {os.path.abspath(__lowerCamelCase				)}"				)
          torch.save(model.state_dict()      ,  __lowerCamelCase				)
          print(F"Save configuration file to {os.path.abspath(__lowerCamelCase				)}"				)
          with open(__lowerCamelCase      ,  "w"      ,  encoding="utf-8"				) as f:
               f.write(config.to_json_string()				)


if __name__ == "__main__":
   lowercase__				     =		argparse.ArgumentParser()
   parser.add_argument(
       "--pytorch_dump_folder_path",
       default=None,
       type=str,
       required=True,
       help="Path to the folder to store the PyTorch model or dataset/vocab.",
   )
   parser.add_argument(
       "--tf_checkpoint_path",
       default="",
       type=str,
       help="An optional path to a TensorFlow checkpoint path to be converted.",
   )
   parser.add_argument(
       "--transfo_xl_config_file",
       default="",
       type=str,
       help=(
           "An optional config json file corresponding to the pre-trained BERT model. \n"
           "This specifies the model architecture."
       ),
   )
   parser.add_argument(
       "--transfo_xl_dataset_file",
       default="",
       type=str,
       help="An optional dataset file to be converted in a vocabulary.",
   )
   lowercase__				     =		parser.parse_args()
   convert_transfo_xl_checkpoint_to_pytorch(
       args.tf_checkpoint_path,
       args.transfo_xl_config_file,
       args.pytorch_dump_folder_path,
       args.transfo_xl_dataset_file,
   )

