


'''simple docstring'''



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


__UpperCAmelCase			:int 				=   logging.get_logger(__name__)

# General docstring
__UpperCAmelCase			:str 				=   "ResNetConfig"

# Base docstring
__UpperCAmelCase			:Dict 				=   "microsoft/resnet-50"
__UpperCAmelCase			:Dict 				=   [1, 2_0_4_8, 7, 7]

# Image classification docstring
__UpperCAmelCase			:Optional[Any] 				=   "microsoft/resnet-50"
__UpperCAmelCase			:str 				=   "tiger cat"

__UpperCAmelCase			:Union[str, Any] 				=   [
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]



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


     """simple docstring"""






     def __init__(				self     :		Optional[int]							, snake_case     :		List[Any]							, snake_case     :		List[str] = 3							, snake_case     :		Union[str, Any] = 1							, snake_case     :		Optional[int] = "relu"							, **snake_case     :		List[Any]			)						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: Tuple  							=			kernel_size // 2
          __UpperCAmelCase	: Tuple  							=			tf.keras.layers.ConvaD(
              snake_case							, kernel_size=snake_case							, strides=snake_case							, padding='''valid'''							, use_bias=snake_case							, name='''convolution'''			)
          # Use same default momentum and epsilon as PyTorch equivalent
          __UpperCAmelCase	: int  							=			tf.keras.layers.BatchNormalization(epsilon=1E-5							, momentum=0.9							, name='''normalization'''			)
          __UpperCAmelCase	: Union[str, Any]  							=			ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('''linear'''			)

     def  lowerCamelCase__ (				self     :		List[str]							, snake_case     :		List[str]			)						->							tf.Tensor:
          __UpperCAmelCase	: Optional[Any]  							=			(self.pad_value, self.pad_value)
          __UpperCAmelCase	: Optional[Any]  							=			tf.pad(snake_case							, [(0, 0), height_pad, width_pad, (0, 0)]			)
          __UpperCAmelCase	: Dict  							=			self.conv(snake_case			)
          return hidden_state






     def  lowerCamelCase__ (				self     :		Optional[int]							, snake_case     :		int							, snake_case     :		List[str] = False			)						->							tf.Tensor:
          __UpperCAmelCase	: List[str]  							=			self.convolution(snake_case			)
          __UpperCAmelCase	: List[str]  							=			self.normalization(snake_case							, training=snake_case			)
          __UpperCAmelCase	: List[str]  							=			self.activation(snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		Optional[Any]							, snake_case     :		List[Any]							, **snake_case     :		int			)						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: Union[str, Any]  							=			TFResNetConvLayer(
              config.embedding_size							, kernel_size=7							, stride=2							, activation=config.hidden_act							, name='''embedder'''							, )
          __UpperCAmelCase	: Any  							=			tf.keras.layers.MaxPoolaD(pool_size=3							, strides=2							, padding='''valid'''							, name='''pooler'''			)
          __UpperCAmelCase	: int  							=			config.num_channels






     def  lowerCamelCase__ (				self     :		Dict							, snake_case     :		List[str]							, snake_case     :		Union[str, Any] = False			)						->							tf.Tensor:
          __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase							,   __UpperCAmelCase	: Dict  							=			shape_list(snake_case			)
          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.'''			)
          __UpperCAmelCase	: Optional[int]  							=			pixel_values
          __UpperCAmelCase	: str  							=			self.embedder(snake_case			)
          __UpperCAmelCase	: Tuple  							=			tf.pad(snake_case							, [[0, 0], [1, 1], [1, 1], [0, 0]]			)
          __UpperCAmelCase	: Tuple  							=			self.pooler(snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		Optional[int]							, snake_case     :		Tuple							, snake_case     :		Tuple = 2							, **snake_case     :		Dict			)						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: List[str]  							=			tf.keras.layers.ConvaD(
              snake_case							, kernel_size=1							, strides=snake_case							, use_bias=snake_case							, name='''convolution'''			)
          # Use same default momentum and epsilon as PyTorch equivalent
          __UpperCAmelCase	: Tuple  							=			tf.keras.layers.BatchNormalization(epsilon=1E-5							, momentum=0.9							, name='''normalization'''			)






     def  lowerCamelCase__ (				self     :		Dict							, snake_case     :		Tuple							, snake_case     :		Tuple = False			)						->							tf.Tensor:
          __UpperCAmelCase	: List[Any]  							=			x
          __UpperCAmelCase	: Optional[Any]  							=			self.convolution(snake_case			)
          __UpperCAmelCase	: int  							=			self.normalization(snake_case							, training=snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		int							, snake_case     :		Any							, snake_case     :		Tuple							, snake_case     :		Union[str, Any] = 1							, snake_case     :		str = "relu"							, **snake_case     :		Tuple			)						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: Tuple  							=			in_channels != out_channels or stride != 1
          __UpperCAmelCase	: List[str]  							=			TFResNetConvLayer(snake_case							, stride=snake_case							, name='''layer.0'''			)
          __UpperCAmelCase	: Tuple  							=			TFResNetConvLayer(snake_case							, activation=snake_case							, name='''layer.1'''			)
          __UpperCAmelCase	: Any  							=			(
              TFResNetShortCut(snake_case							, stride=snake_case							, name='''shortcut'''			)
              if should_apply_shortcut
              else tf.keras.layers.Activation('''linear'''							, name='''shortcut'''			)
          )
          __UpperCAmelCase	: Any  							=			ACTaFN[activation]






     def  lowerCamelCase__ (				self     :		Any							, snake_case     :		List[str]							, snake_case     :		Dict = False			)						->							tf.Tensor:
          __UpperCAmelCase	: Optional[int]  							=			hidden_state
          __UpperCAmelCase	: List[Any]  							=			self.conva(snake_case							, training=snake_case			)
          __UpperCAmelCase	: List[Any]  							=			self.conva(snake_case							, training=snake_case			)
          __UpperCAmelCase	: List[str]  							=			self.shortcut(snake_case							, training=snake_case			)
          hidden_state += residual
          __UpperCAmelCase	: Any  							=			self.activation(snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		Tuple							, snake_case     :		Any							, snake_case     :		Any							, snake_case     :		List[Any] = 1							, snake_case     :		List[Any] = "relu"							, snake_case     :		Optional[Any] = 4							, **snake_case     :		Tuple							, )						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: Any  							=			in_channels != out_channels or stride != 1
          __UpperCAmelCase	: Tuple  							=			out_channels // reduction
          __UpperCAmelCase	: Union[str, Any]  							=			TFResNetConvLayer(snake_case							, kernel_size=1							, name='''layer.0'''			)
          __UpperCAmelCase	: List[str]  							=			TFResNetConvLayer(snake_case							, stride=snake_case							, name='''layer.1'''			)
          __UpperCAmelCase	: int  							=			TFResNetConvLayer(snake_case							, kernel_size=1							, activation=snake_case							, name='''layer.2'''			)
          __UpperCAmelCase	: List[str]  							=			(
              TFResNetShortCut(snake_case							, stride=snake_case							, name='''shortcut'''			)
              if should_apply_shortcut
              else tf.keras.layers.Activation('''linear'''							, name='''shortcut'''			)
          )
          __UpperCAmelCase	: List[Any]  							=			ACTaFN[activation]






     def  lowerCamelCase__ (				self     :		List[str]							, snake_case     :		List[Any]							, snake_case     :		Tuple = False			)						->							tf.Tensor:
          __UpperCAmelCase	: Optional[Any]  							=			hidden_state
          __UpperCAmelCase	: Any  							=			self.conva(snake_case							, training=snake_case			)
          __UpperCAmelCase	: Union[str, Any]  							=			self.conva(snake_case							, training=snake_case			)
          __UpperCAmelCase	: str  							=			self.conva(snake_case							, training=snake_case			)
          __UpperCAmelCase	: Optional[int]  							=			self.shortcut(snake_case							, training=snake_case			)
          hidden_state += residual
          __UpperCAmelCase	: Optional[int]  							=			self.activation(snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		Tuple							, snake_case     :		List[Any]							, snake_case     :		Tuple							, snake_case     :		Tuple							, snake_case     :		Optional[int] = 2							, snake_case     :		Union[str, Any] = 2							, **snake_case     :		Optional[int]			)						->							None:
          super().__init__(**snake_case			)

          __UpperCAmelCase	: int  							=			TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

          __UpperCAmelCase	: Any  							=			[layer(snake_case							, snake_case							, stride=snake_case							, activation=config.hidden_act							, name='''layers.0'''			)]
          layers += [
              layer(snake_case							, snake_case							, activation=config.hidden_act							, name=f'layers.{i + 1}'			)
              for i in range(depth - 1			)
          ]
          __UpperCAmelCase	: Tuple  							=			layers






     def  lowerCamelCase__ (				self     :		Optional[Any]							, snake_case     :		Dict							, snake_case     :		List[Any] = False			)						->							tf.Tensor:



          for layer in self.stage_layers:
               __UpperCAmelCase	: int  							=			layer(snake_case							, training=snake_case			)
          return hidden_state



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


     """simple docstring"""






     def __init__(				self     :		str							, snake_case     :		Optional[int]							, **snake_case     :		str			)						->							None:
          super().__init__(**snake_case			)
          # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
          __UpperCAmelCase	: Union[str, Any]  							=			[
              TFResNetStage(
                  snake_case							, 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(snake_case							, snake_case							, snake_case							, depth=snake_case							, name=f'stages.{i + 1}'			)			)






     def  lowerCamelCase__ (				self     :		Any							, snake_case     :		Dict							, snake_case     :		Tuple = False							, snake_case     :		Optional[Any] = True							, snake_case     :		Optional[Any] = False							, )						->							TFBaseModelOutputWithNoAttention:
          __UpperCAmelCase	: Dict  							=			() if output_hidden_states else None

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

               __UpperCAmelCase	: Any  							=			stage_module(snake_case							, training=snake_case			)

          if output_hidden_states:
               __UpperCAmelCase	: Optional[Any]  							=			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=snake_case							, hidden_states=snake_case			)



class 	a				(		UpperCamelCase__       ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE       : List[Any]							   =   ResNetConfig
     SCREAMING_SNAKE_CASE       : str							   =   """resnet"""
     SCREAMING_SNAKE_CASE       : List[str]							   =   """pixel_values"""

     @property
     def  lowerCamelCase__ (				self     :		Optional[int]			)						->							Union[str, Any]:
          return {"pixel_values": tf.TensorSpec(shape=(None, self.config.num_channels, 224, 224)							, dtype=tf.floataa			)}



__UpperCAmelCase			:Any 				=   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"


__UpperCAmelCase			:Dict 				=   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 	a				(		tf.keras.layers.Layer       ):


     """simple docstring"""






     SCREAMING_SNAKE_CASE       : List[str]							   =   ResNetConfig

     def __init__(				self     :		Optional[Any]							, snake_case     :		Dict							, **snake_case     :		Any			)						->							None:
          super().__init__(**snake_case			)
          __UpperCAmelCase	: Dict  							=			config
          __UpperCAmelCase	: List[Any]  							=			TFResNetEmbeddings(snake_case							, name='''embedder'''			)
          __UpperCAmelCase	: List[str]  							=			TFResNetEncoder(snake_case							, name='''encoder'''			)
          __UpperCAmelCase	: Optional[Any]  							=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case			)






     @unpack_inputs
     def  lowerCamelCase__ (				self     :		List[str]							, snake_case     :		str							, snake_case     :		int = None							, snake_case     :		str = None							, snake_case     :		str = False							, )						->							Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
          __UpperCAmelCase	: Optional[Any]  							=			(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          __UpperCAmelCase	: int  							=			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)
          __UpperCAmelCase	: List[str]  							=			tf.transpose(snake_case							, perm=[0, 2, 3, 1]			)
          __UpperCAmelCase	: Dict  							=			self.embedder(snake_case							, training=snake_case			)

          __UpperCAmelCase	: List[str]  							=			self.encoder(
              snake_case							, output_hidden_states=snake_case							, return_dict=snake_case							, training=snake_case			)

          __UpperCAmelCase	: List[Any]  							=			encoder_outputs[0]

          __UpperCAmelCase	: Union[str, Any]  							=			self.pooler(snake_case			)

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

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

          __UpperCAmelCase	: List[str]  							=			hidden_states if output_hidden_states else None

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



@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."	,  UpperCamelCase__	,  )
class 	a				(		UpperCamelCase__       ):


     """simple docstring"""






     def __init__(				self     :		Dict							, snake_case     :		Tuple							, **snake_case     :		Union[str, Any]			)						->							None:
          super().__init__(snake_case							, **snake_case			)
          __UpperCAmelCase	: Any  							=			TFResNetMainLayer(config=snake_case							, name='''resnet'''			)






     @add_start_docstrings_to_model_forward(snake_case			)
     @add_code_sample_docstrings(
         checkpoint=_CHECKPOINT_FOR_DOC							, output_type=snake_case							, config_class=_CONFIG_FOR_DOC							, modality='''vision'''							, expected_output=_EXPECTED_OUTPUT_SHAPE							, )
     @unpack_inputs
     def  lowerCamelCase__ (				self     :		Any							, snake_case     :		int							, snake_case     :		List[str] = None							, snake_case     :		Union[str, Any] = None							, snake_case     :		int = False							, )						->							Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
          __UpperCAmelCase	: Union[str, Any]  							=			(
              output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
          )
          __UpperCAmelCase	: List[Any]  							=			return_dict if return_dict is not None else self.config.use_return_dict

          __UpperCAmelCase	: Dict  							=			self.resnet(
              pixel_values=snake_case							, output_hidden_states=snake_case							, return_dict=snake_case							, training=snake_case							, )
          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    "	,  UpperCamelCase__	,  )
class 	a				(		UpperCamelCase__	,  UpperCamelCase__       ):


     """simple docstring"""






     def __init__(				self     :		Any							, snake_case     :		Union[str, Any]							, **snake_case     :		List[Any]			)						->							None:
          super().__init__(snake_case							, **snake_case			)
          __UpperCAmelCase	: int  							=			config.num_labels
          __UpperCAmelCase	: Dict  							=			TFResNetMainLayer(snake_case							, name='''resnet'''			)
          # classification head
          __UpperCAmelCase	: Optional[Any]  							=			(
              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  lowerCamelCase__ (				self     :		List[Any]							, snake_case     :		Optional[int]			)						->							tf.Tensor:
          __UpperCAmelCase	: Dict  							=			tf.keras.layers.Flatten()(snake_case			)
          __UpperCAmelCase	: Union[str, Any]  							=			self.classifier_layer(snake_case			)
          return logits






     @add_start_docstrings_to_model_forward(snake_case			)
     @add_code_sample_docstrings(
         checkpoint=_IMAGE_CLASS_CHECKPOINT							, output_type=snake_case							, config_class=_CONFIG_FOR_DOC							, expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT							, )
     @unpack_inputs
     def  lowerCamelCase__ (				self     :		Dict							, snake_case     :		Any = None							, snake_case     :		Optional[Any] = None							, snake_case     :		Optional[Any] = None							, snake_case     :		Tuple = None							, snake_case     :		Optional[int] = False							, )						->							Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
          __UpperCAmelCase	: str  							=			return_dict if return_dict is not None else self.config.use_return_dict

          __UpperCAmelCase	: str  							=			self.resnet(
              snake_case							, output_hidden_states=snake_case							, return_dict=snake_case							, training=snake_case			)

          __UpperCAmelCase	: Dict  							=			outputs.pooler_output if return_dict else outputs[1]

          __UpperCAmelCase	: str  							=			self.classifier(snake_case			)

          __UpperCAmelCase	: Dict  							=			None if labels is None else self.hf_compute_loss(snake_case							, snake_case			)

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

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





import os
import unittest

from transformers import MPNetTokenizerFast
from transformers.models.mpnet.tokenization_mpnet import VOCAB_FILES_NAMES, MPNetTokenizer
from transformers.testing_utils import require_tokenizers, slow

from ...test_tokenization_common import TokenizerTesterMixin




@require_tokenizers
class 			a__       (					UpperCamelCase__   ,					unittest.TestCase      ):
     a		:			Dict							=	MPNetTokenizer
     a		:			Dict							=	MPNetTokenizerFast
     a		:			Optional[int]							=	True
     a		:			Any							=	True







     def 			lowerCAmelCase_				(	self )  ->    Any:



          '''simple docstring'''



          super().setUp()

          a      =      [
              "[UNK]",
              "[CLS]",
              "[SEP]",
              "[PAD]",
              "[MASK]",
              "want",
              "##want",
              "##ed",
              "wa",
              "un",
              "runn",
              "##ing",
              ",",
              "low",
              "lowest",
          ]
          a      =      os.path.join(self.tmpdirname  ,		VOCAB_FILES_NAMES["vocab_file"] )
          with open(self.vocab_file  ,		"w"  ,		encoding="utf-8" ) as vocab_writer:
               vocab_writer.write("".join([x + "\n" for x in vocab_tokens] ) )







     def 			lowerCAmelCase_				(	self  ,		A )  ->    Any:



          '''simple docstring'''



          a      =      "UNwant\u00E9d,running"
          a      =      "unwanted, running"
          return input_text, output_text







     def 			lowerCAmelCase_				(	self )  ->    List[Any]:



          '''simple docstring'''



          a      =      self.tokenizer_class(self.vocab_file )

          a      =      tokenizer.tokenize("UNwant\u00E9d,running" )
          self.assertListEqual(A  ,		["un", "##want", "##ed", ",", "runn", "##ing"] )
          self.assertListEqual(tokenizer.convert_tokens_to_ids(A )  ,		[9, 6, 7, 12, 10, 11] )







     @slow
     def 			lowerCAmelCase_				(	self )  ->    Dict:



          '''simple docstring'''



          a      =      self.tokenizer_class.from_pretrained("microsoft/mpnet-base" )

          a      =      tokenizer.encode("sequence builders"  ,		add_special_tokens=A )
          a      =      tokenizer.encode("multi-sequence build"  ,		add_special_tokens=A )

          a      =      tokenizer.build_inputs_with_special_tokens(A )
          a      =      tokenizer.build_inputs_with_special_tokens(A  ,		A )

          assert encoded_sentence == [0] + text + [2]
          assert encoded_pair == [0] + text + [2] + [2] + text_a + [2]

