





from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...file_utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFSequenceClassifierOutput,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import logging
from .configuration_regnet import RegNetConfig


_A					:				Dict				=			logging.get_logger(__name__)

# General docstring
_A					:				int				=			"""RegNetConfig"""

# Base docstring
_A					:				List[str]				=			"""facebook/regnet-y-040"""
_A					:				Union[str, Any]				=			[1, 10_88, 7, 7]

# Image classification docstring
_A					:				Optional[Any]				=			"""facebook/regnet-y-040"""
_A					:				Tuple				=			"""tabby, tabby cat"""

_A					:				Optional[Any]				=			[
    """facebook/regnet-y-040""",
    # See all regnet models at https://huggingface.co/models?filter=regnet
]



class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_ = 3   ,				A_ = 1   ,				A_ = 1   ,				A_ = "relu"   ,				**A_   ,				):





        '''simple docstring'''

        super().__init__(**A_     )
        # The padding and conv has been verified in
        # https://colab.research.google.com/gist/sayakpaul/854bc10eeaf21c9ee2119e0b9f3841a7/scratchpad.ipynb
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.ZeroPaddingaD(padding=kernel_size // 2     )
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.ConvaD(
            filters=A_   ,				kernel_size=A_   ,				strides=A_   ,				padding='''VALID'''   ,				groups=A_   ,				use_bias=A_   ,				name='''convolution'''   ,				)
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.BatchNormalization(epsilon=1E-5   ,				momentum=0.9   ,				name='''normalization'''     )
        SCREAMING_SNAKE_CASE__											=			ACTaFN[activation] if activation is not None else tf.identity




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.convolution(self.padding(A_     )     )
        SCREAMING_SNAKE_CASE__											=			self.normalization(A_     )
        SCREAMING_SNAKE_CASE__											=			self.activation(A_     )
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			config.num_channels
        SCREAMING_SNAKE_CASE__											=			TFRegNetConvLayer(
            out_channels=config.embedding_size   ,				kernel_size=3   ,				stride=2   ,				activation=config.hidden_act   ,				name='''embedder'''   ,				)




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			shape_list(A_     )[1]
        if tf.executing_eagerly() and num_channels != self.num_channels:
            raise ValueError(
                '''Make sure that the channel dimension of the pixel values match with the one set in the configuration.'''     )

        # When running on CPU, `tf.keras.layers.Conv2D` doesn't support `NCHW` format.
        # So change the input format from `NCHW` to `NHWC`.
        # shape = (batch_size, in_height, in_width, in_channels=num_channels)
        SCREAMING_SNAKE_CASE__											=			tf.transpose(A_   ,				perm=(0, 2, 3, 1)     )
        SCREAMING_SNAKE_CASE__											=			self.embedder(A_     )
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_ = 2   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.ConvaD(
            filters=A_   ,				kernel_size=1   ,				strides=A_   ,				use_bias=A_   ,				name='''convolution'''     )
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.BatchNormalization(epsilon=1E-5   ,				momentum=0.9   ,				name='''normalization'''     )




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





        '''simple docstring'''

        return self.normalization(self.convolution(A_     )   ,				training=A_     )





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=A_   ,				name='''pooler'''     )
        SCREAMING_SNAKE_CASE__											=			[
            tf.keras.layers.ConvaD(filters=A_   ,				kernel_size=1   ,				activation='''relu'''   ,				name='''attention.0'''     ),
            tf.keras.layers.ConvaD(filters=A_   ,				kernel_size=1   ,				activation='''sigmoid'''   ,				name='''attention.2'''     ),
        ]




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			self.pooler(A_     )
        for layer_module in self.attention:
            SCREAMING_SNAKE_CASE__											=			layer_module(A_     )
        SCREAMING_SNAKE_CASE__											=			hidden_state * pooled
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_   ,				A_   ,				A_ = 1   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			in_channels != out_channels or stride != 1
        SCREAMING_SNAKE_CASE__											=			max(1   ,				out_channels // config.groups_width     )
        SCREAMING_SNAKE_CASE__											=			(
            TFRegNetShortCut(A_   ,				stride=A_   ,				name='''shortcut'''     )
            if should_apply_shortcut
            else tf.keras.layers.Activation('''linear'''   ,				name='''shortcut'''     )
        )
        # `self.layers` instead of `self.layer` because that is a reserved argument.
        SCREAMING_SNAKE_CASE__											=			[
            TFRegNetConvLayer(A_   ,				kernel_size=1   ,				activation=config.hidden_act   ,				name='''layer.0'''     ),
            TFRegNetConvLayer(
                A_   ,				stride=A_   ,				groups=A_   ,				activation=config.hidden_act   ,				name='''layer.1'''     ),
            TFRegNetConvLayer(A_   ,				kernel_size=1   ,				activation=A_   ,				name='''layer.2'''     ),
        ]
        SCREAMING_SNAKE_CASE__											=			ACTaFN[config.hidden_act]




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			hidden_state
        for layer_module in self.layers:
            SCREAMING_SNAKE_CASE__											=			layer_module(A_     )
        SCREAMING_SNAKE_CASE__											=			self.shortcut(A_     )
        hidden_state += residual
        SCREAMING_SNAKE_CASE__											=			self.activation(A_     )
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_   ,				A_   ,				A_ = 1   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			in_channels != out_channels or stride != 1
        SCREAMING_SNAKE_CASE__											=			max(1   ,				out_channels // config.groups_width     )
        SCREAMING_SNAKE_CASE__											=			(
            TFRegNetShortCut(A_   ,				stride=A_   ,				name='''shortcut'''     )
            if should_apply_shortcut
            else tf.keras.layers.Activation('''linear'''   ,				name='''shortcut'''     )
        )
        SCREAMING_SNAKE_CASE__											=			[
            TFRegNetConvLayer(A_   ,				kernel_size=1   ,				activation=config.hidden_act   ,				name='''layer.0'''     ),
            TFRegNetConvLayer(
                A_   ,				stride=A_   ,				groups=A_   ,				activation=config.hidden_act   ,				name='''layer.1'''     ),
            TFRegNetSELayer(A_   ,				reduced_channels=int(round(in_channels / 4     )     )   ,				name='''layer.2'''     ),
            TFRegNetConvLayer(A_   ,				kernel_size=1   ,				activation=A_   ,				name='''layer.3'''     ),
        ]
        SCREAMING_SNAKE_CASE__											=			ACTaFN[config.hidden_act]




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			hidden_state
        for layer_module in self.layers:
            SCREAMING_SNAKE_CASE__											=			layer_module(A_     )
        SCREAMING_SNAKE_CASE__											=			self.shortcut(A_     )
        hidden_state += residual
        SCREAMING_SNAKE_CASE__											=			self.activation(A_     )
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				A_   ,				A_   ,				A_ = 2   ,				A_ = 2   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )

        SCREAMING_SNAKE_CASE__											=			TFRegNetXLayer if config.layer_type == '''x''' else TFRegNetYLayer
        SCREAMING_SNAKE_CASE__											=			[
            # downsampling is done in the first layer with stride of 2
            layer(A_   ,				A_   ,				A_   ,				stride=A_   ,				name='''layers.0'''     ),
            *[layer(A_   ,				A_   ,				A_   ,				name=f'''layers.{i+1}'''     ) for i in range(depth - 1     )],
        ]




    def  lowercase_					(       self   ,				A_     ):





        '''simple docstring'''

        for layer_module in self.layers:
            SCREAMING_SNAKE_CASE__											=			layer_module(A_     )
        return hidden_state





class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			[]
        # based on `downsample_in_first_stage`, the first layer of the first stage may or may not downsample the input
        self.stages.append(
            TFRegNetStage(
                A_   ,				config.embedding_size   ,				config.hidden_sizes[0]   ,				stride=2 if config.downsample_in_first_stage else 1   ,				depth=config.depths[0]   ,				name='''stages.0'''   ,				)     )
        SCREAMING_SNAKE_CASE__											=			zip(config.hidden_sizes   ,				config.hidden_sizes[1:]     )
        for i, ((in_channels, out_channels), depth) in enumerate(zip(A_   ,				config.depths[1:]     )     ):
            self.stages.append(TFRegNetStage(A_   ,				A_   ,				A_   ,				depth=A_   ,				name=f'''stages.{i+1}'''     )     )




    def  lowercase_					(       self   ,				A_   ,				A_ = False   ,				A_ = True     ):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			() if output_hidden_states else None

        for stage_module in self.stages:
            if output_hidden_states:
                SCREAMING_SNAKE_CASE__											=			hidden_states + (hidden_state,)

            SCREAMING_SNAKE_CASE__											=			stage_module(A_     )

        if output_hidden_states:
            SCREAMING_SNAKE_CASE__											=			hidden_states + (hidden_state,)

        if not return_dict:
            return tuple(v for v in [hidden_state, hidden_states] if v is not None     )

        return TFBaseModelOutputWithNoAttention(last_hidden_state=A_   ,				hidden_states=A_     )





@keras_serializable
class 					__snake_case	(  tf.keras.layers.Layer    ):


    '''simple docstring'''







    lowerCamelCase__    :		Optional[int]				=	RegNetConfig



    def __init__(       self   ,				A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(**A_     )
        SCREAMING_SNAKE_CASE__											=			config
        SCREAMING_SNAKE_CASE__											=			TFRegNetEmbeddings(A_   ,				name='''embedder'''     )
        SCREAMING_SNAKE_CASE__											=			TFRegNetEncoder(A_   ,				name='''encoder'''     )
        SCREAMING_SNAKE_CASE__											=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=A_   ,				name='''pooler'''     )




    @unpack_inputs
    def  lowercase_					(       self   ,				A_   ,				A_ = None   ,				A_ = None   ,				A_ = False   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        SCREAMING_SNAKE_CASE__											=			return_dict if return_dict is not None else self.config.use_return_dict

        SCREAMING_SNAKE_CASE__											=			self.embedder(A_   ,				training=A_     )

        SCREAMING_SNAKE_CASE__											=			self.encoder(
            A_   ,				output_hidden_states=A_   ,				return_dict=A_   ,				training=A_     )

        SCREAMING_SNAKE_CASE__											=			encoder_outputs[0]
        SCREAMING_SNAKE_CASE__											=			self.pooler(A_     )

        # Change to NCHW output format have uniformity in the modules
        SCREAMING_SNAKE_CASE__											=			tf.transpose(A_   ,				perm=(0, 3, 1, 2)     )
        SCREAMING_SNAKE_CASE__											=			tf.transpose(A_   ,				perm=(0, 3, 1, 2)     )

        # Change the other hidden state outputs to NCHW as well
        if output_hidden_states:
            SCREAMING_SNAKE_CASE__											=			tuple([tf.transpose(A_   ,				perm=(0, 3, 1, 2)     ) for h in encoder_outputs[1]]     )

        if not return_dict:
            return (last_hidden_state, pooled_output) + encoder_outputs[1:]

        return TFBaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=A_   ,				pooler_output=A_   ,				hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states   ,				)





class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    lowerCamelCase__    :		Union[str, Any]				=	RegNetConfig
    lowerCamelCase__    :		Optional[int]				=	"""regnet"""
    lowerCamelCase__    :		Union[str, Any]				=	"""pixel_values"""



    @property
    def  lowercase_					(       self     ):





        '''simple docstring'''

        return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 2_24, 2_24)   ,				dtype=tf.floataa     )}





_A					:				Optional[Any]				=			r"""
    Parameters:
    This model is a Tensorflow
    [tf.keras.layers.Layer](https://www.tensorflow.org/api_docs/python/tf/keras/layers/Layer) sub-class. Use it as a
    regular Tensorflow Module and refer to the Tensorflow documentation for all matter related to general usage and
    behavior.
        config ([`RegNetConfig`]): Model configuration class with all the parameters of the model.
            Initializing with a config file does not load the weights associated with the model, only the
            configuration. Check out the [`~TFPreTrainedModel.from_pretrained`] method to load the model weights.
"""

_A					:				Tuple				=			r"""
    Args:
        pixel_values (`tf.Tensor` of shape `(batch_size, num_channels, height, width)`):
            Pixel values. Pixel values can be obtained using [`AutoImageProcessor`]. See
            [`ConveNextImageProcessor.__call__`] for details.
        output_hidden_states (`bool`, *optional*):
            Whether or not to return the hidden states of all layers. See `hidden_states` under returned tensors for
            more detail.
        return_dict (`bool`, *optional*):
            Whether or not to return a [`~utils.ModelOutput`] instead of a plain tuple.
"""



@add_start_docstrings(
    """The bare RegNet model outputting raw features without any specific head on top."""			,     __SCREAMING_SNAKE_CASE			,     )
class 					__snake_case	(  __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				*A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(A_   ,				*A_   ,				**A_     )
        SCREAMING_SNAKE_CASE__											=			TFRegNetMainLayer(A_   ,				name='''regnet'''     )




    @unpack_inputs
    @add_start_docstrings_to_model_forward(A_     )
    @add_code_sample_docstrings(
        checkpoint=_CHECKPOINT_FOR_DOC   ,				output_type=A_   ,				config_class=_CONFIG_FOR_DOC   ,				modality='''vision'''   ,				expected_output=_EXPECTED_OUTPUT_SHAPE   ,				)
    def  lowercase_					(       self   ,				A_   ,				A_ = None   ,				A_ = None   ,				A_=False   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        SCREAMING_SNAKE_CASE__											=			return_dict if return_dict is not None else self.config.use_return_dict

        SCREAMING_SNAKE_CASE__											=			self.regnet(
            pixel_values=A_   ,				output_hidden_states=A_   ,				return_dict=A_   ,				training=A_   ,				)
        if not return_dict:
            return (outputs[0],) + outputs[1:]

        return TFBaseModelOutputWithPoolingAndNoAttention(
            last_hidden_state=outputs.last_hidden_state   ,				pooler_output=outputs.pooler_output   ,				hidden_states=outputs.hidden_states   ,				)





@add_start_docstrings(
    """
    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """			,     __SCREAMING_SNAKE_CASE			,     )
class 					__snake_case	(  __SCREAMING_SNAKE_CASE			,     __SCREAMING_SNAKE_CASE    ):


    '''simple docstring'''







    def __init__(       self   ,				A_   ,				*A_   ,				**A_     ):





        '''simple docstring'''

        super().__init__(A_   ,				*A_   ,				**A_     )
        SCREAMING_SNAKE_CASE__											=			config.num_labels
        SCREAMING_SNAKE_CASE__											=			TFRegNetMainLayer(A_   ,				name='''regnet'''     )
        # classification head
        SCREAMING_SNAKE_CASE__											=			[
            tf.keras.layers.Flatten(),
            tf.keras.layers.Dense(config.num_labels   ,				name='''classifier.1'''     ) if config.num_labels > 0 else tf.identity,
        ]




    @unpack_inputs
    @add_start_docstrings_to_model_forward(A_     )
    @add_code_sample_docstrings(
        checkpoint=_IMAGE_CLASS_CHECKPOINT   ,				output_type=A_   ,				config_class=_CONFIG_FOR_DOC   ,				expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT   ,				)
    def  lowercase_					(       self   ,				A_ = None   ,				A_ = None   ,				A_ = None   ,				A_ = None   ,				A_=False   ,				):





        '''simple docstring'''

        SCREAMING_SNAKE_CASE__											=			(
            output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
        )
        SCREAMING_SNAKE_CASE__											=			return_dict if return_dict is not None else self.config.use_return_dict

        SCREAMING_SNAKE_CASE__											=			self.regnet(
            A_   ,				output_hidden_states=A_   ,				return_dict=A_   ,				training=A_     )

        SCREAMING_SNAKE_CASE__											=			outputs.pooler_output if return_dict else outputs[1]

        SCREAMING_SNAKE_CASE__											=			self.classifier[0](A_     )
        SCREAMING_SNAKE_CASE__											=			self.classifier[1](A_     )

        SCREAMING_SNAKE_CASE__											=			None if labels is None else self.hf_compute_loss(labels=A_   ,				logits=A_     )

        if not return_dict:
            SCREAMING_SNAKE_CASE__											=			(logits,) + outputs[2:]
            return ((loss,) + output) if loss is not None else output

        return TFSequenceClassifierOutput(loss=A_   ,				logits=A_   ,				hidden_states=outputs.hidden_states     )







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_     )
