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

# General docstring
_UpperCamelCase         =		"ResNetConfig"

# Base docstring
_UpperCamelCase         =		"microsoft/resnet-50"
_UpperCamelCase         =		[1, 20_48, 7, 7]

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

_UpperCamelCase         =		[
    "microsoft/resnet-50",
    # See all resnet models at https://huggingface.co/models?filter=resnet
]
class 	__UpperCAmelCase						(tf.keras.layers.Layer    ):







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(**snake_case_       )
										A__					:    Optional[int]														= kernel_size // 2
										A__					:    int														= 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
										A__					:    Dict														= tf.keras.layers.BatchNormalization(epsilon=1E-5      ,			momentum=0.9      ,			name="""normalization"""       )
										A__					:    Tuple														= ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("""linear"""       )





			def 		lowerCamelCase				( self      ,			snake_case_       ):







										'''simple docstring'''


										A__					:    str														= (self.pad_value, self.pad_value)
										A__					:    Any														= tf.pad(snake_case_      ,			[(0, 0), height_pad, width_pad, (0, 0)]       )
										A__					:    Dict														= self.conv(snake_case_       )
										return hidden_state





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


										A__					:    Tuple														= self.convolution(snake_case_       )
										A__					:    Tuple														= self.normalization(snake_case_      ,			training=snake_case_       )
										A__					:    int														= self.activation(snake_case_       )
										return hidden_state





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







			'''simple docstring'''





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







										'''simple docstring'''


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





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


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





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







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(**snake_case_       )
										A__					:    Optional[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
										A__					:    int														= tf.keras.layers.BatchNormalization(epsilon=1E-5      ,			momentum=0.9      ,			name="""normalization"""       )





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


										A__					:    Any														= x
										A__					:    Any														= self.convolution(snake_case_       )
										A__					:    Any														= self.normalization(snake_case_      ,			training=snake_case_       )
										return hidden_state





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







			'''simple docstring'''





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







										'''simple docstring'''


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





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


										A__					:    Tuple														= hidden_state
										A__					:    Tuple														= self.conva(snake_case_      ,			training=snake_case_       )
										A__					:    Optional[Any]														= self.conva(snake_case_      ,			training=snake_case_       )
										A__					:    Dict														= self.shortcut(snake_case_      ,			training=snake_case_       )
										hidden_state += residual
										A__					:    Union[str, Any]														= self.activation(snake_case_       )
										return hidden_state





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







			'''simple docstring'''





			def __init__( self      ,			snake_case_      ,			snake_case_      ,			snake_case_ = 1      ,			snake_case_ = "relu"      ,			snake_case_ = 4      ,			**snake_case_      ,			):







										'''simple docstring'''


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





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


										A__					:    List[Any]														= hidden_state
										A__					:    Tuple														= self.conva(snake_case_      ,			training=snake_case_       )
										A__					:    Any														= self.conva(snake_case_      ,			training=snake_case_       )
										A__					:    Union[str, Any]														= self.conva(snake_case_      ,			training=snake_case_       )
										A__					:    Tuple														= self.shortcut(snake_case_      ,			training=snake_case_       )
										hidden_state += residual
										A__					:    Optional[Any]														= self.activation(snake_case_       )
										return hidden_state





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







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(**snake_case_       )

										A__					:    str														= TFResNetBottleNeckLayer if config.layer_type == """bottleneck""" else TFResNetBasicLayer

										A__					:    List[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       )
										]
										A__					:    Dict														= layers





			def 		lowerCamelCase				( self      ,			snake_case_      ,			snake_case_ = False       ):







										'''simple docstring'''


										for layer in self.stage_layers:
																	A__					:    List[Any]														= layer(snake_case_      ,			training=snake_case_       )
										return hidden_state





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







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(**snake_case_       )
										# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
										A__					:    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      ,			snake_case_      ,			snake_case_ = False      ,			snake_case_ = True      ,			snake_case_ = False      ,			):







										'''simple docstring'''


										A__					:    Union[str, Any]														= () if output_hidden_states else None

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

																	A__					:    Union[str, Any]														= stage_module(snake_case_      ,			training=snake_case_       )

										if output_hidden_states:
																	A__					:    Optional[int]														= 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 	__UpperCAmelCase						(__A    ):







			'''simple docstring'''
			_UpperCamelCase     :	List[Any]				    =							ResNetConfig
			_UpperCamelCase     :	List[str]				    =							'resnet'
			_UpperCamelCase     :	List[str]				    =							'pixel_values'





			@property
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


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





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







			'''simple docstring'''
			_UpperCamelCase     :	str				    =							ResNetConfig





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







										'''simple docstring'''


										super().__init__(**snake_case_       )
										A__					:    Dict														= config
										A__					:    Optional[int]														= TFResNetEmbeddings(snake_case_      ,			name="""embedder"""       )
										A__					:    Optional[int]														= TFResNetEncoder(snake_case_      ,			name="""encoder"""       )
										A__					:    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      ,			):







										'''simple docstring'''


										A__					:    Optional[Any]														= (
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										A__					:    Optional[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)
										A__					:    str														= tf.transpose(snake_case_      ,			perm=[0, 2, 3, 1]       )
										A__					:    List[Any]														= self.embedder(snake_case_      ,			training=snake_case_       )

										A__					:    Optional[Any]														= self.encoder(
										    snake_case_      ,			output_hidden_states=snake_case_      ,			return_dict=snake_case_      ,			training=snake_case_       )

										A__					:    Dict														= encoder_outputs[0]

										A__					:    Dict														= self.pooler(snake_case_       )

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

										A__					:    Dict														= 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.'       ,      __A       ,      )
class 	__UpperCAmelCase						(__A    ):







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(snake_case_      ,			**snake_case_       )
										A__					:    List[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      ,			snake_case_      ,			snake_case_ = None      ,			snake_case_ = None      ,			snake_case_ = False      ,			):







										'''simple docstring'''


										A__					:    Union[str, Any]														= (
										    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
										)
										A__					:    List[str]														= return_dict if return_dict is not None else self.config.use_return_dict

										A__					:    Optional[Any]														= 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    '       ,      __A       ,      )
class 	__UpperCAmelCase						(__A       ,      __A    ):







			'''simple docstring'''





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







										'''simple docstring'''


										super().__init__(snake_case_      ,			**snake_case_       )
										A__					:    List[str]														= config.num_labels
										A__					:    Dict														= TFResNetMainLayer(snake_case_      ,			name="""resnet"""       )
										# classification head
										A__					:    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_       ):







										'''simple docstring'''


										A__					:    int														= tf.keras.layers.Flatten()(snake_case_       )
										A__					:    Optional[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      ,			snake_case_ = None      ,			snake_case_ = None      ,			snake_case_ = None      ,			snake_case_ = None      ,			snake_case_ = False      ,			):







										'''simple docstring'''


										A__					:    Union[str, Any]														= return_dict if return_dict is not None else self.config.use_return_dict

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

										A__					:    Optional[Any]														= outputs.pooler_output if return_dict else outputs[1]

										A__					:    str														= self.classifier(snake_case_       )

										A__					:    List[Any]														= None if labels is None else self.hf_compute_loss(snake_case_      ,			snake_case_       )

										if not return_dict:
																	A__					:    List[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       )






"""simple docstring"""



import inspect
import os
import unittest

import torch

import accelerate
from accelerate import debug_launcher
from accelerate.test_utils import (
    execute_subprocess_async,
    require_cpu,
    require_multi_gpu,
    require_single_gpu,
    test_sync,
)
from accelerate.utils import patch_environment
class 	__UpperCAmelCase						(unittest.TestCase    ):







			'''simple docstring'''





			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										A__					:    Optional[int]														= inspect.getfile(accelerate.test_utils       )
										A__					:    Tuple														= os.path.sep.join(mod_file.split(os.path.sep       )[:-1] + ["""scripts""", """test_sync.py"""]       )





			@require_cpu
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										debug_launcher(test_sync.main      ,			num_processes=1       )





			@require_cpu
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										debug_launcher(test_sync.main       )





			@require_single_gpu
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										test_sync.main()





			@require_multi_gpu
			def 		lowerCamelCase				( self       ):







										'''simple docstring'''


										print(F'''Found {torch.cuda.device_count()} devices.'''       )
										A__					:    List[str]														= ["""torchrun""", F'''--nproc_per_node={torch.cuda.device_count()}''', self.test_file_path]
										with patch_environment(omp_num_threads=1       ):
																	execute_subprocess_async(snake_case_      ,			env=os.environ.copy()       )





