


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


__snake_case    :    List[Any]         =     logging.getLogger(__name__)







def 	_UpperCamelCase   (    UpperCamelCase_       :					Union[str, Any]    ,       UpperCamelCase_       :					int		)  ->   str:

						"""simple docstring"""



						return (preds == labels).mean()


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




@dataclass
class     __SCREAMING_SNAKE_CASE					:
						_SCREAMING_SNAKE_CASE	:       Any   =					field(metadata={'''help''': '''The name of the task to train on: ''' + ''', '''.join(processors.keys())})
						_SCREAMING_SNAKE_CASE	:       List[Any]   =					field(metadata={'''help''': '''Should contain the data files for the task.'''})
						_SCREAMING_SNAKE_CASE	:       Optional[Any]   =					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.'''
						        )
						    }		,					)
						_SCREAMING_SNAKE_CASE	:       int   =					field(
						    default=__UpperCAmelCase		,					metadata={'''help''': '''Overwrite the cached training and evaluation sets'''})







def 	_UpperCamelCase   (    )  ->   Optional[Any]:

						"""simple docstring"""



						lowerCAmelCase__    						=						HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)		)
						lowerCAmelCase__						,       lowerCAmelCase__						,       lowerCAmelCase__    						=						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'    ,       __lowerCAmelCase		)

						# Set seed
						set_seed(training_args.seed		)

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

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

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

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

						# Initialize our Trainer
						lowerCAmelCase__    						=						Trainer(
						    model=__lowerCAmelCase    ,       args=__lowerCAmelCase    ,       train_dataset=__lowerCAmelCase    ,       eval_dataset=__lowerCAmelCase    ,       compute_metrics=__lowerCAmelCase    ,       data_collator=__lowerCAmelCase    ,       )

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

												lowerCAmelCase__    						=						trainer.evaluate()

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

																								results.update(__lowerCAmelCase		)

						return results







def 	_UpperCamelCase   (    UpperCamelCase_       :					Tuple		)  ->   Dict:

						"""simple docstring"""



						main()


if __name__ == "__main__":
					main()













import argparse

import torch

from transformers import BertConfig, BertForPreTraining, load_tf_weights_in_bert
from transformers.utils import logging


logging.set_verbosity_info()







def 	_UpperCamelCase   (    UpperCamelCase_       :					Dict    ,       UpperCamelCase_       :					str    ,       UpperCamelCase_       :					Optional[Any]		)  ->   Any:

						"""simple docstring"""



						lowerCAmelCase__    						=						BertConfig.from_json_file(UpperCamelCase_		)
						print(F"Building PyTorch model from configuration: {config}"		)
						lowerCAmelCase__    						=						BertForPreTraining(UpperCamelCase_		)

						# Load weights from tf checkpoint
						load_tf_weights_in_bert(UpperCamelCase_    ,       UpperCamelCase_    ,       UpperCamelCase_		)

						# Save pytorch-model
						print(F"Save PyTorch model to {pytorch_dump_path}"		)
						torch.save(model.state_dict()    ,       UpperCamelCase_		)


if __name__ == "__main__":
					__snake_case    :    Union[str, Any]         =     argparse.ArgumentParser()
					# Required parameters
					parser.add_argument(
					    """--tf_checkpoint_path""", default=None, type=str, required=True, help="""Path to the TensorFlow checkpoint path."""
					)
					parser.add_argument(
					    """--bert_config_file""",
					    default=None,
					    type=str,
					    required=True,
					    help=(
					        """The config json file corresponding to the pre-trained BERT model. \n"""
					        """This specifies the model architecture."""
					    ),
					)
					parser.add_argument(
					    """--pytorch_dump_path""", default=None, type=str, required=True, help="""Path to the output PyTorch model."""
					)
					__snake_case    :    List[str]         =     parser.parse_args()
					convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.bert_config_file, args.pytorch_dump_path)





