





import unittest

from transformers import DebertaVaConfig, is_torch_available
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
  import torch

  from transformers import (
      DebertaVaForMaskedLM,
      DebertaVaForMultipleChoice,
      DebertaVaForQuestionAnswering,
      DebertaVaForSequenceClassification,
      DebertaVaForTokenClassification,
      DebertaVaModel,
  )
  from transformers.models.deberta_va.modeling_deberta_va import DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST



class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_=13   ,				A_=7   ,				A_=True   ,				A_=True   ,				A_=True   ,				A_=True   ,				A_=99   ,				A_=32   ,				A_=5   ,				A_=4   ,				A_=37   ,				A_="gelu"   ,				A_=0.1   ,				A_=0.1   ,				A_=5_12   ,				A_=16   ,				A_=2   ,				A_=0.02   ,				A_=False   ,				A_=True   ,				A_="None"   ,				A_=3   ,				A_=4   ,				A_=None   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			parent
        SCREAMING_SNAKE_CASE__											=			batch_size
        SCREAMING_SNAKE_CASE__											=			seq_length
        SCREAMING_SNAKE_CASE__											=			is_training
        SCREAMING_SNAKE_CASE__											=			use_input_mask
        SCREAMING_SNAKE_CASE__											=			use_token_type_ids
        SCREAMING_SNAKE_CASE__											=			use_labels
        SCREAMING_SNAKE_CASE__											=			vocab_size
        SCREAMING_SNAKE_CASE__											=			hidden_size
        SCREAMING_SNAKE_CASE__											=			num_hidden_layers
        SCREAMING_SNAKE_CASE__											=			num_attention_heads
        SCREAMING_SNAKE_CASE__											=			intermediate_size
        SCREAMING_SNAKE_CASE__											=			hidden_act
        SCREAMING_SNAKE_CASE__											=			hidden_dropout_prob
        SCREAMING_SNAKE_CASE__											=			attention_probs_dropout_prob
        SCREAMING_SNAKE_CASE__											=			max_position_embeddings
        SCREAMING_SNAKE_CASE__											=			type_vocab_size
        SCREAMING_SNAKE_CASE__											=			type_sequence_label_size
        SCREAMING_SNAKE_CASE__											=			initializer_range
        SCREAMING_SNAKE_CASE__											=			num_labels
        SCREAMING_SNAKE_CASE__											=			num_choices
        SCREAMING_SNAKE_CASE__											=			relative_attention
        SCREAMING_SNAKE_CASE__											=			position_biased_input
        SCREAMING_SNAKE_CASE__											=			pos_att_type
        SCREAMING_SNAKE_CASE__											=			scope



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

        SCREAMING_SNAKE_CASE__											=			None
        if self.use_input_mask:
            SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				vocab_size=2     )

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

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

        SCREAMING_SNAKE_CASE__											=			self.get_config()

        return config, input_ids, token_type_ids, input_mask, sequence_labels, token_labels, choice_labels



    def  lowercase_					(       self     ):





        '''simple docstring'''

        return DebertaVaConfig(
            vocab_size=self.vocab_size   ,				hidden_size=self.hidden_size   ,				num_hidden_layers=self.num_hidden_layers   ,				num_attention_heads=self.num_attention_heads   ,				intermediate_size=self.intermediate_size   ,				hidden_act=self.hidden_act   ,				hidden_dropout_prob=self.hidden_dropout_prob   ,				attention_probs_dropout_prob=self.attention_probs_dropout_prob   ,				max_position_embeddings=self.max_position_embeddings   ,				type_vocab_size=self.type_vocab_size   ,				initializer_range=self.initializer_range   ,				relative_attention=self.relative_attention   ,				position_biased_input=self.position_biased_input   ,				pos_att_type=self.pos_att_type   ,				)



    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        self.parent.assertListEqual(list(result.loss.size()     )   ,				[]     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaModel(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_   ,				token_type_ids=A_     )[0]
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				token_type_ids=A_     )[0]
        SCREAMING_SNAKE_CASE__											=			model(A_     )[0]

        self.parent.assertListEqual(list(sequence_output.size()     )   ,				[self.batch_size, self.seq_length, self.hidden_size]     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaForMaskedLM(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				labels=A_     )

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



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.num_labels
        SCREAMING_SNAKE_CASE__											=			DebertaVaForSequenceClassification(A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				labels=A_     )
        self.parent.assertListEqual(list(result.logits.size()     )   ,				[self.batch_size, self.num_labels]     )
        self.check_loss_output(A_     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.num_labels
        SCREAMING_SNAKE_CASE__											=			DebertaVaForTokenClassification(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				labels=A_     )
        self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.seq_length, self.num_labels)     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaForQuestionAnswering(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			model(
            A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				start_positions=A_   ,				end_positions=A_   ,				)
        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   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaForMultipleChoice(config=A_     )
        model.to(A_     )
        model.eval()
        SCREAMING_SNAKE_CASE__											=			input_ids.unsqueeze(1     ).expand(-1   ,				self.num_choices   ,				-1     ).contiguous()
        SCREAMING_SNAKE_CASE__											=			token_type_ids.unsqueeze(1     ).expand(-1   ,				self.num_choices   ,				-1     ).contiguous()
        SCREAMING_SNAKE_CASE__											=			input_mask.unsqueeze(1     ).expand(-1   ,				self.num_choices   ,				-1     ).contiguous()
        SCREAMING_SNAKE_CASE__											=			model(
            A_   ,				attention_mask=A_   ,				token_type_ids=A_   ,				labels=A_   ,				)
        self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_choices)     )




    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.prepare_config_and_inputs()
        (
            (
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		(
            SCREAMING_SNAKE_CASE__
        )				,		
        )											=			config_and_inputs
        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids, '''token_type_ids''': token_type_ids, '''attention_mask''': input_mask}
        return config, inputs_dict





@require_torch
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







    lowerCamelCase__    :		List[str]				=	(
        (
            DebertaVaModel,
            DebertaVaForMaskedLM,
            DebertaVaForSequenceClassification,
            DebertaVaForTokenClassification,
            DebertaVaForQuestionAnswering,
            DebertaVaForMultipleChoice,
        )
        if is_torch_available()
        else ()
    )
    lowerCamelCase__    :		Tuple				=	(
        {
            """feature-extraction""": DebertaVaModel,
            """fill-mask""": DebertaVaForMaskedLM,
            """question-answering""": DebertaVaForQuestionAnswering,
            """text-classification""": DebertaVaForSequenceClassification,
            """token-classification""": DebertaVaForTokenClassification,
            """zero-shot""": DebertaVaForSequenceClassification,
        }
        if is_torch_available()
        else {}
    )

    lowerCamelCase__    :		str				=	True
    lowerCamelCase__    :		Union[str, Any]				=	False
    lowerCamelCase__    :		List[Any]				=	False
    lowerCamelCase__    :		Union[str, Any]				=	False
    lowerCamelCase__    :		Any				=	False



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaModelTester(self     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_   ,				hidden_size=37     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_model(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_for_sequence_classification(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_for_masked_lm(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_for_question_answering(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_for_token_classification(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_deberta_for_multiple_choice(*A_     )




    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        for model_name in DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__											=			DebertaVaModel.from_pretrained(A_     )
            self.assertIsNotNone(A_     )





@require_torch
@require_sentencepiece
@require_tokenizers
class 					__snake_case	(  unittest.TestCase    ):


    '''simple docstring'''







    @unittest.skip(reason='''Model not available yet'''     )
    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass




    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			DebertaVaModel.from_pretrained('''microsoft/deberta-v2-xlarge'''     )

        SCREAMING_SNAKE_CASE__											=			torch.tensor([[0, 3_14_14, 2_32, 3_28, 7_40, 11_40, 1_26_95, 69, 4_60_78, 15_88, 2]]     )
        SCREAMING_SNAKE_CASE__											=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]     )
        with torch.no_grad():
            SCREAMING_SNAKE_CASE__											=			model(A_   ,				attention_mask=A_     )[0]
        # compare the actual values for a slice.
        SCREAMING_SNAKE_CASE__											=			torch.tensor(
            [[[0.2356, 0.1948, 0.0369], [-0.1063, 0.3586, -0.5152], [-0.6399, -0.0259, -0.2525]]]     )
        self.assertTrue(torch.allclose(output[:, 1:4, 1:4]   ,				A_   ,				atol=1E-4     )   ,				f'''{output[:, 1:4, 1:4]}'''     )







from __future__ import annotations

import random
import unittest

from transformers import TransfoXLConfig, 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
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
  import tensorflow as tf

  from transformers import (
      TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST,
      TFTransfoXLForSequenceClassification,
      TFTransfoXLLMHeadModel,
      TFTransfoXLModel,
  )



class 					__snake_case	:


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			parent
        SCREAMING_SNAKE_CASE__											=			13
        SCREAMING_SNAKE_CASE__											=			7
        SCREAMING_SNAKE_CASE__											=			30
        SCREAMING_SNAKE_CASE__											=			self.seq_length + self.mem_len
        SCREAMING_SNAKE_CASE__											=			15
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			True
        SCREAMING_SNAKE_CASE__											=			99
        SCREAMING_SNAKE_CASE__											=			[10, 50, 80]
        SCREAMING_SNAKE_CASE__											=			32
        SCREAMING_SNAKE_CASE__											=			32
        SCREAMING_SNAKE_CASE__											=			4
        SCREAMING_SNAKE_CASE__											=			8
        SCREAMING_SNAKE_CASE__											=			1_28
        SCREAMING_SNAKE_CASE__											=			2
        SCREAMING_SNAKE_CASE__											=			2
        SCREAMING_SNAKE_CASE__											=			None
        SCREAMING_SNAKE_CASE__											=			1
        SCREAMING_SNAKE_CASE__											=			0
        SCREAMING_SNAKE_CASE__											=			3
        SCREAMING_SNAKE_CASE__											=			self.vocab_size - 1
        SCREAMING_SNAKE_CASE__											=			0.01



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )
        SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

        SCREAMING_SNAKE_CASE__											=			None
        if self.use_labels:
            SCREAMING_SNAKE_CASE__											=			ids_tensor([self.batch_size, self.seq_length]   ,				self.vocab_size     )

        SCREAMING_SNAKE_CASE__											=			TransfoXLConfig(
            vocab_size=self.vocab_size   ,				mem_len=self.mem_len   ,				clamp_len=self.clamp_len   ,				cutoffs=self.cutoffs   ,				d_model=self.hidden_size   ,				d_embed=self.d_embed   ,				n_head=self.num_attention_heads   ,				d_head=self.d_head   ,				d_inner=self.d_inner   ,				div_val=self.div_val   ,				n_layer=self.num_hidden_layers   ,				eos_token_id=self.eos_token_id   ,				pad_token_id=self.vocab_size - 1   ,				init_range=self.init_range   ,				num_labels=self.num_labels   ,				)

        return (config, input_ids_a, input_ids_a, lm_labels)



    def  lowercase_					(       self     ):





        '''simple docstring'''

        random.seed(self.seed     )
        tf.random.set_seed(self.seed     )



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLModel(A_     )

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a, '''mems''': mems_a}

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        self.parent.assertEqual(hidden_states_a.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
        self.parent.assertEqual(hidden_states_a.shape   ,				(self.batch_size, self.seq_length, self.hidden_size)     )
        self.parent.assertListEqual(
            [mem.shape for mem in mems_a]   ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,				)
        self.parent.assertListEqual(
            [mem.shape for mem in mems_a]   ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,				)



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLLMHeadModel(A_     )

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a, '''labels''': lm_labels}
        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model([input_ids_a, mems_a]     ).to_tuple()

        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a, '''mems''': mems_a, '''labels''': lm_labels}

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			model(A_     ).to_tuple()

        self.parent.assertEqual(lm_logits_a.shape   ,				(self.batch_size, self.seq_length, self.vocab_size)     )
        self.parent.assertListEqual(
            [mem.shape for mem in mems_a]   ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,				)

        self.parent.assertEqual(lm_logits_a.shape   ,				(self.batch_size, self.seq_length, self.vocab_size)     )
        self.parent.assertListEqual(
            [mem.shape for mem in mems_a]   ,				[(self.mem_len, self.batch_size, self.hidden_size)] * self.num_hidden_layers   ,				)



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLForSequenceClassification(A_     )
        SCREAMING_SNAKE_CASE__											=			model(A_     )
        self.parent.assertEqual(result.logits.shape   ,				(self.batch_size, self.num_labels)     )




    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.prepare_config_and_inputs()
        ((SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__)				,		(SCREAMING_SNAKE_CASE__))											=			config_and_inputs
        SCREAMING_SNAKE_CASE__											=			{'''input_ids''': input_ids_a}
        return config, inputs_dict





@require_tf
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE			,     unittest.TestCase    ):


    '''simple docstring'''







    lowerCamelCase__    :		Optional[int]				=	(
        (TFTransfoXLModel, TFTransfoXLLMHeadModel, TFTransfoXLForSequenceClassification) if is_tf_available() else ()
    )
    lowerCamelCase__    :		List[str]				=	() if is_tf_available() else ()
    lowerCamelCase__    :		List[Any]				=	(
        {
            """feature-extraction""": TFTransfoXLModel,
            """text-classification""": TFTransfoXLForSequenceClassification,
            """text-generation""": TFTransfoXLLMHeadModel,
            """zero-shot""": TFTransfoXLForSequenceClassification,
        }
        if is_tf_available()
        else {}
    )
    # TODO: add this test when TFTransfoXLLMHead has a linear output layer implemented
    lowerCamelCase__    :		Tuple				=	False
    lowerCamelCase__    :		Any				=	False
    lowerCamelCase__    :		Dict				=	False
    lowerCamelCase__    :		Optional[Any]				=	False



    def  lowercase_					(       self   ,				A_   ,				A_   ,				A_   ,				A_   ,				A_     ):





        '''simple docstring'''

        if pipeline_test_casse_name == "TextGenerationPipelineTests":
            # Get `ValueError: AttributeError: 'NoneType' object has no attribute 'new_ones'` or `AssertionError`.
            # `TransfoXLConfig` was never used in pipeline tests: cannot create a simple
            # tokenizer.
            return True

        return False



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLModelTester(self     )
        SCREAMING_SNAKE_CASE__											=			ConfigTester(self   ,				config_class=A_   ,				d_embed=37     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.config_tester.run_common_tests()



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.model_tester.set_seed()
        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_model(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        self.model_tester.set_seed()
        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_lm_head(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_transfo_xl_for_sequence_classification(*A_     )



    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__				,		SCREAMING_SNAKE_CASE__											=			self.model_tester.prepare_config_and_inputs_for_common()
        SCREAMING_SNAKE_CASE__											=			[TFTransfoXLForSequenceClassification]

        for model_class in self.all_model_classes:
            SCREAMING_SNAKE_CASE__											=			model_class(A_     )
            assert isinstance(model.get_input_embeddings()   ,				tf.keras.layers.Layer     )
            if model_class in list_other_models_with_output_ebd:
                SCREAMING_SNAKE_CASE__											=			model.get_output_embeddings()
                assert isinstance(A_   ,				tf.keras.layers.Layer     )
                SCREAMING_SNAKE_CASE__											=			model.get_bias()
                assert name is None
            else:
                SCREAMING_SNAKE_CASE__											=			model.get_output_embeddings()
                assert x is None
                SCREAMING_SNAKE_CASE__											=			model.get_bias()
                assert name is None



    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass



    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        for model_name in TF_TRANSFO_XL_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
            SCREAMING_SNAKE_CASE__											=			TFTransfoXLModel.from_pretrained(A_     )
            self.assertIsNotNone(A_     )




    @unittest.skip(reason='''This model doesn\'t play well with fit() due to not returning a single loss.'''     )
    def  lowercase_					(       self     ):





        '''simple docstring'''

        pass





@require_tf
class 					__snake_case	(  unittest.TestCase    ):


    '''simple docstring'''







    @unittest.skip('''Skip test until #12651 is resolved.'''     )
    @slow
    def  lowercase_					(       self     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			TFTransfoXLLMHeadModel.from_pretrained('''transfo-xl-wt103'''     )
        # fmt: off
        SCREAMING_SNAKE_CASE__											=			tf.convert_to_tensor([[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0]]   ,				dtype=tf.intaa     )  # noqa: E231
        # fmt: on
        #  In 1991 , the remains of Russian Tsar Nicholas II and his family
        #  ( except for Alexei and Maria ) are discovered .
        #  The voice of Nicholas's young son , Tsarevich Alexei Nikolaevich , narrates the
        #  remainder of the story . 1883 Western Siberia ,
        #  a young Grigori Rasputin is asked by his father and a group of men to perform magic .
        #  Rasputin has a vision and denounces one of the men as a horse thief . Although his
        #  father initially slaps him for making such an accusation , Rasputin watches as the
        #  man is chased outside and beaten . Twenty years later , Rasputin sees a vision of
        #  the Virgin Mary , prompting him to become a priest . Rasputin quickly becomes famous ,
        #  with people , even a bishop , begging for his blessing . <eod> </s> <eos>

        # fmt: off
        SCREAMING_SNAKE_CASE__											=			[33,12_97,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,22,17_06,17,2_00_98,5,32_15,21,37,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,62_24,8_31,1_60_02,2,8,6_03,7_89_67,2_95_46,23,8_03,20,25,4_16,5,8,2_32,4,2_77,6,18_55,46_01,3,2_95_46,54,8,36_09,5,5_72_11,49,4,1,2_77,18,8,17_55,1_56_91,3,3_41,25,4_16,6_93,4_25_73,71,17,4_01,94,31,1_79_19,2,2_95_46,78_73,18,1,4_35,23,1_10_11,7_55,5,51_67,3,79_83,98,84,2,2_95_46,32_67,8,36_09,4,1,48_65,10_75,2,60_87,71,6,3_46,8,58_54,3,2_95_46,8_24,14_00,18_68,2,19,1_60,2,3_11,8,54_96,2,2_09_20,17,25,1_50_97,3,24,24,0,33,1,18_57,2,1,10_09,4,11_09,1_17_39,47_62,3_58,5,25,2_45,28,11_10,3,13,10_41,4,24,6_03,4_90,2,7_14_77,2_00_98,10_44_47,2,2_09_61,1,26_04,4,1,3_29,3,0]  # noqa: E231
        # fmt: on
        #  In 1991, the remains of Russian Tsar Nicholas II and his family (
        #  except for Alexei and Maria ) are discovered. The voice of young son,
        #  Tsarevich Alexei Nikolaevich, narrates the remainder of the story.
        #  1883 Western Siberia, a young Grigori Rasputin is asked by his father
        #  and a group of men to perform magic. Rasputin has a vision and
        #  denounces one of the men as a horse thief. Although his father initially
        #  slaps him for making such an accusation, Rasputin watches as the man
        #  is chased outside and beaten. Twenty years later, Rasputin sees a vision
        #  of the Virgin Mary, prompting him to become a priest.
        #  Rasputin quickly becomes famous, with people, even a bishop, begging for
        #  his blessing. <unk> <unk> <eos> In the 1990s, the remains of Russian Tsar
        # Nicholas II and his family were discovered. The voice of <unk> young son,
        # Tsarevich Alexei Nikolaevich, narrates the remainder of the story.<eos>

        SCREAMING_SNAKE_CASE__											=			model.generate(A_   ,				max_length=2_00   ,				do_sample=A_     )
        self.assertListEqual(output_ids[0].numpy().tolist()   ,				A_     )
