



'''simple docstring'''






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

import transformers
from transformers import (
    AutoConfig,
    AutoModelForQuestionAnswering,
    AutoTokenizer,
    DataCollatorWithPadding,
    HfArgumentParser,
    SquadDataset,
    Trainer,
    TrainingArguments,
)
from transformers import SquadDataTrainingArguments as DataTrainingArguments
from transformers.trainer_utils import is_main_process


A_				:					int							=      logging.getLogger(__name__)



@dataclass
class 				lowercase			:


 """simple docstring"""


 UpperCAmelCase		      =    field(
     metadata={"""help""": """Path to pretrained model or model identifier from huggingface.co/models"""}							)
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Pretrained config name or path if not the same as model_name"""}							)
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Pretrained tokenizer name or path if not the same as model_name"""}							)
 UpperCAmelCase		      =    field(default=_lowerCamelCase   ,   metadata={"""help""": """Set this flag to use fast tokenization."""}							)
 # If you want to tweak more attributes on your tokenizer, you should do it in a distinct script,
 # or just modify its tokenizer_config.json.
 UpperCAmelCase		      =    field(
     default=_lowerCamelCase   ,   metadata={"""help""": """Where do you want to store the pretrained models downloaded from huggingface.co"""}   ,   )







def        snake_case_   (	)->						Dict:





       '''simple docstring'''


       _UpperCAmelCase    :		Optional[Any]     	=					HfArgumentParser((ModelArguments, DataTrainingArguments, TrainingArguments)						)

       if len(sys.argv						) == 2 and sys.argv[1].endswith(""".json"""						):
              # If we pass only one argument to the script and it's the path to a json file,
              # let's parse it to get our arguments.
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		str     	=					parser.parse_json_file(json_file=os.path.abspath(sys.argv[1]						)						)
       else:
              _UpperCAmelCase	,_UpperCAmelCase	,_UpperCAmelCase    :		Optional[int]     	=					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_						)

       # Prepare Question-Answering task
       # Load pretrained model and tokenizer
       #
       # Distributed training:
       # The .from_pretrained methods guarantee that only one local process can concurrently
       # download model & vocab.

       _UpperCAmelCase    :		Optional[Any]     	=					AutoConfig.from_pretrained(
           model_args.config_name if model_args.config_name else model_args.model_name_or_path			,  cache_dir=model_args.cache_dir			,  )
       _UpperCAmelCase    :		List[Any]     	=					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			,  use_fast=lowerCAmelCase_			,  )
       _UpperCAmelCase    :		List[str]     	=					AutoModelForQuestionAnswering.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
       _UpperCAmelCase    :		Tuple     	=					hasattr(model.config			,  """lang2id"""						)
       _UpperCAmelCase    :		Tuple     	=					(
           SquadDataset(
               lowerCAmelCase_			,  tokenizer=lowerCAmelCase_			,  is_language_sensitive=lowerCAmelCase_			,  cache_dir=model_args.cache_dir						)
           if training_args.do_train
           else None
       )
       _UpperCAmelCase    :		Optional[Any]     	=					(
           SquadDataset(
               lowerCAmelCase_			,  tokenizer=lowerCAmelCase_			,  mode="""dev"""			,  is_language_sensitive=lowerCAmelCase_			,  cache_dir=model_args.cache_dir			,  )
           if training_args.do_eval
           else None
       )

       # Data collator
       _UpperCAmelCase    :		Optional[int]     	=					DataCollatorWithPadding(lowerCAmelCase_			,  pad_to_multiple_of=8						) if training_args.fpaa else None

       # Initialize our Trainer
       _UpperCAmelCase    :		Union[str, Any]     	=					Trainer(
           model=lowerCAmelCase_			,  args=lowerCAmelCase_			,  train_dataset=lowerCAmelCase_			,  eval_dataset=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						)




def        snake_case_   (	lowerCAmelCase_						)->						Any:





       '''simple docstring'''


       main()


if __name__ == "__main__":
   main()




"""simple docstring"""


from __future__ import annotations

import unittest

from transformers import OpenAIGPTConfig, is_tf_available
from transformers.testing_utils import require_tf, slow

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, ids_tensor, random_attention_mask
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers.models.openai.modeling_tf_openai import (
      TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFOpenAIGPTDoubleHeadsModel,
      TFOpenAIGPTForSequenceClassification,
      TFOpenAIGPTLMHeadModel,
      TFOpenAIGPTModel,
  )
class   UpperCAmelCase_	:
    def __init__(	self			:       Tuple   ,						_lowercase			:       List[str]   ,						)						->    Tuple:
       _lowercase							     =       parent
       _lowercase							     =       1_3
       _lowercase							     =       7
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       True
       _lowercase							     =       9_9
       _lowercase							     =       3_2
       _lowercase							     =       2
       _lowercase							     =       4
       _lowercase							     =       3_7
       _lowercase							     =       "gelu"
       _lowercase							     =       0.1
       _lowercase							     =       0.1
       _lowercase							     =       5_1_2
       _lowercase							     =       1_6
       _lowercase							     =       2
       _lowercase							     =       0.02
       _lowercase							     =       3
       _lowercase							     =       4
       _lowercase							     =       None
       _lowercase							     =       self.vocab_size - 1
    def 		_lowerCamelCase      (	self			:       int		)						->    List[Any]:
       _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.vocab_size		)

       _lowercase							     =       None
       if self.use_input_mask:
          _lowercase							     =       random_attention_mask([self.batch_size, self.seq_length]		)

       _lowercase							     =       None
       if self.use_token_type_ids:
          _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.type_vocab_size		)

       _lowercase							     =       None
       if self.use_mc_token_ids:
          _lowercase							     =       ids_tensor([self.batch_size, self.num_choices]   ,						self.seq_length		)

       _lowercase							     =       None
       _lowercase							     =       None
       _lowercase							     =       None
       if self.use_labels:
          _lowercase							     =       ids_tensor([self.batch_size]   ,						self.type_sequence_label_size		)
          _lowercase							     =       ids_tensor([self.batch_size, self.seq_length]   ,						self.num_labels		)
          _lowercase							     =       ids_tensor([self.batch_size]   ,						self.num_choices		)

       _lowercase							     =       OpenAIGPTConfig(
           vocab_size=self.vocab_size   ,						n_embd=self.hidden_size   ,						n_layer=self.num_hidden_layers   ,						n_head=self.num_attention_heads   ,						n_positions=self.max_position_embeddings   ,						pad_token_id=self.pad_token_id   ,						)

       _lowercase							     =       ids_tensor([self.num_hidden_layers, self.num_attention_heads]   ,						2		)

       return (
           config,
           input_ids,
           input_mask,
           head_mask,
           token_type_ids,
           mc_token_ids,
           sequence_labels,
           token_labels,
           choice_labels,
       )
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[Any]   ,						_lowercase			:       int   ,						*_lowercase			:       List[str]		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       [input_ids, input_mask]
       _lowercase							     =       model(_lowercase		)

       _lowercase							     =       model(_lowercase		)

       self.parent.assertEqual(result.last_hidden_state.shape   ,						(self.batch_size, self.seq_length, self.hidden_size)		)
    def 		_lowerCamelCase      (	self			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       str   ,						_lowercase			:       Dict   ,						_lowercase			:       List[str]   ,						*_lowercase			:       Optional[Any]		)						->    Dict:
       _lowercase							     =       TFOpenAIGPTLMHeadModel(config=_lowercase		)
       _lowercase							     =       {"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.seq_length, self.vocab_size)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       int   ,						_lowercase			:       str   ,						_lowercase			:       int   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       Tuple		)						->    Optional[int]:
       _lowercase							     =       TFOpenAIGPTDoubleHeadsModel(config=_lowercase		)

       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)
       _lowercase							     =       tf.tile(tf.expand_dims(_lowercase   ,						1		)   ,						(1, self.num_choices, 1)		)

       _lowercase							     =       {
           "input_ids": multiple_choice_inputs_ids,
           "mc_token_ids": mc_token_ids,
           "attention_mask": multiple_choice_input_mask,
           "token_type_ids": multiple_choice_token_type_ids,
       }
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(
           result.logits.shape   ,						(self.batch_size, self.num_choices, self.seq_length, self.vocab_size)		)
       self.parent.assertEqual(result.mc_logits.shape   ,						(self.batch_size, self.num_choices)		)
    def 		_lowerCamelCase      (	self			:       Union[str, Any]   ,						_lowercase			:       List[Any]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Any   ,						_lowercase			:       Optional[Any]   ,						_lowercase			:       List[Any]   ,						*_lowercase			:       str		)						->    str:
       _lowercase							     =       self.num_labels
       _lowercase							     =       ids_tensor([self.batch_size]   ,						self.type_sequence_label_size		)
       _lowercase							     =       {
           "input_ids": input_ids,
           "attention_mask": input_mask,
           "token_type_ids": token_type_ids,
           "labels": sequence_labels,
       }
       _lowercase							     =       TFOpenAIGPTForSequenceClassification(_lowercase		)
       _lowercase							     =       model(_lowercase		)
       self.parent.assertEqual(result.logits.shape   ,						(self.batch_size, self.num_labels)		)




    def 		_lowerCamelCase      (	self			:       str		)						->    Tuple:
       _lowercase							     =       self.prepare_config_and_inputs()

       (
           (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  (
           _lowercase
       )     ,  
       )							     =       config_and_inputs

       _lowercase							     =       {"input_ids": input_ids, "token_type_ids": token_type_ids, "attention_mask": input_mask}
       return config, inputs_dict
@require_tf
class   UpperCAmelCase_	(				lowercase__,    lowercase__,    unittest.TestCase   ):
    snake_case_											=      (
        (TFOpenAIGPTModel, TFOpenAIGPTLMHeadModel, TFOpenAIGPTDoubleHeadsModel, TFOpenAIGPTForSequenceClassification)
        if is_tf_available()
        else ()
    )
    snake_case_											=      (
        (TFOpenAIGPTLMHeadModel,) if is_tf_available() else ()
    )  # TODO (PVP): Add Double HeadsModel when generate() function is changed accordingly
    snake_case_											=      (
        {
            """feature-extraction""": TFOpenAIGPTModel,
            """text-classification""": TFOpenAIGPTForSequenceClassification,
            """text-generation""": TFOpenAIGPTLMHeadModel,
            """zero-shot""": TFOpenAIGPTForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    snake_case_											=      False
    snake_case_											=      False
    def 		_lowerCamelCase      (	self			:       Optional[int]   ,						_lowercase			:       Optional[int]   ,						_lowercase			:       List[str]   ,						_lowercase			:       Tuple   ,						_lowercase			:       Union[str, Any]   ,						_lowercase			:       Any		)						->    List[str]:
       if pipeline_test_casse_name == "ZeroShotClassificationPipelineTests":
          # Get `tokenizer does not have a padding token` error for both fast/slow tokenizers.
          # `OpenAIGPTConfig` was never used in pipeline tests, either because of a missing checkpoint or because a
          # tiny config could not be created.
          return True

       return False
    def 		_lowerCamelCase      (	self			:       Union[str, Any]		)						->    str:
       _lowercase							     =       TFOpenAIGPTModelTester(self		)
       _lowercase							     =       ConfigTester(self   ,						config_class=_lowercase   ,						n_embd=3_7		)
    def 		_lowerCamelCase      (	self			:       List[Any]		)						->    Optional[int]:
       self.config_tester.run_common_tests()
    def 		_lowerCamelCase      (	self			:       Any		)						->    List[str]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_model(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[int]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_lm_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    List[Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_double_head(*_lowercase		)
    def 		_lowerCamelCase      (	self			:       int		)						->    Union[str, Any]:
       _lowercase							     =       self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_openai_gpt_for_sequence_classification(*_lowercase		)




    @slow
    def 		_lowerCamelCase      (	self			:       Tuple		)						->    Dict:
       for model_name in TF_OPENAI_GPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
          _lowercase							     =       TFOpenAIGPTModel.from_pretrained(_lowercase		)
          self.assertIsNotNone(_lowercase		)
@require_tf
class   UpperCAmelCase_	(				unittest.TestCase   ):
    @slow
    def 		_lowerCamelCase      (	self			:       Optional[Any]		)						->    Union[str, Any]:
       _lowercase							     =       TFOpenAIGPTLMHeadModel.from_pretrained("openai-gpt"		)
       _lowercase							     =       tf.convert_to_tensor([[4_8_1, 4_7_3_5, 5_4_4]]   ,						dtype=tf.intaa		)  # the president is
       _lowercase							     =       [
           4_8_1,
           4_7_3_5,
           5_4_4,
           2_4_6,
           9_6_3,
           8_7_0,
           7_6_2,
           2_3_9,
           2_4_4,
           4_0_4_7_7,
           2_4_4,
           2_4_9,
           7_1_9,
           8_8_1,
           4_8_7,
           5_4_4,
           2_4_0,
           2_4_4,
           6_0_3,
           4_8_1,
       ]  # the president is a very good man. " \n " i\'m sure he is, " said the

       _lowercase							     =       model.generate(_lowercase   ,						do_sample=_lowercase		)
       self.assertListEqual(output_ids[0].numpy().tolist()   ,						_lowercase		)