
'''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 					a_					:




       def __init__(       self				,				snake_case_				,				):
         _lowerCAmelCase    :					Any							=   parent
         _lowerCAmelCase    :					Dict							=   1_3
         _lowerCAmelCase    :					Optional[Any]							=   7
         _lowerCAmelCase    :					Union[str, Any]							=   True
         _lowerCAmelCase    :					Optional[Any]							=   True
         _lowerCAmelCase    :					str							=   True
         _lowerCAmelCase    :					Optional[int]							=   True
         _lowerCAmelCase    :					Union[str, Any]							=   True
         _lowerCAmelCase    :					List[str]							=   False
         _lowerCAmelCase    :					Dict							=   False
         _lowerCAmelCase    :					List[Any]							=   False
         _lowerCAmelCase    :					Optional[int]							=   2
         _lowerCAmelCase    :					Dict							=   9_9
         _lowerCAmelCase    :					List[Any]							=   0
         _lowerCAmelCase    :					List[Any]							=   3_2
         _lowerCAmelCase    :					int							=   2
         _lowerCAmelCase    :					Tuple							=   4
         _lowerCAmelCase    :					Optional[Any]							=   0.1
         _lowerCAmelCase    :					List[str]							=   0.1
         _lowerCAmelCase    :					Optional[int]							=   5_1_2
         _lowerCAmelCase    :					Any							=   1_6
         _lowerCAmelCase    :					str							=   2
         _lowerCAmelCase    :					int							=   0.02
         _lowerCAmelCase    :					Any							=   3
         _lowerCAmelCase    :					Any							=   4
         _lowerCAmelCase    :					Union[str, Any]							=   """last"""
         _lowerCAmelCase    :					Dict							=   True
         _lowerCAmelCase    :					Union[str, Any]							=   None
         _lowerCAmelCase    :					List[str]							=   0




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Union[str, Any]							=   ids_tensor([self.batch_size, self.seq_length]				,				self.vocab_size					)
         _lowerCAmelCase    :					Optional[Any]							=   random_attention_mask([self.batch_size, self.seq_length]				,				dtype=tf.floataa					)

         _lowerCAmelCase    :					Optional[int]							=   None
         if self.use_input_lengths:
           _lowerCAmelCase    :					List[str]							=   (
               ids_tensor([self.batch_size]				,				vocab_size=2					) + self.seq_length - 2
           )  # small variation of seq_length

         _lowerCAmelCase    :					Union[str, Any]							=   None
         if self.use_token_type_ids:
           _lowerCAmelCase    :					List[str]							=   ids_tensor([self.batch_size, self.seq_length]				,				self.n_langs					)

         _lowerCAmelCase    :					List[Any]							=   None
         _lowerCAmelCase    :					int							=   None
         _lowerCAmelCase    :					int							=   None
         if self.use_labels:
           _lowerCAmelCase    :					Tuple							=   ids_tensor([self.batch_size]				,				self.type_sequence_label_size					)
           _lowerCAmelCase    :					Optional[Any]							=   ids_tensor([self.batch_size, self.seq_length]				,				self.num_labels					)
           _lowerCAmelCase    :					str							=   ids_tensor([self.batch_size]				,				2				,				dtype=tf.floataa					)
           _lowerCAmelCase    :					Union[str, Any]							=   ids_tensor([self.batch_size]				,				self.num_choices					)

         _lowerCAmelCase    :					Union[str, Any]							=   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 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					int							=   TFXLMModel(config=snake_case_					)
         _lowerCAmelCase    :					Tuple							=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
         _lowerCAmelCase    :					List[str]							=   model(snake_case_					)

         _lowerCAmelCase    :					Optional[int]							=   [input_ids, input_mask]
         _lowerCAmelCase    :					int							=   model(snake_case_					)
         self.parent.assertEqual(result.last_hidden_state.shape				,				(self.batch_size, self.seq_length, self.hidden_size)					)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					int							=   TFXLMWithLMHeadModel(snake_case_					)

         _lowerCAmelCase    :					Optional[int]							=   {"""input_ids""": input_ids, """lengths""": input_lengths, """langs""": token_type_ids}
         _lowerCAmelCase    :					str							=   model(snake_case_					)

         _lowerCAmelCase    :					List[Any]							=   outputs

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




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					Union[str, Any]							=   TFXLMForQuestionAnsweringSimple(snake_case_					)

         _lowerCAmelCase    :					Optional[Any]							=   {"""input_ids""": input_ids, """lengths""": input_lengths}

         _lowerCAmelCase    :					List[str]							=   model(snake_case_					)

         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 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					Tuple							=   TFXLMForSequenceClassification(snake_case_					)

         _lowerCAmelCase    :					Tuple							=   {"""input_ids""": input_ids, """lengths""": input_lengths}

         _lowerCAmelCase    :					str							=   model(snake_case_					)

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




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					List[Any]							=   self.num_labels
         _lowerCAmelCase    :					Tuple							=   TFXLMForTokenClassification(config=snake_case_					)
         _lowerCAmelCase    :					int							=   {"""input_ids""": input_ids, """attention_mask""": input_mask, """token_type_ids""": token_type_ids}
         _lowerCAmelCase    :					Optional[int]							=   model(snake_case_					)
         self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.seq_length, self.num_labels)					)




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				):
         _lowerCAmelCase    :					Union[str, Any]							=   self.num_choices
         _lowerCAmelCase    :					str							=   TFXLMForMultipleChoice(config=snake_case_					)
         _lowerCAmelCase    :					int							=   tf.tile(tf.expand_dims(snake_case_				,				1					)				,				(1, self.num_choices, 1)					)
         _lowerCAmelCase    :					List[str]							=   tf.tile(tf.expand_dims(snake_case_				,				1					)				,				(1, self.num_choices, 1)					)
         _lowerCAmelCase    :					Union[str, Any]							=   tf.tile(tf.expand_dims(snake_case_				,				1					)				,				(1, self.num_choices, 1)					)
         _lowerCAmelCase    :					Union[str, Any]							=   {
             """input_ids""": multiple_choice_inputs_ids,
             """attention_mask""": multiple_choice_input_mask,
             """token_type_ids""": multiple_choice_token_type_ids,
         }
         _lowerCAmelCase    :					Dict							=   model(snake_case_					)
         self.parent.assertEqual(result.logits.shape				,				(self.batch_size, self.num_choices)					)







       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[int]							=   self.prepare_config_and_inputs()
         (
             _lowerCAmelCase   
         )    :					Optional[Any]							=   config_and_inputs
         _lowerCAmelCase    :					str							=   {
             """input_ids""": input_ids,
             """token_type_ids""": token_type_ids,
             """langs""": token_type_ids,
             """lengths""": input_lengths,
         }
         return config, inputs_dict



@require_tf
class 					a_					(_a							,     _a							,     unittest.TestCase      ):
       __lowerCAmelCase      :			Union[str, Any]      = (
           (
               TFXLMModel,
               TFXLMWithLMHeadModel,
               TFXLMForSequenceClassification,
               TFXLMForQuestionAnsweringSimple,
               TFXLMForTokenClassification,
               TFXLMForMultipleChoice,
           )
           if is_tf_available()
           else ()
       )
       __lowerCAmelCase      :			List[Any]      = (
           (TFXLMWithLMHeadModel,) if is_tf_available() else ()
       )  # TODO (PVP): Check other models whether language generation is also applicable
       __lowerCAmelCase      :			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 {}
       )
       __lowerCAmelCase      :			str      = False
       __lowerCAmelCase      :			int      = False




       def 							__UpperCamelCase    (       self				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_				,				snake_case_					):
         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 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[Any]							=   TFXLMModelTester(self					)
         _lowerCAmelCase    :					str							=   ConfigTester(self				,				config_class=snake_case_				,				emb_dim=3_7					)




       def 							__UpperCamelCase    (       self					):
         self.config_tester.run_common_tests()




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Dict							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_model(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Tuple							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_lm_head(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[int]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_qa(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Union[str, Any]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_sequence_classif(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[int]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_token_classification(*snake_case_					)




       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					Optional[int]							=   self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_xlm_for_multiple_choice(*snake_case_					)







       @slow
       def 							__UpperCamelCase    (       self					):
         for model_name in TF_XLM_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
           _lowerCAmelCase    :					int							=   TFXLMModel.from_pretrained(snake_case_					)
           self.assertIsNotNone(snake_case_					)



@require_tf
class 					a_					(unittest.TestCase      ):




       @slow
       def 							__UpperCamelCase    (       self					):
         _lowerCAmelCase    :					List[Any]							=   TFXLMWithLMHeadModel.from_pretrained("""xlm-mlm-en-2048"""					)
         _lowerCAmelCase    :					Dict							=   tf.convert_to_tensor([[1_4, 4_4_7]]				,				dtype=tf.intaa					)  # the president
         _lowerCAmelCase    :					Any							=   [
             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
         _lowerCAmelCase    :					Union[str, Any]							=   model.generate(snake_case_				,				do_sample=snake_case_					)
         self.assertListEqual(output_ids[0].numpy().tolist()				,				snake_case_					)




'''simple docstring'''

from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_tf_available,
    is_torch_available,
)


UpperCamelCase_            =    {"""configuration_gptj""": ["""GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP""", """GPTJConfig""", """GPTJOnnxConfig"""]}

try:
     if not is_torch_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST""",
         """GPTJForCausalLM""",
         """GPTJForQuestionAnswering""",
         """GPTJForSequenceClassification""",
         """GPTJModel""",
         """GPTJPreTrainedModel""",
     ]

try:
     if not is_tf_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """TFGPTJForCausalLM""",
         """TFGPTJForQuestionAnswering""",
         """TFGPTJForSequenceClassification""",
         """TFGPTJModel""",
         """TFGPTJPreTrainedModel""",
     ]

try:
     if not is_flax_available():
          raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
     pass
else:
     UpperCamelCase_            =    [
         """FlaxGPTJForCausalLM""",
         """FlaxGPTJModel""",
         """FlaxGPTJPreTrainedModel""",
     ]


if TYPE_CHECKING:
     from .configuration_gptj import GPTJ_PRETRAINED_CONFIG_ARCHIVE_MAP, GPTJConfig, GPTJOnnxConfig

     try:
          if not is_torch_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_gptj import (
              GPTJ_PRETRAINED_MODEL_ARCHIVE_LIST,
              GPTJForCausalLM,
              GPTJForQuestionAnswering,
              GPTJForSequenceClassification,
              GPTJModel,
              GPTJPreTrainedModel,
          )

     try:
          if not is_tf_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_tf_gptj import (
              TFGPTJForCausalLM,
              TFGPTJForQuestionAnswering,
              TFGPTJForSequenceClassification,
              TFGPTJModel,
              TFGPTJPreTrainedModel,
          )

     try:
          if not is_flax_available():
               raise OptionalDependencyNotAvailable()
     except OptionalDependencyNotAvailable:
          pass
     else:
          from .modeling_flax_gptj import FlaxGPTJForCausalLM, FlaxGPTJModel, FlaxGPTJPreTrainedModel

else:
     import sys

     UpperCamelCase_            =    _LazyModule(__name__, globals()["""__file__"""], _import_structure, module_spec=__spec__)


