






'''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


__A      :       int      =	logging.get_logger(__name__)

# General docstring
__A      :       List[str]      =	'ResNetConfig'

# Base docstring
__A      :       Optional[Any]      =	'microsoft/resnet-50'
__A      :       Dict      =	[1, 2_0_4_8, 7, 7]

# Image classification docstring
__A      :       Optional[Any]      =	'microsoft/resnet-50'
__A      :       List[str]      =	'tiger cat'

__A      :       Optional[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    :	str				,				lowercase__    :	int				,				lowercase__    :	int = 3				,				lowercase__    :	int = 1				,				lowercase__    :	str = "relu"				,				**lowercase__    :	List[str]					)  ->       None:
           super().__init__(**lowercase__					)
           __A		   =      kernel_size // 2
           __A		   =      tf.keras.layers.ConvaD(
               lowercase__				,				kernel_size=lowercase__				,				strides=lowercase__				,				padding="valid"				,				use_bias=lowercase__				,				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    :	List[str]				,				lowercase__    :	tf.Tensor					)  ->       tf.Tensor:
           # Pad to match that done in the PyTorch Conv2D model
           __A		   =      __A		   =      (self.pad_value, self.pad_value)
           __A		   =      tf.pad(lowercase__				,				[(0, 0), height_pad, width_pad, (0, 0)]					)
           __A		   =      self.conv(lowercase__					)
           return hidden_state






     def     _UpperCamelCase   (self    :	int				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           __A		   =      self.convolution(lowercase__					)
           __A		   =      self.normalization(lowercase__				,				training=lowercase__					)
           __A		   =      self.activation(lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







     def __init__(self    :	List[Any]				,				lowercase__    :	ResNetConfig				,				**lowercase__    :	Optional[Any]					)  ->       None:
           super().__init__(**lowercase__					)
           __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    :	List[Any]				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           __A   ,				__A   ,				__A   ,				__A		   =      shape_list(lowercase__					)
           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(lowercase__					)
           __A		   =      tf.pad(lowercase__				,				[[0, 0], [1, 1], [1, 1], [0, 0]]					)
           __A		   =      self.pooler(lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







     def __init__(self    :	Union[str, Any]				,				lowercase__    :	int				,				lowercase__    :	int = 2				,				**lowercase__    :	Any					)  ->       None:
           super().__init__(**lowercase__					)
           __A		   =      tf.keras.layers.ConvaD(
               lowercase__				,				kernel_size=1				,				strides=lowercase__				,				use_bias=lowercase__				,				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    :	List[Any]				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           __A		   =      x
           __A		   =      self.convolution(lowercase__					)
           __A		   =      self.normalization(lowercase__				,				training=lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







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






     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           __A		   =      hidden_state
           __A		   =      self.conva(lowercase__				,				training=lowercase__					)
           __A		   =      self.conva(lowercase__				,				training=lowercase__					)
           __A		   =      self.shortcut(lowercase__				,				training=lowercase__					)
           hidden_state += residual
           __A		   =      self.activation(lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







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






     def     _UpperCamelCase   (self    :	Dict				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           __A		   =      hidden_state
           __A		   =      self.conva(lowercase__				,				training=lowercase__					)
           __A		   =      self.conva(lowercase__				,				training=lowercase__					)
           __A		   =      self.conva(lowercase__				,				training=lowercase__					)
           __A		   =      self.shortcut(lowercase__				,				training=lowercase__					)
           hidden_state += residual
           __A		   =      self.activation(lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







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

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

           __A		   =      [layer(lowercase__				,				lowercase__				,				stride=lowercase__				,				activation=config.hidden_act				,				name="layers.0"					)]
           layers += [
               layer(lowercase__				,				lowercase__				,				activation=config.hidden_act				,				name=f"layers.{i + 1}"					)
               for i in range(depth - 1					)
           ]
           __A		   =      layers






     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False					)  ->       tf.Tensor:
           for layer in self.stage_layers:
                 __A		   =      layer(lowercase__				,				training=lowercase__					)
           return hidden_state







class 					a__    (			tf.keras.layers.Layer						):
     '''simple docstring'''







     def __init__(self    :	int				,				lowercase__    :	ResNetConfig				,				**lowercase__    :	Tuple					)  ->       None:
           super().__init__(**lowercase__					)
           # based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
           __A		   =      [
               TFResNetStage(
                   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"				,				)
           ]
           for i, (in_channels, out_channels, depth) in enumerate(
               zip(config.hidden_sizes				,				config.hidden_sizes[1:]				,				config.depths[1:]					)					):
                 self.stages.append(TFResNetStage(lowercase__				,				lowercase__				,				lowercase__				,				depth=lowercase__				,				name=f"stages.{i + 1}"					)					)






     def     _UpperCamelCase   (self    :	str				,				lowercase__    :	tf.Tensor				,				lowercase__    :	bool = False				,				lowercase__    :	bool = True				,				lowercase__    :	bool = False				,				)  ->       TFBaseModelOutputWithNoAttention:
           __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(lowercase__				,				training=lowercase__					)

           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=lowercase__				,				hidden_states=lowercase__					)







class 					a__    (			lowerCamelCase						):
     '''simple docstring'''







     _snake_case             =  ResNetConfig
     _snake_case             =  'resnet'
     _snake_case             =  'pixel_values'






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







__A      :       Union[str, 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'


__A      :       Optional[int]      =	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'''







     _snake_case             =  ResNetConfig






     def __init__(self    :	Tuple				,				lowercase__    :	ResNetConfig				,				**lowercase__    :	int					)  ->       None:
           super().__init__(**lowercase__					)
           __A		   =      config
           __A		   =      TFResNetEmbeddings(lowercase__				,				name="embedder"					)
           __A		   =      TFResNetEncoder(lowercase__				,				name="encoder"					)
           __A		   =      tf.keras.layers.GlobalAveragePoolingaD(keepdims=lowercase__					)






     @unpack_inputs
     def     _UpperCamelCase   (self    :	List[Any]				,				lowercase__    :	tf.Tensor				,				lowercase__    :	Optional[bool] = None				,				lowercase__    :	Optional[bool] = None				,				lowercase__    :	bool = False				,				)  ->       Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
           __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(lowercase__				,				perm=[0, 2, 3, 1]					)
           __A		   =      self.embedder(lowercase__				,				training=lowercase__					)

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

           __A		   =      encoder_outputs[0]

           __A		   =      self.pooler(lowercase__					)

           # Transpose all the outputs to the NCHW format
           # (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
           __A		   =      tf.transpose(lowercase__				,				(0, 3, 1, 2)					)
           __A		   =      tf.transpose(lowercase__				,				(0, 3, 1, 2)					)
           __A		   =      ()
           for hidden_state in encoder_outputs[1:]:
                 __A		   =      hidden_states + tuple(tf.transpose(lowercase__				,				(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=lowercase__				,				pooler_output=lowercase__				,				hidden_states=lowercase__				,				)







@add_start_docstrings(
    'The bare ResNet model outputting raw features without any specific head on top.' ,						lowerCamelCase ,						)
class 					a__    (			lowerCamelCase						):
     '''simple docstring'''







     def __init__(self    :	int				,				lowercase__    :	ResNetConfig				,				**lowercase__    :	Optional[int]					)  ->       None:
           super().__init__(lowercase__				,				**lowercase__					)
           __A		   =      TFResNetMainLayer(config=lowercase__				,				name="resnet"					)






     @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				,				)
     @unpack_inputs
     def     _UpperCamelCase   (self    :	Tuple				,				lowercase__    :	tf.Tensor				,				lowercase__    :	Optional[bool] = None				,				lowercase__    :	Optional[bool] = None				,				lowercase__    :	bool = False				,				)  ->       Union[Tuple[tf.Tensor], TFBaseModelOutputWithPoolingAndNoAttention]:
           __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=lowercase__				,				output_hidden_states=lowercase__				,				return_dict=lowercase__				,				training=lowercase__				,				)
           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 					a__    (			lowerCamelCase ,						lowerCamelCase						):
     '''simple docstring'''







     def __init__(self    :	Any				,				lowercase__    :	ResNetConfig				,				**lowercase__    :	int					)  ->       None:
           super().__init__(lowercase__				,				**lowercase__					)
           __A		   =      config.num_labels
           __A		   =      TFResNetMainLayer(lowercase__				,				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    :	Dict				,				lowercase__    :	tf.Tensor					)  ->       tf.Tensor:
           __A		   =      tf.keras.layers.Flatten()(lowercase__					)
           __A		   =      self.classifier_layer(lowercase__					)
           return logits






     @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				,				)
     @unpack_inputs
     def     _UpperCamelCase   (self    :	Dict				,				lowercase__    :	tf.Tensor = None				,				lowercase__    :	tf.Tensor = None				,				lowercase__    :	bool = None				,				lowercase__    :	bool = None				,				lowercase__    :	bool = False				,				)  ->       Union[Tuple[tf.Tensor], TFImageClassifierOutputWithNoAttention]:
           __A		   =      return_dict if return_dict is not None else self.config.use_return_dict

           __A		   =      self.resnet(
               lowercase__				,				output_hidden_states=lowercase__				,				return_dict=lowercase__				,				training=lowercase__					)

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

           __A		   =      self.classifier(lowercase__					)

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

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

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










'''simple docstring'''







from typing import TYPE_CHECKING

from ...utils import OptionalDependencyNotAvailable, _LazyModule, is_torch_available


__A      :       str      =	{'configuration_umt5': ['UMT5Config', 'UMT5OnnxConfig']}


try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       __A      :       str      =	[
           'UMT5EncoderModel',
           'UMT5ForConditionalGeneration',
           'UMT5ForQuestionAnswering',
           'UMT5Model',
           'UMT5PreTrainedModel',
       ]

if TYPE_CHECKING:
       from .configuration_umta import UMTaConfig, UMTaOnnxConfig

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_umta import (
                  UMTaEncoderModel,
                  UMTaForConditionalGeneration,
                  UMTaForQuestionAnswering,
                  UMTaModel,
                  UMTaPreTrainedModel,
              )
else:
       import sys

       __A      :       Optional[int]      =	_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)


