

from typing import Optional, Tuple, Union

import tensorflow as tf

from ...activations_tf import ACTaFN
from ...modeling_tf_outputs import (
    TFBaseModelOutputWithNoAttention,
    TFBaseModelOutputWithPoolingAndNoAttention,
    TFImageClassifierOutputWithNoAttention,
)
from ...modeling_tf_utils import TFPreTrainedModel, TFSequenceClassificationLoss, keras_serializable, unpack_inputs
from ...tf_utils import shape_list
from ...utils import add_code_sample_docstrings, add_start_docstrings, add_start_docstrings_to_model_forward, logging
from .configuration_resnet import ResNetConfig


lowerCamelCase         =      logging.get_logger(__name__)

# General docstring
lowerCamelCase         =      '''ResNetConfig'''

# Base docstring
lowerCamelCase         =      '''microsoft/resnet-50'''
lowerCamelCase         =      [1, 2048, 7, 7]

# Image classification docstring
lowerCamelCase         =      '''microsoft/resnet-50'''
lowerCamelCase         =      '''tiger cat'''

lowerCamelCase         =      [
    '''microsoft/resnet-50''',
    # See all resnet models at https://huggingface.co/models?filter=resnet
]







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_ = 3,					lowercase_ = 1,					lowercase_ = "relu",					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=kernel_size // 2
     a__						=tf.keras.layers.ConvaD(
         __lowerCamelCase,					kernel_size=__lowerCamelCase,					strides=__lowerCamelCase,					padding='''valid''',					use_bias=__lowerCamelCase,					name='''convolution''' )
     # Use same default momentum and epsilon as PyTorch equivalent
     a__						=tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='''normalization''' )
     a__						=ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear''' )



   def 				_UpperCAmelCase				(       self,					lowercase_ )							->					tf.Tensor:






     """simple docstring"""






     a__						=(self.pad_value, self.pad_value)
     a__						=tf.pad(__lowerCamelCase,					[(0, 0), height_pad, width_pad, (0, 0)] )
     a__						=self.conv(__lowerCamelCase )
     return hidden_state



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     a__						=self.convolution(__lowerCamelCase )
     a__						=self.normalization(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.activation(__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=TFResNetConvLayer(
         config.embedding_size,					kernel_size=7,					stride=2,					activation=config.hidden_act,					name='''embedder''',					)
     a__						=tf.keras.layers.MaxPoolaD(pool_size=3,					strides=2,					padding='''valid''',					name='''pooler''' )
     a__						=config.num_channels



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     a__						=shape_list(__lowerCamelCase )
     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.''' )
     a__						=pixel_values
     a__						=self.embedder(__lowerCamelCase )
     a__						=tf.pad(__lowerCamelCase,					[[0, 0], [1, 1], [1, 1], [0, 0]] )
     a__						=self.pooler(__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_ = 2,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=tf.keras.layers.ConvaD(
         __lowerCamelCase,					kernel_size=1,					strides=__lowerCamelCase,					use_bias=__lowerCamelCase,					name='''convolution''' )
     # Use same default momentum and epsilon as PyTorch equivalent
     a__						=tf.keras.layers.BatchNormalization(epsilon=1E-5,					momentum=0.9,					name='''normalization''' )



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     a__						=x
     a__						=self.convolution(__lowerCamelCase )
     a__						=self.normalization(__lowerCamelCase,					training=__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_,					lowercase_ = 1,					lowercase_ = "relu",					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=in_channels != out_channels or stride != 1
     a__						=TFResNetConvLayer(__lowerCamelCase,					stride=__lowerCamelCase,					name='''layer.0''' )
     a__						=TFResNetConvLayer(__lowerCamelCase,					activation=__lowerCamelCase,					name='''layer.1''' )
     a__						=(
         TFResNetShortCut(__lowerCamelCase,					stride=__lowerCamelCase,					name='''shortcut''' )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',					name='''shortcut''' )
     )
     a__						=ACTaFN[activation]



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     a__						=hidden_state
     a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.shortcut(__lowerCamelCase,					training=__lowerCamelCase )
     hidden_state += residual
     a__						=self.activation(__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_,					lowercase_ = 1,					lowercase_ = "relu",					lowercase_ = 4,					**lowercase_,					)							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=in_channels != out_channels or stride != 1
     a__						=out_channels // reduction
     a__						=TFResNetConvLayer(__lowerCamelCase,					kernel_size=1,					name='''layer.0''' )
     a__						=TFResNetConvLayer(__lowerCamelCase,					stride=__lowerCamelCase,					name='''layer.1''' )
     a__						=TFResNetConvLayer(__lowerCamelCase,					kernel_size=1,					activation=__lowerCamelCase,					name='''layer.2''' )
     a__						=(
         TFResNetShortCut(__lowerCamelCase,					stride=__lowerCamelCase,					name='''shortcut''' )
         if should_apply_shortcut
         else tf.keras.layers.Activation('''linear''',					name='''shortcut''' )
     )
     a__						=ACTaFN[activation]



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     a__						=hidden_state
     a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.conva(__lowerCamelCase,					training=__lowerCamelCase )
     a__						=self.shortcut(__lowerCamelCase,					training=__lowerCamelCase )
     hidden_state += residual
     a__						=self.activation(__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					lowercase_,					lowercase_,					lowercase_ = 2,					lowercase_ = 2,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )

     a__						=TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

     a__						=[layer(__lowerCamelCase,					__lowerCamelCase,					stride=__lowerCamelCase,					activation=config.hidden_act,					name='''layers.0''' )]
     layers += [
         layer(__lowerCamelCase,					__lowerCamelCase,					activation=config.hidden_act,					name=F"""layers.{i + 1}""" )
         for i in range(depth - 1 )
     ]
     a__						=layers



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False )							->					tf.Tensor:






     """simple docstring"""






     for layer in self.stage_layers:
       a__						=layer(__lowerCamelCase,					training=__lowerCamelCase )
     return hidden_state







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

   '''simple docstring'''




   def __init__(       self,					lowercase_,					**lowercase_ )							->					None:






     """simple docstring"""






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



   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = False,					lowercase_ = True,					lowercase_ = False,					)							->					TFBaseModelOutputWithNoAttention:






     """simple docstring"""






     a__						=() if output_hidden_states else None

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

       a__						=stage_module(__lowerCamelCase,					training=__lowerCamelCase )

     if output_hidden_states:
       a__						=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=__lowerCamelCase,					hidden_states=__lowerCamelCase )







class 		__magic_name__    (							lowerCamelCase__							):

   '''simple docstring'''




   lowerCamelCase__				:			Optional[Any]												=     ResNetConfig
   lowerCamelCase__				:			Dict												=     'resnet'
   lowerCamelCase__				:			Dict												=     'pixel_values'



   @property
   def 				_UpperCAmelCase				(       self )							->					int:






     """simple docstring"""






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





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


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







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

   '''simple docstring'''




   lowerCamelCase__				:			Union[str, Any]												=     ResNetConfig



   def __init__(       self,					lowercase_,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(**__lowerCamelCase )
     a__						=config
     a__						=TFResNetEmbeddings(__lowerCamelCase,					name='''embedder''' )
     a__						=TFResNetEncoder(__lowerCamelCase,					name='''encoder''' )
     a__						=tf.keras.layers.GlobalAveragePoolingaD(keepdims=__lowerCamelCase )



   @unpack_inputs
   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:






     """simple docstring"""






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

     # TF 2.0 image layers can't use NCHW format when running on CPU.
     # We transpose to NHWC format and then transpose back after the full forward pass.
     # (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
     a__						=tf.transpose(__lowerCamelCase,					perm=[0, 2, 3, 1] )
     a__						=self.embedder(__lowerCamelCase,					training=__lowerCamelCase )

     a__						=self.encoder(
         __lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase )

     a__						=encoder_outputs[0]

     a__						=self.pooler(__lowerCamelCase )

     # Transpose all the outputs to the NCHW format
     # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
     a__						=tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) )
     a__						=tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) )
     a__						=()
     for hidden_state in encoder_outputs[1:]:
       a__						=hidden_states + tuple(tf.transpose(__lowerCamelCase,					(0, 3, 1, 2) ) for h in hidden_state )

     if not return_dict:
       return (last_hidden_state, pooled_output) + hidden_states

     a__						=hidden_states if output_hidden_states else None

     return TFBaseModelOutputWithPoolingAndNoAttention(
         last_hidden_state=__lowerCamelCase,					pooler_output=__lowerCamelCase,					hidden_states=__lowerCamelCase,					)







@add_start_docstrings(
    'The bare ResNet model outputting raw features without any specific head on top.'	, lowerCamelCase__	, )
class 		__magic_name__    (							lowerCamelCase__							):

   '''simple docstring'''




   def __init__(       self,					lowercase_,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(__lowerCamelCase,					**__lowerCamelCase )
     a__						=TFResNetMainLayer(config=__lowerCamelCase,					name='''resnet''' )



   @add_start_docstrings_to_model_forward(__lowerCamelCase )
   @add_code_sample_docstrings(
       checkpoint=_CHECKPOINT_FOR_DOC,					output_type=__lowerCamelCase,					config_class=_CONFIG_FOR_DOC,					modality='''vision''',					expected_output=_EXPECTED_OUTPUT_SHAPE,					)
   @unpack_inputs
   def 				_UpperCAmelCase				(       self,					lowercase_,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:






     """simple docstring"""






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

     a__						=self.resnet(
         pixel_values=__lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase,					)
     return resnet_outputs







@add_start_docstrings(
    '\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    '	, lowerCamelCase__	, )
class 		__magic_name__    (							lowerCamelCase__	, lowerCamelCase__							):

   '''simple docstring'''




   def __init__(       self,					lowercase_,					**lowercase_ )							->					None:






     """simple docstring"""






     super().__init__(__lowerCamelCase,					**__lowerCamelCase )
     a__						=config.num_labels
     a__						=TFResNetMainLayer(__lowerCamelCase,					name='''resnet''' )
     # classification head
     a__						=(
         tf.keras.layers.Dense(config.num_labels,					name='''classifier.1''' )
         if config.num_labels > 0
         else tf.keras.layers.Activation('''linear''',					name='''classifier.1''' )
     )



   def 				_UpperCAmelCase				(       self,					lowercase_ )							->					tf.Tensor:






     """simple docstring"""






     a__						=tf.keras.layers.Flatten()(__lowerCamelCase )
     a__						=self.classifier_layer(__lowerCamelCase )
     return logits



   @add_start_docstrings_to_model_forward(__lowerCamelCase )
   @add_code_sample_docstrings(
       checkpoint=_IMAGE_CLASS_CHECKPOINT,					output_type=__lowerCamelCase,					config_class=_CONFIG_FOR_DOC,					expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT,					)
   @unpack_inputs
   def 				_UpperCAmelCase				(       self,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					lowercase_ = None,					lowercase_ = False,					)							->					Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:






     """simple docstring"""






     a__						=return_dict if return_dict is not None else self.config.use_return_dict

     a__						=self.resnet(
         __lowerCamelCase,					output_hidden_states=__lowerCamelCase,					return_dict=__lowerCamelCase,					training=__lowerCamelCase )

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

     a__						=self.classifier(__lowerCamelCase )

     a__						=None if labels is None else self.hf_compute_loss(__lowerCamelCase,					__lowerCamelCase )

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

     return TFImageClassifierOutputWithNoAttention(loss=__lowerCamelCase,					logits=__lowerCamelCase,					hidden_states=outputs.hidden_states )



from typing import TYPE_CHECKING

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


lowerCamelCase     =      {
    '''configuration_deberta_v2''': ['''DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''DebertaV2Config''', '''DebertaV2OnnxConfig'''],
    '''tokenization_deberta_v2''': ['''DebertaV2Tokenizer'''],
}

try:
       if not is_tokenizers_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase     =      ['''DebertaV2TokenizerFast''']

try:
       if not is_tf_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase     =      [
           '''TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''TFDebertaV2ForMaskedLM''',
           '''TFDebertaV2ForQuestionAnswering''',
           '''TFDebertaV2ForSequenceClassification''',
           '''TFDebertaV2ForTokenClassification''',
           '''TFDebertaV2Model''',
           '''TFDebertaV2PreTrainedModel''',
       ]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       lowerCamelCase     =      [
           '''DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST''',
           '''DebertaV2ForMaskedLM''',
           '''DebertaV2ForMultipleChoice''',
           '''DebertaV2ForQuestionAnswering''',
           '''DebertaV2ForSequenceClassification''',
           '''DebertaV2ForTokenClassification''',
           '''DebertaV2Model''',
           '''DebertaV2PreTrainedModel''',
       ]


if TYPE_CHECKING:
       from .configuration_deberta_va import (
           DEBERTA_V2_PRETRAINED_CONFIG_ARCHIVE_MAP,
           DebertaVaConfig,
           DebertaVaOnnxConfig,
       )
       from .tokenization_deberta_va import DebertaVaTokenizer

       try:
              if not is_tokenizers_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .tokenization_deberta_va_fast import DebertaVaTokenizerFast

       try:
              if not is_tf_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_tf_deberta_va import (
                  TF_DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
                  TFDebertaVaForMaskedLM,
                  TFDebertaVaForQuestionAnswering,
                  TFDebertaVaForSequenceClassification,
                  TFDebertaVaForTokenClassification,
                  TFDebertaVaModel,
                  TFDebertaVaPreTrainedModel,
              )

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_deberta_va import (
                  DEBERTA_V2_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DebertaVaForMaskedLM,
                  DebertaVaForMultipleChoice,
                  DebertaVaForQuestionAnswering,
                  DebertaVaForSequenceClassification,
                  DebertaVaForTokenClassification,
                  DebertaVaModel,
                  DebertaVaPreTrainedModel,
              )

else:
       import sys

       lowerCamelCase     =      _LazyModule(__name__, globals()['''__file__'''], _import_structure, module_spec=__spec__)
