






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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase = 3 ,					UpperCAmelCase = 1 ,					UpperCAmelCase = "relu" ,					**UpperCAmelCase					):
							"""simple docstring"""







							super().__init__(**lowercase_					)
							_UpperCAmelCase             =    kernel_size // 2
							_UpperCAmelCase             =    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
							_UpperCAmelCase             =    tf.keras.layers.BatchNormalization(epsilon=1e-5 ,					momentum=0.9 ,					name='normalization'					)
							_UpperCAmelCase             =    ACTaFN[activation] if activation is not None else tf.keras.layers.Activation('linear'					)

	def  UpperCamelCase					(							self ,					UpperCAmelCase					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







							_UpperCAmelCase             =    self.convolution(lowercase_					)
							_UpperCAmelCase             =    self.normalization(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.activation(lowercase_					)
							return hidden_state





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					**UpperCAmelCase					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







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





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase = 2 ,					**UpperCAmelCase					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







							_UpperCAmelCase             =    x
							_UpperCAmelCase             =    self.convolution(lowercase_					)
							_UpperCAmelCase             =    self.normalization(lowercase_ ,					training=lowercase_					)
							return hidden_state





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase = 1 ,					UpperCAmelCase = "relu" ,					**UpperCAmelCase					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







							_UpperCAmelCase             =    hidden_state
							_UpperCAmelCase             =    self.conva(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.conva(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.shortcut(lowercase_ ,					training=lowercase_					)
							hidden_state += residual
							_UpperCAmelCase             =    self.activation(lowercase_					)
							return hidden_state





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase = 1 ,					UpperCAmelCase = "relu" ,					UpperCAmelCase = 4 ,					**UpperCAmelCase ,					):
							"""simple docstring"""







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

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







							_UpperCAmelCase             =    hidden_state
							_UpperCAmelCase             =    self.conva(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.conva(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.conva(lowercase_ ,					training=lowercase_					)
							_UpperCAmelCase             =    self.shortcut(lowercase_ ,					training=lowercase_					)
							hidden_state += residual
							_UpperCAmelCase             =    self.activation(lowercase_					)
							return hidden_state





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase ,					UpperCAmelCase = 2 ,					UpperCAmelCase = 2 ,					**UpperCAmelCase					):
							"""simple docstring"""







							super().__init__(**lowercase_					)

							_UpperCAmelCase             =    TFResNetBottleNeckLayer if config.layer_type == '''bottleneck''' else TFResNetBasicLayer

							_UpperCAmelCase             =    [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					)
							]
							_UpperCAmelCase             =    layers

	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = False					):
							"""simple docstring"""







							for layer in self.stage_layers:
													_UpperCAmelCase             =    layer(lowercase_ ,					training=lowercase_					)
							return hidden_state





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





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					**UpperCAmelCase					):
							"""simple docstring"""







							super().__init__(**lowercase_					)
							# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
							_UpperCAmelCase             =    [
							    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 ,					UpperCAmelCase ,					UpperCAmelCase = False ,					UpperCAmelCase = True ,					UpperCAmelCase = False ,					):
							"""simple docstring"""







							_UpperCAmelCase             =    () if output_hidden_states else None

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

													_UpperCAmelCase             =    stage_module(lowercase_ ,					training=lowercase_					)

							if output_hidden_states:
													_UpperCAmelCase             =    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 __lowerCamelCase				(   __UpperCAmelCase):





	"""simple docstring"""






	UpperCamelCase__			=   ResNetConfig
	UpperCamelCase__			=   "resnet"
	UpperCamelCase__			=   "pixel_values"

	@property
	def  UpperCamelCase					(							self					):
							"""simple docstring"""







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





	"""simple docstring"""






	UpperCamelCase__			=   ResNetConfig

	def __init__(							self ,					UpperCAmelCase ,					**UpperCAmelCase					):
							"""simple docstring"""







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

	@unpack_inputs
	def  UpperCamelCase					(							self ,					UpperCAmelCase ,					UpperCAmelCase = None ,					UpperCAmelCase = None ,					UpperCAmelCase = False ,					):
							"""simple docstring"""







							_UpperCAmelCase             =    (
							    output_hidden_states if output_hidden_states is not None else self.config.output_hidden_states
							)
							_UpperCAmelCase             =    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             =    tf.transpose(lowercase_ ,					perm=[0, 2, 3, 1]					)
							_UpperCAmelCase             =    self.embedder(lowercase_ ,					training=lowercase_					)

							_UpperCAmelCase             =    self.encoder(
							    lowercase_ ,					output_hidden_states=lowercase_ ,					return_dict=lowercase_ ,					training=lowercase_					)

							_UpperCAmelCase             =    encoder_outputs[0]

							_UpperCAmelCase             =    self.pooler(lowercase_					)

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

							_UpperCAmelCase             =    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."  , __UpperCAmelCase  , )
class __lowerCamelCase				(   __UpperCAmelCase):





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					**UpperCAmelCase					):
							"""simple docstring"""







							super().__init__(lowercase_ ,					**lowercase_					)
							_UpperCAmelCase             =    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 ,					UpperCAmelCase ,					UpperCAmelCase = None ,					UpperCAmelCase = None ,					UpperCAmelCase = False ,					):
							"""simple docstring"""







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

							_UpperCAmelCase             =    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    "  , __UpperCAmelCase  , )
class __lowerCamelCase				(   __UpperCAmelCase  , __UpperCAmelCase):





	"""simple docstring"""






	def __init__(							self ,					UpperCAmelCase ,					**UpperCAmelCase					):
							"""simple docstring"""







							super().__init__(lowercase_ ,					**lowercase_					)
							_UpperCAmelCase             =    config.num_labels
							_UpperCAmelCase             =    TFResNetMainLayer(lowercase_ ,					name='resnet'					)
							# classification head
							_UpperCAmelCase             =    (
							    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 ,					UpperCAmelCase					):
							"""simple docstring"""







							_UpperCAmelCase             =    tf.keras.layers.Flatten()(lowercase_					)
							_UpperCAmelCase             =    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 ,					UpperCAmelCase = None ,					UpperCAmelCase = None ,					UpperCAmelCase = None ,					UpperCAmelCase = None ,					UpperCAmelCase = False ,					):
							"""simple docstring"""







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

							_UpperCAmelCase             =    self.resnet(
							    lowercase_ ,					output_hidden_states=lowercase_ ,					return_dict=lowercase_ ,					training=lowercase_					)

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

							_UpperCAmelCase             =    self.classifier(lowercase_					)

							_UpperCAmelCase             =    None if labels is None else self.hf_compute_loss(lowercase_ ,					lowercase_					)

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

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








from itertools import combinations_with_replacement


def __A					(   __lowerCAmelCase = 100			)->						int:





						"""simple docstring"""



						_UpperCAmelCase             =    [*list(range(1				,	21			)			), 25]
						_UpperCAmelCase             =    [2 * x for x in range(1				,	21			)] + [50]
						_UpperCAmelCase             =    [3 * x for x in range(1				,	21			)]
						_UpperCAmelCase             =    singles + doubles + triples + [0]

						_UpperCAmelCase             =    0
						_UpperCAmelCase             =    42
						_UpperCAmelCase             =    42
						_UpperCAmelCase             =    42
						_UpperCAmelCase             =    42

						for double in doubles:
												for throwa, throwa in combinations_with_replacement(__lowerCAmelCase				,	2			):
																		_UpperCAmelCase             =    double + throwa + throwa
																		if checkout_total < limit:
																								num_checkouts += 1

						return num_checkouts


if __name__ == "__main__":
		print(F'''{solution() = }''')
