'''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_	   = logging.get_logger(__name__)

# General docstring
A_	   = "ResNetConfig"

# Base docstring
A_	   = "microsoft/resnet-50"
A_	   = [1, 2048, 7, 7]

# Image classification docstring
A_	   = "microsoft/resnet-50"
A_	   = "tiger cat"

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




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



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			snake_case_ = 3				,			snake_case_ = 1				,			snake_case_ = "relu"				,			**snake_case_					):
									super().__init__(**snake_case_					)
									snake_case :       Union[str, Any]				=    kernel_size // 2
									snake_case :       Any				=    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
									snake_case :       str				=    tf.keras.layers.BatchNormalization(epsilon=1e-5				,			momentum=0.9				,			name="normalization"					)
									snake_case :       Optional[Any]				=    ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"					)



			def   lowerCamelCase (							self				,			snake_case_					):
									# Pad to match that done in the PyTorch Conv2D model
									snake_case :       Dict				=    (self.pad_value, self.pad_value)
									snake_case :       str				=    tf.pad(snake_case_				,			[(0, 0), height_pad, width_pad, (0, 0)]					)
									snake_case :       Tuple				=    self.conv(snake_case_					)
									return hidden_state






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									snake_case :       List[str]				=    self.convolution(snake_case_					)
									snake_case :       Dict				=    self.normalization(snake_case_				,			training=snake_case_					)
									snake_case :       Tuple				=    self.activation(snake_case_					)
									return hidden_state







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



			"""simple docstring"""






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






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									snake_case				,					snake_case				,					snake_case				,					snake_case :       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."					)
									snake_case :       Tuple				=    pixel_values
									snake_case :       Tuple				=    self.embedder(snake_case_					)
									snake_case :       Optional[int]				=    tf.pad(snake_case_				,			[[0, 0], [1, 1], [1, 1], [0, 0]]					)
									snake_case :       List[Any]				=    self.pooler(snake_case_					)
									return hidden_state







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



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			snake_case_ = 2				,			**snake_case_					):
									super().__init__(**snake_case_					)
									snake_case :       Union[str, Any]				=    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
									snake_case :       Optional[int]				=    tf.keras.layers.BatchNormalization(epsilon=1e-5				,			momentum=0.9				,			name="normalization"					)






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									snake_case :       List[Any]				=    x
									snake_case :       Dict				=    self.convolution(snake_case_					)
									snake_case :       Tuple				=    self.normalization(snake_case_				,			training=snake_case_					)
									return hidden_state







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



			"""simple docstring"""






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






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									snake_case :       Optional[Any]				=    hidden_state
									snake_case :       Any				=    self.conva(snake_case_				,			training=snake_case_					)
									snake_case :       List[Any]				=    self.conva(snake_case_				,			training=snake_case_					)
									snake_case :       Union[str, Any]				=    self.shortcut(snake_case_				,			training=snake_case_					)
									hidden_state += residual
									snake_case :       Any				=    self.activation(snake_case_					)
									return hidden_state







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



			"""simple docstring"""






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






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									snake_case :       Union[str, Any]				=    hidden_state
									snake_case :       int				=    self.conva(snake_case_				,			training=snake_case_					)
									snake_case :       List[str]				=    self.conva(snake_case_				,			training=snake_case_					)
									snake_case :       Optional[Any]				=    self.conva(snake_case_				,			training=snake_case_					)
									snake_case :       int				=    self.shortcut(snake_case_				,			training=snake_case_					)
									hidden_state += residual
									snake_case :       Optional[int]				=    self.activation(snake_case_					)
									return hidden_state







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



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			snake_case_				,			snake_case_				,			snake_case_ = 2				,			snake_case_ = 2				,			**snake_case_					):
									super().__init__(**snake_case_					)

									snake_case :       List[Any]				=    TFResNetBottleNeckLayer if config.layer_type == "bottleneck" else TFResNetBasicLayer

									snake_case :       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					)
									]
									snake_case :       Tuple				=    layers






			def   lowerCamelCase (							self				,			snake_case_				,			snake_case_ = False					):
									for layer in self.stage_layers:
															snake_case :       List[Any]				=    layer(snake_case_				,			training=snake_case_					)
									return hidden_state







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



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			**snake_case_					):
									super().__init__(**snake_case_					)
									# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
									snake_case :       Tuple				=    [
									    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				,			snake_case_				,			snake_case_ = False				,			snake_case_ = True				,			snake_case_ = False				,			):
									snake_case :       str				=    () if output_hidden_states else None

									for stage_module in self.stages:
															if output_hidden_states:
																					snake_case :       List[str]				=    hidden_states + (hidden_state,)

															snake_case :       List[Any]				=    stage_module(snake_case_				,			training=snake_case_					)

									if output_hidden_states:
															snake_case :       Tuple				=    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 		SCREAMING_SNAKE_CASE_					(_UpperCAmelCase      ):



			"""simple docstring"""






			__magic_name__ :				List[str]   							=       ResNetConfig
			__magic_name__ :				Union[str, Any]   							=       """resnet"""
			__magic_name__ :				int   							=       """pixel_values"""



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







A_	   = 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_	   = 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 		SCREAMING_SNAKE_CASE_					(tf.keras.layers.Layer      ):



			"""simple docstring"""






			__magic_name__ :				Tuple   							=       ResNetConfig



			def __init__(							self				,			snake_case_				,			**snake_case_					):
									super().__init__(**snake_case_					)
									snake_case :       Union[str, Any]				=    config
									snake_case :       List[str]				=    TFResNetEmbeddings(snake_case_				,			name="embedder"					)
									snake_case :       Any				=    TFResNetEncoder(snake_case_				,			name="encoder"					)
									snake_case :       List[Any]				=    tf.keras.layers.GlobalAveragePoolingaD(keepdims=snake_case_					)






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

									snake_case :       Union[str, Any]				=    self.encoder(
									    snake_case_				,			output_hidden_states=snake_case_				,			return_dict=snake_case_				,			training=snake_case_					)

									snake_case :       Any				=    encoder_outputs[0]

									snake_case :       int				=    self.pooler(snake_case_					)

									# Transpose all the outputs to the NCHW format
									# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
									snake_case :       int				=    tf.transpose(snake_case_				,			(0, 3, 1, 2)					)
									snake_case :       Any				=    tf.transpose(snake_case_				,			(0, 3, 1, 2)					)
									snake_case :       str				=    ()
									for hidden_state in encoder_outputs[1:]:
															snake_case :       Optional[Any]				=    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

									snake_case :       Any				=    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 		SCREAMING_SNAKE_CASE_					(_UpperCAmelCase      ):



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			**snake_case_					):
									super().__init__(snake_case_				,			**snake_case_					)
									snake_case :       Optional[int]				=    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				,			snake_case_				,			snake_case_ = None				,			snake_case_ = None				,			snake_case_ = False				,			):
									snake_case :       List[Any]				=    (
									    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
									)
									snake_case :       List[str]				=    return_dict if return_dict is not None else self.config.use_return_dict

									snake_case :       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(
    """
    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for
    ImageNet.
    """							,				_UpperCAmelCase							,				)
class 		SCREAMING_SNAKE_CASE_					(_UpperCAmelCase							,				_UpperCAmelCase      ):



			"""simple docstring"""






			def __init__(							self				,			snake_case_				,			**snake_case_					):
									super().__init__(snake_case_				,			**snake_case_					)
									snake_case :       Any				=    config.num_labels
									snake_case :       Union[str, Any]				=    TFResNetMainLayer(snake_case_				,			name="resnet"					)
									# classification head
									snake_case :       List[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				,			snake_case_					):
									snake_case :       int				=    tf.keras.layers.Flatten()(snake_case_					)
									snake_case :       List[str]				=    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				,			snake_case_ = None				,			snake_case_ = None				,			snake_case_ = None				,			snake_case_ = None				,			snake_case_ = False				,			):
									snake_case :       Optional[int]				=    return_dict if return_dict is not None else self.config.use_return_dict

									snake_case :       Dict				=    self.resnet(
									    snake_case_				,			output_hidden_states=snake_case_				,			return_dict=snake_case_				,			training=snake_case_					)

									snake_case :       List[Any]				=    outputs.pooler_output if return_dict else outputs[1]

									snake_case :       Optional[Any]				=    self.classifier(snake_case_					)

									snake_case :       Any				=    None if labels is None else self.hf_compute_loss(snake_case_				,			snake_case_					)

									if not return_dict:
															snake_case :       Tuple				=    (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					)






'''simple docstring'''

# Copyright 2023 The HuggingFace Team. All rights reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#     http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
from typing import TYPE_CHECKING

# rely on isort to merge the imports
from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_torch_available,
)


A_	   = {
    "configuration_convnextv2": [
        "CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP",
        "ConvNextV2Config",
    ]
}

try:
						if not is_torch_available():
												raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
						pass
else:
						A_	   = [
						    "CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST",
						    "ConvNextV2ForImageClassification",
						    "ConvNextV2Model",
						    "ConvNextV2PreTrainedModel",
						    "ConvNextV2Backbone",
						]


if TYPE_CHECKING:
						from .configuration_convnextva import (
						    CONVNEXTV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
						    ConvNextVaConfig,
						)

						try:
												if not is_torch_available():
																		raise OptionalDependencyNotAvailable()
						except OptionalDependencyNotAvailable:
												pass
						else:
												from .modeling_convnextva import (
												    CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST,
												    ConvNextVaBackbone,
												    ConvNextVaForImageClassification,
												    ConvNextVaModel,
												    ConvNextVaPreTrainedModel,
												)

else:
						import sys

						A_	   = _LazyModule(__name__, globals()["__file__"], _import_structure)





