



'''simple docstring'''


from __future__ import annotations

import unittest

from transformers import 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 import (
      TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFXLMForMultipleChoice,
      TFXLMForQuestionAnsweringSimple,
      TFXLMForSequenceClassification,
      TFXLMForTokenClassification,
      TFXLMModel,
      TFXLMWithLMHeadModel,
      XLMConfig,
  )







class 						UpperCAmelCase						:


 '''simple docstring'''




 def __init__( self				,	lowerCAmelCase_				,	)			->   Tuple:



      """simple docstring"""







      a_									=parent
      a_									=1_3
      a_									=7
      a_									=True
      a_									=True
      a_									=True
      a_									=True
      a_									=True
      a_									=False
      a_									=False
      a_									=False
      a_									=2
      a_									=9_9
      a_									=0
      a_									=3_2
      a_									=2
      a_									=4
      a_									=0.1
      a_									=0.1
      a_									=5_1_2
      a_									=1_6
      a_									=2
      a_									=0.0_2
      a_									=3
      a_									=4
      a_									="last"
      a_									=True
      a_									=None
      a_									=0




 def    lowercase_	( self)			->   Tuple:



      """simple docstring"""







      a_									=ids_tensor([self.batch_size, self.seq_length]				,	self.vocab_size)
      a_									=random_attention_mask([self.batch_size, self.seq_length]				,	dtype=tf.floataa)

      a_									=None
      if self.use_input_lengths:
           a_									=(
               ids_tensor([self.batch_size]				,	vocab_size=2) + self.seq_length - 2
           )  # small variation of seq_length

      a_									=None
      if self.use_token_type_ids:
           a_									=ids_tensor([self.batch_size, self.seq_length]				,	self.n_langs)

      a_									=None
      a_									=None
      a_									=None
      if self.use_labels:
           a_									=ids_tensor([self.batch_size]				,	self.type_sequence_label_size)
           a_									=ids_tensor([self.batch_size, self.seq_length]				,	self.num_labels)
           a_									=ids_tensor([self.batch_size]				,	2				,	dtype=tf.floataa)
           a_									=ids_tensor([self.batch_size]				,	self.num_choices)

      a_									=XLMConfig(
          vocab_size=self.vocab_size				,	n_special=self.n_special				,	emb_dim=self.hidden_size				,	n_layers=self.num_hidden_layers				,	n_heads=self.num_attention_heads				,	dropout=self.hidden_dropout_prob				,	attention_dropout=self.attention_probs_dropout_prob				,	gelu_activation=self.gelu_activation				,	sinusoidal_embeddings=self.sinusoidal_embeddings				,	asm=self.asm				,	causal=self.causal				,	n_langs=self.n_langs				,	max_position_embeddings=self.max_position_embeddings				,	initializer_range=self.initializer_range				,	summary_type=self.summary_type				,	use_proj=self.use_proj				,	bos_token_id=self.bos_token_id				,	)

      return (
          config,
          input_ids,
          token_type_ids,
          input_lengths,
          sequence_labels,
          token_labels,
          is_impossible_labels,
          choice_labels,
          input_mask,
      )




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   Union[str, Any]:



      """simple docstring"""







      a_									=TFXLMModel(config=lowerCAmelCase_)
      a_									={"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
      a_									=model(lowerCAmelCase_)

      a_									=[input_ids, input_mask]
      a_									=model(lowerCAmelCase_)
      self.parent.assertEqual(result.last_hidden_state.shape				,	(self.batch_size, self.seq_length, self.hidden_size))




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   Any:



      """simple docstring"""







      a_									=TFXLMWithLMHeadModel(lowerCAmelCase_)

      a_									={"input_ids": input_ids, "lengths": input_lengths, "langs": token_type_ids}
      a_									=model(lowerCAmelCase_)

      a_									=outputs

      self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.seq_length, self.vocab_size))




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   str:



      """simple docstring"""







      a_									=TFXLMForQuestionAnsweringSimple(lowerCAmelCase_)

      a_									={"input_ids": input_ids, "lengths": input_lengths}

      a_									=model(lowerCAmelCase_)

      self.parent.assertEqual(result.start_logits.shape				,	(self.batch_size, self.seq_length))
      self.parent.assertEqual(result.end_logits.shape				,	(self.batch_size, self.seq_length))




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   Tuple:



      """simple docstring"""







      a_									=TFXLMForSequenceClassification(lowerCAmelCase_)

      a_									={"input_ids": input_ids, "lengths": input_lengths}

      a_									=model(lowerCAmelCase_)

      self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.type_sequence_label_size))




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   Union[str, Any]:



      """simple docstring"""







      a_									=self.num_labels
      a_									=TFXLMForTokenClassification(config=lowerCAmelCase_)
      a_									={"input_ids": input_ids, "attention_mask": input_mask, "token_type_ids": token_type_ids}
      a_									=model(lowerCAmelCase_)
      self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.seq_length, self.num_labels))




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	)			->   str:



      """simple docstring"""







      a_									=self.num_choices
      a_									=TFXLMForMultipleChoice(config=lowerCAmelCase_)
      a_									=tf.tile(tf.expand_dims(lowerCAmelCase_				,	1)				,	(1, self.num_choices, 1))
      a_									=tf.tile(tf.expand_dims(lowerCAmelCase_				,	1)				,	(1, self.num_choices, 1))
      a_									=tf.tile(tf.expand_dims(lowerCAmelCase_				,	1)				,	(1, self.num_choices, 1))
      a_									={
          "input_ids": multiple_choice_inputs_ids,
          "attention_mask": multiple_choice_input_mask,
          "token_type_ids": multiple_choice_token_type_ids,
      }
      a_									=model(lowerCAmelCase_)
      self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.num_choices))




 def    lowercase_	( self)			->   int:



      """simple docstring"""







      a_									=self.prepare_config_and_inputs()
      (
          (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    (
          a_
      )		,    
      )									=config_and_inputs
      a_									={
          "input_ids": input_ids,
          "token_type_ids": token_type_ids,
          "langs": token_type_ids,
          "lengths": input_lengths,
      }
      return config, inputs_dict







@require_tf
class 						UpperCAmelCase						(		__a       ,						__a       ,						unittest.TestCase):


 '''simple docstring'''




 __magic_name__       :			Union[str, Any]	=   (
     (
         TFXLMModel,
         TFXLMWithLMHeadModel,
         TFXLMForSequenceClassification,
         TFXLMForQuestionAnsweringSimple,
         TFXLMForTokenClassification,
         TFXLMForMultipleChoice,
     )
     if is_tf_available()
     else ()
 )
 __magic_name__       :			Union[str, Any]	=   (
     (TFXLMWithLMHeadModel,) if is_tf_available() else ()
 )  # TODO (PVP): Check other models whether language generation is also applicable
 __magic_name__       :			Union[str, Any]	=   (
     {
         "feature-extraction": TFXLMModel,
         "fill-mask": TFXLMWithLMHeadModel,
         "question-answering": TFXLMForQuestionAnsweringSimple,
         "text-classification": TFXLMForSequenceClassification,
         "text-generation": TFXLMWithLMHeadModel,
         "token-classification": TFXLMForTokenClassification,
         "zero-shot": TFXLMForSequenceClassification,
     }
     if is_tf_available()
     else {}
 )
 __magic_name__       :			Dict	=   False
 __magic_name__       :			Optional[int]	=   False




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_				,	lowerCAmelCase_)			->   List[str]:



      """simple docstring"""







      if (
          pipeline_test_casse_name == "QAPipelineTests"
          and tokenizer_name is not None
          and not tokenizer_name.endswith("Fast")
      ):
           # `QAPipelineTests` fails for a few models when the slower tokenizer are used.
           # (The slower tokenizers were never used for pipeline tests before the pipeline testing rework)
           # TODO: check (and possibly fix) the `QAPipelineTests` with slower tokenizer
           return True

      return False




 def    lowercase_	( self)			->   int:



      """simple docstring"""







      a_									=TFXLMModelTester(self)
      a_									=ConfigTester(self				,	config_class=lowerCAmelCase_				,	emb_dim=3_7)




 def    lowercase_	( self)			->   int:



      """simple docstring"""







      self.config_tester.run_common_tests()




 def    lowercase_	( self)			->   Tuple:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_model(*lowerCAmelCase_)




 def    lowercase_	( self)			->   Union[str, Any]:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_lm_head(*lowerCAmelCase_)




 def    lowercase_	( self)			->   str:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_qa(*lowerCAmelCase_)




 def    lowercase_	( self)			->   Any:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_sequence_classif(*lowerCAmelCase_)




 def    lowercase_	( self)			->   Optional[Any]:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_for_token_classification(*lowerCAmelCase_)




 def    lowercase_	( self)			->   Dict:



      """simple docstring"""







      a_									=self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_xlm_for_multiple_choice(*lowerCAmelCase_)




 @slow
 def    lowercase_	( self)			->   List[str]:



      """simple docstring"""







      for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           a_									=TFXLMModel.from_pretrained(lowerCAmelCase_)
           self.assertIsNotNone(lowerCAmelCase_)







@require_tf
class 						UpperCAmelCase						(		unittest.TestCase):


 '''simple docstring'''




 @slow
 def    lowercase_	( self)			->   Dict:



      """simple docstring"""







      a_									=TFXLMWithLMHeadModel.from_pretrained("xlm-mlm-en-2048")
      a_									=tf.convert_to_tensor([[1_4, 4_4_7]]				,	dtype=tf.intaa)  # the president
      a_									=[
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
          1_4,
          4_4_7,
      ]  # the president the president the president the president the president the president the president the president the president the president
      # TODO(PVP): this and other input_ids I tried for generation give pretty bad results. Not sure why. Model might just not be made for auto-regressive inference
      a_									=model.generate(lowerCAmelCase_				,	do_sample=lowerCAmelCase_)
      self.assertListEqual(output_ids[0].numpy().tolist()				,	lowerCAmelCase_)







'''simple docstring'''


from collections import OrderedDict
from typing import Any, List, Mapping, Optional

from ... import PreTrainedTokenizer, TensorType, is_torch_available
from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfigWithPast, PatchingSpec
from ...utils import logging


lowercase											=      logging.get_logger(__name__)

lowercase											=      {
    '''gpt2''': '''https://huggingface.co/gpt2/resolve/main/config.json''',
    '''gpt2-medium''': '''https://huggingface.co/gpt2-medium/resolve/main/config.json''',
    '''gpt2-large''': '''https://huggingface.co/gpt2-large/resolve/main/config.json''',
    '''gpt2-xl''': '''https://huggingface.co/gpt2-xl/resolve/main/config.json''',
    '''distilgpt2''': '''https://huggingface.co/distilgpt2/resolve/main/config.json''',
}







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 __magic_name__       :			str	=   "gpt2"
 __magic_name__       :			str	=   ["past_key_values"]
 __magic_name__       :			Dict	=   {
     "hidden_size": "n_embd",
     "max_position_embeddings": "n_positions",
     "num_attention_heads": "n_head",
     "num_hidden_layers": "n_layer",
 }




 def __init__( self				,	lowerCAmelCase_=5_0_2_5_7				,	lowerCAmelCase_=1_0_2_4				,	lowerCAmelCase_=7_6_8				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=1_2				,	lowerCAmelCase_=None				,	lowerCAmelCase_="gelu_new"				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=1e-5				,	lowerCAmelCase_=0.0_2				,	lowerCAmelCase_="cls_index"				,	lowerCAmelCase_=True				,	lowerCAmelCase_=None				,	lowerCAmelCase_=True				,	lowerCAmelCase_=0.1				,	lowerCAmelCase_=True				,	lowerCAmelCase_=True				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=5_0_2_5_6				,	lowerCAmelCase_=False				,	lowerCAmelCase_=False				,	**lowerCAmelCase_				,	)			->   Dict:



      """simple docstring"""







      a_									=vocab_size
      a_									=n_positions
      a_									=n_embd
      a_									=n_layer
      a_									=n_head
      a_									=n_inner
      a_									=activation_function
      a_									=resid_pdrop
      a_									=embd_pdrop
      a_									=attn_pdrop
      a_									=layer_norm_epsilon
      a_									=initializer_range
      a_									=summary_type
      a_									=summary_use_proj
      a_									=summary_activation
      a_									=summary_first_dropout
      a_									=summary_proj_to_labels
      a_									=scale_attn_weights
      a_									=use_cache
      a_									=scale_attn_by_inverse_layer_idx
      a_									=reorder_and_upcast_attn

      a_									=bos_token_id
      a_									=eos_token_id

      super().__init__(bos_token_id=lowerCAmelCase_				,	eos_token_id=lowerCAmelCase_				,	**lowerCAmelCase_)







class 						UpperCAmelCase						(		__a):


 '''simple docstring'''




 def __init__( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = "default"				,	lowerCAmelCase_ = None				,	lowerCAmelCase_ = False				,	)			->   List[str]:



      """simple docstring"""







      super().__init__(lowerCAmelCase_				,	task=lowerCAmelCase_				,	patching_specs=lowerCAmelCase_				,	use_past=lowerCAmelCase_)
      if not getattr(self._config				,	"pad_token_id"				,	lowerCAmelCase_):
           # TODO: how to do that better?
           a_									=0




 @property
 def    lowercase_	( self)			->   Mapping[str, Mapping[int, str]]:



      """simple docstring"""







      a_									=OrderedDict({"input_ids": {0: "batch", 1: "sequence"}})
      if self.use_past:
           self.fill_with_past_key_values_(lowerCAmelCase_				,	direction="inputs")
           a_									={0: "batch", 1: "past_sequence + sequence"}
      else:
           a_									={0: "batch", 1: "sequence"}

      return common_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_layer




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return self._config.n_head




 def    lowercase_	( self				,	lowerCAmelCase_				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = -1				,	lowerCAmelCase_ = False				,	lowerCAmelCase_ = None				,	)			->   Mapping[str, Any]:



      """simple docstring"""







      a_									=super(lowerCAmelCase_				,	self).generate_dummy_inputs(
          lowerCAmelCase_				,	batch_size=lowerCAmelCase_				,	seq_length=lowerCAmelCase_				,	is_pair=lowerCAmelCase_				,	framework=lowerCAmelCase_)

      # We need to order the input in the way they appears in the forward()
      a_									=OrderedDict({"input_ids": common_inputs["input_ids"]})

      # Need to add the past_keys
      if self.use_past:
           if not is_torch_available():
                raise ValueError("Cannot generate dummy past_keys inputs without PyTorch installed.")
           else:
                import torch

                a_		,    a_									=common_inputs["input_ids"].shape
                # Not using the same length for past_key_values
                a_									=seqlen + 2
                a_									=(
                    batch,
                    self.num_attention_heads,
                    past_key_values_length,
                    self._config.hidden_size // self.num_attention_heads,
                )
                a_									=[
                    (torch.zeros(lowerCAmelCase_), torch.zeros(lowerCAmelCase_)) for _ in range(self.num_layers)
                ]

      a_									=common_inputs["attention_mask"]
      if self.use_past:
           a_									=ordered_inputs["attention_mask"].dtype
           a_									=torch.cat(
               [ordered_inputs["attention_mask"], torch.ones(lowerCAmelCase_				,	lowerCAmelCase_				,	dtype=lowerCAmelCase_)]				,	dim=1)

      return ordered_inputs




 @property
 def    lowercase_	( self)			->   int:



      """simple docstring"""







      return 1_3


