




"""simple docstring"""






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


__lowerCAmelCase					: int        =logging.get_logger(__name__)

# General docstring
__lowerCAmelCase					: Dict        ="""RegNetConfig"""

# Base docstring
__lowerCAmelCase					: Optional[int]        ="""facebook/regnet-y-040"""
__lowerCAmelCase					: Any        =[1, 1_0_8_8, 7, 7]

# Image classification docstring
__lowerCAmelCase					: Union[str, Any]        ="""facebook/regnet-y-040"""
__lowerCAmelCase					: List[str]        ="""tabby, tabby cat"""

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





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

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







            """simple docstring"""



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







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			self.convolution(self.padding(lowercase__		)		)
            lowercase														=			self.normalization(lowercase__		)
            lowercase														=			self.activation(lowercase__		)
            return hidden_state






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

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







            """simple docstring"""



            super().__init__(**lowercase__		)
            lowercase														=			config.num_channels
            lowercase														=			TFRegNetConvLayer(
                out_channels=config.embedding_size	, kernel_size=3	, stride=2	, activation=config.hidden_act	, name="""embedder"""	, )







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			shape_list(lowercase__		)[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)
            lowercase														=			tf.transpose(lowercase__	, perm=(0, 2, 3, 1)		)
            lowercase														=			self.embedder(lowercase__		)
            return hidden_state






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

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







            """simple docstring"""



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







      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase = False		):







            """simple docstring"""



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






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

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







            """simple docstring"""



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







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			self.pooler(lowercase__		)
            for layer_module in self.attention:
                  lowercase														=			layer_module(lowercase__		)
            lowercase														=			hidden_state * pooled
            return hidden_state






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

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







            """simple docstring"""



            super().__init__(**lowercase__		)
            lowercase														=			in_channels != out_channels or stride != 1
            lowercase														=			max(1	, out_channels // config.groups_width		)
            lowercase														=			(
                TFRegNetShortCut(lowercase__	, stride=lowercase__	, 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.
            lowercase														=			[
                TFRegNetConvLayer(lowercase__	, kernel_size=1	, activation=config.hidden_act	, name="""layer.0"""		),
                TFRegNetConvLayer(
                    lowercase__	, stride=lowercase__	, groups=lowercase__	, activation=config.hidden_act	, name="""layer.1"""		),
                TFRegNetConvLayer(lowercase__	, kernel_size=1	, activation=lowercase__	, name="""layer.2"""		),
            ]
            lowercase														=			ACTaFN[config.hidden_act]







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



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






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

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







            """simple docstring"""



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







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



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






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

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







            """simple docstring"""



            super().__init__(**lowercase__		)

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







      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



            for layer_module in self.layers:
                  lowercase														=			layer_module(lowercase__		)
            return hidden_state






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

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







            """simple docstring"""



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







      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase = False	, __lowerCAmelCase = True		):







            """simple docstring"""



            lowercase														=			() if output_hidden_states else None

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

                  lowercase														=			stage_module(lowercase__		)

            if output_hidden_states:
                  lowercase														=			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=lowercase__	, hidden_states=lowercase__		)






@keras_serializable
class 				_A		( tf.keras.layers.Layer			):
      snake_case__    :     Dict													=			RegNetConfig

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







            """simple docstring"""



            super().__init__(**lowercase__		)
            lowercase														=			config
            lowercase														=			TFRegNetEmbeddings(lowercase__	, name="""embedder"""		)
            lowercase														=			TFRegNetEncoder(lowercase__	, name="""encoder"""		)
            lowercase														=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowercase__	, name="""pooler"""		)







      @unpack_inputs
      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase = None	, __lowerCAmelCase = None	, __lowerCAmelCase = False	, ):







            """simple docstring"""



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

            lowercase														=			self.embedder(lowercase__	, training=lowercase__		)

            lowercase														=			self.encoder(
                lowercase__	, output_hidden_states=lowercase__	, return_dict=lowercase__	, training=lowercase__		)

            lowercase														=			encoder_outputs[0]
            lowercase														=			self.pooler(lowercase__		)

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

            # Change the other hidden state outputs to NCHW as well
            if output_hidden_states:
                  lowercase														=			tuple([tf.transpose(lowercase__	, 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=lowercase__	, pooler_output=lowercase__	, hidden_states=hidden_states if output_hidden_states else encoder_outputs.hidden_states	, )






class 				_A		( _UpperCAmelCase			):
      snake_case__    :     Any													=			RegNetConfig
      snake_case__    :     List[Any]													=			"""regnet"""
      snake_case__    :     Tuple													=			"""pixel_values"""

      @property
      def        A__ (		self		):







            """simple docstring"""



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






__lowerCAmelCase					: List[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.
"""

__lowerCAmelCase					: int        =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.'						,					_UpperCAmelCase						,					)
class 				_A		( _UpperCAmelCase			):

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







            """simple docstring"""



            super().__init__(lowercase__	, *lowercase__	, **lowercase__		)
            lowercase														=			TFRegNetMainLayer(lowercase__	, name="""regnet"""		)







      @unpack_inputs
      @add_start_docstrings_to_model_forward(lowercase__		)
      @add_code_sample_docstrings(
          checkpoint=_CHECKPOINT_FOR_DOC	, output_type=lowercase__	, config_class=_CONFIG_FOR_DOC	, modality="""vision"""	, expected_output=_EXPECTED_OUTPUT_SHAPE	, )
      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase = None	, __lowerCAmelCase = None	, __lowerCAmelCase=False	, ):







            """simple docstring"""



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

            lowercase														=			self.regnet(
                pixel_values=lowercase__	, output_hidden_states=lowercase__	, return_dict=lowercase__	, training=lowercase__	, )
            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(
    '\n    RegNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '						,					_UpperCAmelCase						,					)
class 				_A		( _UpperCAmelCase						,					_UpperCAmelCase			):

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







            """simple docstring"""



            super().__init__(lowercase__	, *lowercase__	, **lowercase__		)
            lowercase														=			config.num_labels
            lowercase														=			TFRegNetMainLayer(lowercase__	, name="""regnet"""		)
            # classification head
            lowercase														=			[
                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(lowercase__		)
      @add_code_sample_docstrings(
          checkpoint=_IMAGE_CLASS_CHECKPOINT	, output_type=lowercase__	, config_class=_CONFIG_FOR_DOC	, expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT	, )
      def        A__ (		self	, __lowerCAmelCase = None	, __lowerCAmelCase = None	, __lowerCAmelCase = None	, __lowerCAmelCase = None	, __lowerCAmelCase=False	, ):







            """simple docstring"""



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

            lowercase														=			self.regnet(
                lowercase__	, output_hidden_states=lowercase__	, return_dict=lowercase__	, training=lowercase__		)

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

            lowercase														=			self.classifier[0](lowercase__		)
            lowercase														=			self.classifier[1](lowercase__		)

            lowercase														=			None if labels is None else self.hf_compute_loss(labels=lowercase__	, logits=lowercase__		)

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

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




"""simple docstring"""






import unittest

from transformers import DebertaConfig, 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 (
           DebertaForMaskedLM,
           DebertaForQuestionAnswering,
           DebertaForSequenceClassification,
           DebertaForTokenClassification,
           DebertaModel,
       )
       from transformers.models.deberta.modeling_deberta import DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST





class 				_A		( lowerCAmelCase			):

      def __init__(		self	, __lowerCAmelCase	, __lowerCAmelCase=13	, __lowerCAmelCase=7	, __lowerCAmelCase=True	, __lowerCAmelCase=True	, __lowerCAmelCase=True	, __lowerCAmelCase=True	, __lowerCAmelCase=99	, __lowerCAmelCase=32	, __lowerCAmelCase=5	, __lowerCAmelCase=4	, __lowerCAmelCase=37	, __lowerCAmelCase="gelu"	, __lowerCAmelCase=0.1	, __lowerCAmelCase=0.1	, __lowerCAmelCase=512	, __lowerCAmelCase=16	, __lowerCAmelCase=2	, __lowerCAmelCase=0.0_2	, __lowerCAmelCase=False	, __lowerCAmelCase=True	, __lowerCAmelCase="None"	, __lowerCAmelCase=3	, __lowerCAmelCase=4	, __lowerCAmelCase=None	, ):







            """simple docstring"""



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

      def        A__ (		self		):







            """simple docstring"""



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

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

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

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

            lowercase														=			self.get_config()

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

      def        A__ (		self		):







            """simple docstring"""



            return DebertaConfig(
                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        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.get_config()
            lowercase														=			300
            return config

      def        A__ (		self	, __lowerCAmelCase		):







            """simple docstring"""



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

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			DebertaModel(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase														=			model(__lowerCAmelCase	, attention_mask=__lowerCAmelCase	, token_type_ids=__lowerCAmelCase		)[0]
            lowercase														=			model(__lowerCAmelCase	, token_type_ids=__lowerCAmelCase		)[0]
            lowercase														=			model(__lowerCAmelCase		)[0]

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

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			DebertaForMaskedLM(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase														=			model(__lowerCAmelCase	, attention_mask=__lowerCAmelCase	, token_type_ids=__lowerCAmelCase	, labels=__lowerCAmelCase		)

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

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			self.num_labels
            lowercase														=			DebertaForSequenceClassification(__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase														=			model(__lowerCAmelCase	, attention_mask=__lowerCAmelCase	, token_type_ids=__lowerCAmelCase	, labels=__lowerCAmelCase		)
            self.parent.assertListEqual(list(result.logits.size()		)	, [self.batch_size, self.num_labels]		)
            self.check_loss_output(__lowerCAmelCase		)

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			self.num_labels
            lowercase														=			DebertaForTokenClassification(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase														=			model(__lowerCAmelCase	, attention_mask=__lowerCAmelCase	, token_type_ids=__lowerCAmelCase	, labels=__lowerCAmelCase		)
            self.parent.assertEqual(result.logits.shape	, (self.batch_size, self.seq_length, self.num_labels)		)

      def        A__ (		self	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase	, __lowerCAmelCase		):







            """simple docstring"""



            lowercase														=			DebertaForQuestionAnswering(config=__lowerCAmelCase		)
            model.to(__lowerCAmelCase		)
            model.eval()
            lowercase														=			model(
                __lowerCAmelCase	, attention_mask=__lowerCAmelCase	, token_type_ids=__lowerCAmelCase	, start_positions=__lowerCAmelCase	, end_positions=__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        A__ (		self		):







            """simple docstring"""



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






@require_torch
class 				_A		( lowerCAmelCase						,					lowerCAmelCase						,					unittest.TestCase			):
      snake_case__    :     Any													=			(
          (
              DebertaModel,
              DebertaForMaskedLM,
              DebertaForSequenceClassification,
              DebertaForTokenClassification,
              DebertaForQuestionAnswering,
          )
          if is_torch_available()
          else ()
      )
      snake_case__    :     int													=			(
          {
              'feature-extraction': DebertaModel,
              'fill-mask': DebertaForMaskedLM,
              'question-answering': DebertaForQuestionAnswering,
              'text-classification': DebertaForSequenceClassification,
              'token-classification': DebertaForTokenClassification,
              'zero-shot': DebertaForSequenceClassification,
          }
          if is_torch_available()
          else {}
      )

      snake_case__    :     Optional[Any]													=			True
      snake_case__    :     Optional[Any]													=			False
      snake_case__    :     Optional[int]													=			False
      snake_case__    :     Any													=			False
      snake_case__    :     List[Any]													=			False

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			DebertaModelTester(self		)
            lowercase														=			ConfigTester(self	, config_class=__lowerCAmelCase	, hidden_size=37		)

      def        A__ (		self		):







            """simple docstring"""



            self.config_tester.run_common_tests()

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_model(*__lowerCAmelCase		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_sequence_classification(*__lowerCAmelCase		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_masked_lm(*__lowerCAmelCase		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_question_answering(*__lowerCAmelCase		)

      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_deberta_for_token_classification(*__lowerCAmelCase		)







      @slow
      def        A__ (		self		):







            """simple docstring"""



            for model_name in DEBERTA_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                  lowercase														=			DebertaModel.from_pretrained(__lowerCAmelCase		)
                  self.assertIsNotNone(__lowerCAmelCase		)






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

      @unittest.skip(reason="""Model not available yet"""		)
      def        A__ (		self		):







            """simple docstring"""



            pass







      @slow
      def        A__ (		self		):







            """simple docstring"""



            lowercase														=			DebertaModel.from_pretrained("""microsoft/deberta-base"""		)

            lowercase														=			torch.tensor([[0, 3_1414, 232, 328, 740, 1140, 1_2695, 69, 4_6078, 1588, 2]]		)
            lowercase														=			torch.tensor([[0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]		)
            with torch.no_grad():
                  lowercase														=			model(__lowerCAmelCase	, attention_mask=__lowerCAmelCase		)[0]
            # compare the actual values for a slice.
            lowercase														=			torch.tensor(
                [[[-0.5_9_8_6, -0.8_0_5_5, -0.8_4_6_2], [1.4_4_8_4, -0.9_3_4_8, -0.8_0_5_9], [0.3_1_2_3, 0.0_0_3_2, -1.4_1_3_1]]]		)
            self.assertTrue(torch.allclose(output[:, 1:4, 1:4]	, __lowerCAmelCase	, atol=1E-4		)	, f'{output[:, 1:4, 1:4]}'		)



