






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

import numpy as np
import torch
from utils_hans import HansDataset, InputFeatures, hans_processors, hans_tasks_num_labels

import transformers
from transformers import (
    AutoConfig,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    HfArgumentParser,
    Trainer,
    TrainingArguments,
    default_data_collator,
    set_seed,
)
from transformers.trainer_utils import is_main_process


a 			=							logging.getLogger(__name__)
@dataclass
class 							__snake_case:
 lowercase			:							Optional[int]		   =		field(
     metadata={'''help''': '''Path to pretrained model or model identifier from huggingface.co/models'''}   )
 lowercase			:							Union[str, Any]		   =		field(
     default=__UpperCamelCase  ,							metadata={'''help''': '''Pretrained config name or path if not the same as model_name'''}   )
 lowercase			:							Any		   =		field(
     default=__UpperCamelCase  ,							metadata={'''help''': '''Pretrained tokenizer name or path if not the same as model_name'''}   )
 lowercase			:							List[str]		   =		field(
     default=__UpperCamelCase  ,							metadata={'''help''': '''Where do you want to store the pretrained models downloaded from huggingface.co'''}  ,							)
@dataclass
class 							__snake_case:
 lowercase			:							str		   =		field(
     metadata={'''help''': '''The name of the task to train selected in the list: ''' + ''', '''.join(hans_processors.keys()   )}   )
 lowercase			:							int		   =		field(
     metadata={'''help''': '''The input data dir. Should contain the .tsv files (or other data files) for the task.'''}   )
 lowercase			:							Dict		   =		field(
     default=1_28  ,							metadata={
         '''help''': (
             '''The maximum total input sequence length after tokenization. Sequences longer '''
             '''than this will be truncated, sequences shorter will be padded.'''
         )
     }  ,							)
 lowercase			:							List[Any]		   =		field(
     default=__UpperCamelCase  ,							metadata={'''help''': '''Overwrite the cached training and evaluation sets'''}   )
def    a__    (	A       ):
   lowercase__    :						str       =			default_data_collator(A       )
   lowercase__    :						Optional[int]       =			batch.pop("""pairID"""		,					A       )
   return batch
def    a__    (	):
   lowercase__    :						int       =			HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)       )
   lowercase__    :						List[str]       =			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"""		,					A       )

   # Set seed
   set_seed(training_args.seed       )

   try:
      lowercase__    :						Optional[Any]       =			hans_tasks_num_labels[data_args.task_name]
   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.

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

   # Get datasets
   lowercase__    :						Optional[int]       =			(
       HansDataset(
           data_dir=data_args.data_dir		,					tokenizer=A		,					task=data_args.task_name		,					max_seq_length=data_args.max_seq_length		,					overwrite_cache=data_args.overwrite_cache		,					)
       if training_args.do_train
       else None
   )
   lowercase__    :						Optional[int]       =			(
       HansDataset(
           data_dir=data_args.data_dir		,					tokenizer=A		,					task=data_args.task_name		,					max_seq_length=data_args.max_seq_length		,					overwrite_cache=data_args.overwrite_cache		,					evaluate=A		,					)
       if training_args.do_eval
       else None
   )

   # Initialize our Trainer
   lowercase__    :						Union[str, Any]       =			Trainer(
       model=A		,					args=A		,					train_dataset=A		,					eval_dataset=A		,					data_collator=A		,					)

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

      lowercase__    :						Dict       =			trainer.predict(A       )
      lowercase__    :						Optional[int]       =			output.predictions
      lowercase__    :						Dict       =			np.argmax(A		,					axis=1       )

      lowercase__    :						Optional[int]       =			[ex.pairID for ex in eval_dataset]
      lowercase__    :						Any       =			os.path.join(training_args.output_dir		,					"""hans_predictions.txt"""       )
      lowercase__    :						Optional[Any]       =			eval_dataset.get_labels()
      if trainer.is_world_master():
         with open(A		,					"""w"""       ) as writer:
            writer.write("""pairID,gold_label\n"""       )
            for pid, pred in zip(A		,					A       ):
               writer.write("""ex""" + str(A       ) + """,""" + label_list[int(A       )] + """\n"""       )

      trainer._log(output.metrics       )
def    a__    (	A       ):
   main()


if __name__ == "__main__":
 main()










import argparse

import torch

from transformers import ElectraConfig, ElectraForMaskedLM, ElectraForPreTraining, load_tf_weights_in_electra
from transformers.utils import logging


logging.set_verbosity_info()






def    UpperCamelCase__  (   UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase     )     ->		str:







							"""simple docstring"""





							_a  :    Union[str, Any]			=						ElectraConfig.from_json_file(UpperCAmelCase     )
							print(F'Building PyTorch model from configuration: {config}'     )

							if discriminator_or_generator == "discriminator":
														_a  :    int			=						ElectraForPreTraining(UpperCAmelCase     )
							elif discriminator_or_generator == "generator":
														_a  :    Any			=						ElectraForMaskedLM(UpperCAmelCase     )
							else:
														raise ValueError('''The discriminator_or_generator argument should be either \'discriminator\' or \'generator\''''     )

							# Load weights from tf checkpoint
							load_tf_weights_in_electra(
							    UpperCAmelCase    ,	UpperCAmelCase    ,	UpperCAmelCase    ,	discriminator_or_generator=UpperCAmelCase     )

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


if __name__ == "__main__":
						__lowerCamelCase						= 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(
						    '--config_file',
						    default=None,
						    type=str,
						    required=True,
						    help='The config json file corresponding to the pre-trained model. \nThis specifies the model architecture.',
						)
						parser.add_argument(
						    '--pytorch_dump_path', default=None, type=str, required=True, help='Path to the output PyTorch model.'
						)
						parser.add_argument(
						    '--discriminator_or_generator',
						    default=None,
						    type=str,
						    required=True,
						    help=(
						        'Whether to export the generator or the discriminator. Should be a string, either \'discriminator\' or '
						        '\'generator\'.'
						    ),
						)
						__lowerCamelCase						= parser.parse_args()
						convert_tf_checkpoint_to_pytorch(
						    args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path, args.discriminator_or_generator
						)