import functools
import math

import flax.linen as nn
import jax
import jax.numpy as jnp

def 	__lowerCamelCase							(				__a    : List[Any]      ,							__a    : List[Any]      ,							__a    : int      ,							__a    : Optional[int]      ,							__a    : int = 4_096		)      ->       Optional[Any]:
	_lowercase   ,  _lowercase   ,  _lowercase   =key.shape[-3:]
	_lowercase   =value.shape[-1]
	_lowercase   =min(__a      ,							__a		)
	_lowercase   =query / jnp.sqrt(__a		)

	@functools.partial(jax.checkpoint      ,							prevent_cse=__a		)
	def summarize_chunk(__a    : Dict      ,							__a    : Optional[Any]      ,							__a    : Optional[int]		):
		_lowercase   =jnp.einsum("...qhd,...khd->...qhk"      ,							__a      ,							__a      ,							precision=__a		)

		_lowercase   =jnp.max(__a      ,							axis=-1      ,							keepdims=__a		)
		_lowercase   =jax.lax.stop_gradient(__a		)
		_lowercase   =jnp.exp(attn_weights - max_score		)

		_lowercase   =jnp.einsum("...vhf,...qhv->...qhf"      ,							__a      ,							__a      ,							precision=__a		)
		_lowercase   =jnp.einsum("...qhk->...qh"      ,							__a		)

		return (exp_values, exp_weights.sum(axis=-1		), max_score)

	def chunk_scanner(__a    : str		):
		# julienne key array
		_lowercase   =jax.lax.dynamic_slice(
		    operand=__a      ,							start_indices=[0] * (key.ndim - 3) + [chunk_idx, 0, 0]      ,							slice_sizes=list(key.shape[:-3]		) + [key_chunk_size, num_heads, k_features]      ,							)

		# julienne value array
		_lowercase   =jax.lax.dynamic_slice(
		    operand=__a      ,							start_indices=[0] * (value.ndim - 3) + [chunk_idx, 0, 0]      ,							slice_sizes=list(value.shape[:-3]		) + [key_chunk_size, num_heads, v_features]      ,							)

		return summarize_chunk(__a      ,							__a      ,							__a		)

	_lowercase   ,  _lowercase   ,  _lowercase   =jax.lax.map(f=__a      ,							xs=jnp.arange(0      ,							__a      ,							__a		)		)

	_lowercase   =jnp.max(__a      ,							axis=0      ,							keepdims=__a		)
	_lowercase   =jnp.exp(chunk_max - global_max		)

	chunk_values *= jnp.expand_dims(__a      ,							axis=-1		)
	chunk_weights *= max_diffs

	_lowercase   =chunk_values.sum(axis=0		)
	_lowercase   =jnp.expand_dims(__a      ,							-1		).sum(axis=0		)

	return all_values / all_weights

def 	__lowerCamelCase							(				__a    : Union[str, Any]      ,							__a    : Dict      ,							__a    : int      ,							__a    : Any=jax.lax.Precision.HIGHEST      ,							__a    : int = 1_024      ,							__a    : int = 4_096		)      ->       Any:
	_lowercase   ,  _lowercase   ,  _lowercase   =query.shape[-3:]

	def chunk_scanner(__a    : List[Any]      ,							__a    : Union[str, Any]		):
		# julienne query array
		_lowercase   =jax.lax.dynamic_slice(
		    operand=__a      ,							start_indices=([0] * (query.ndim - 3)) + [chunk_idx, 0, 0]      ,							slice_sizes=list(query.shape[:-3]		) + [min(__a      ,							__a		), num_heads, q_features]      ,							)

		return (
		    chunk_idx + query_chunk_size,  # unused ignore it
		    _query_chunk_attention(
		        query=__a      ,							key=__a      ,							value=__a      ,							precision=__a      ,							key_chunk_size=__a		),
		)

	_lowercase   ,  _lowercase   =jax.lax.scan(
	    f=__a      ,							init=0      ,							xs=__a      ,							length=math.ceil(num_q / query_chunk_size		)		)

	return jnp.concatenate(__a      ,							axis=-3		)  # fuse the chunked result back
class 	_a  (							nn.Module					):



	"""simple docstring"""



	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					8
	__SCREAMING_SNAKE_CASE              =					64
	__SCREAMING_SNAKE_CASE              =					0.0
	__SCREAMING_SNAKE_CASE              =					False
	__SCREAMING_SNAKE_CASE              =					jnp.floataa


	def __lowerCAmelCase      (   self       ):
		_lowercase   =self.dim_head * self.heads
		_lowercase   =self.dim_head**-0.5

		# Weights were exported with old names {to_q, to_k, to_v, to_out}
		_lowercase   =nn.Dense(lowerCAmelCase_       ,  use_bias=lowerCAmelCase_       ,  dtype=self.dtype       ,  name="to_q"       )
		_lowercase   =nn.Dense(lowerCAmelCase_       ,  use_bias=lowerCAmelCase_       ,  dtype=self.dtype       ,  name="to_k"       )
		_lowercase   =nn.Dense(lowerCAmelCase_       ,  use_bias=lowerCAmelCase_       ,  dtype=self.dtype       ,  name="to_v"       )

		_lowercase   =nn.Dense(self.query_dim       ,  dtype=self.dtype       ,  name="to_out_0"       )
		_lowercase   =nn.Dropout(rate=self.dropout       )


	def __lowerCAmelCase      (   self       ,  lowerCAmelCase_       ):
		_lowercase   ,  _lowercase   ,  _lowercase   =tensor.shape
		_lowercase   =self.heads
		_lowercase   =tensor.reshape(lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  dim // head_size       )
		_lowercase   =jnp.transpose(lowerCAmelCase_       ,  (0, 2, 1, 3)       )
		_lowercase   =tensor.reshape(batch_size * head_size       ,  lowerCAmelCase_       ,  dim // head_size       )
		return tensor


	def __lowerCAmelCase      (   self       ,  lowerCAmelCase_       ):
		_lowercase   ,  _lowercase   ,  _lowercase   =tensor.shape
		_lowercase   =self.heads
		_lowercase   =tensor.reshape(batch_size // head_size       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       )
		_lowercase   =jnp.transpose(lowerCAmelCase_       ,  (0, 2, 1, 3)       )
		_lowercase   =tensor.reshape(batch_size // head_size       ,  lowerCAmelCase_       ,  dim * head_size       )
		return tensor


	def __call__(   self       ,  lowerCAmelCase_       ,  lowerCAmelCase_=None       ,  lowerCAmelCase_=True       ):
		_lowercase   =hidden_states if context is None else context

		_lowercase   =self.query(lowerCAmelCase_       )
		_lowercase   =self.key(lowerCAmelCase_       )
		_lowercase   =self.value(lowerCAmelCase_       )

		_lowercase   =self.reshape_heads_to_batch_dim(lowerCAmelCase_       )
		_lowercase   =self.reshape_heads_to_batch_dim(lowerCAmelCase_       )
		_lowercase   =self.reshape_heads_to_batch_dim(lowerCAmelCase_       )

		if self.use_memory_efficient_attention:
			_lowercase   =query_states.transpose(1       ,  0       ,  2       )
			_lowercase   =key_states.transpose(1       ,  0       ,  2       )
			_lowercase   =value_states.transpose(1       ,  0       ,  2       )

			# this if statement create a chunk size for each layer of the unet
			# the chunk size is equal to the query_length dimension of the deepest layer of the unet

			_lowercase   =query_states.shape[-3]
			if flatten_latent_dim % 64 == 0:
				_lowercase   =int(flatten_latent_dim / 64       )
			elif flatten_latent_dim % 16 == 0:
				_lowercase   =int(flatten_latent_dim / 16       )
			elif flatten_latent_dim % 4 == 0:
				_lowercase   =int(flatten_latent_dim / 4       )
			else:
				_lowercase   =int(lowerCAmelCase_       )

			_lowercase   =jax_memory_efficient_attention(
			    lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  query_chunk_size=lowerCAmelCase_       ,  key_chunk_size=4096 * 4       )

			_lowercase   =hidden_states.transpose(1       ,  0       ,  2       )
		else:
			# compute attentions
			_lowercase   =jnp.einsum("b i d, b j d->b i j"       ,  lowerCAmelCase_       ,  lowerCAmelCase_       )
			_lowercase   =attention_scores * self.scale
			_lowercase   =nn.softmax(lowerCAmelCase_       ,  axis=2       )

			# attend to values
			_lowercase   =jnp.einsum("b i j, b j d -> b i d"       ,  lowerCAmelCase_       ,  lowerCAmelCase_       )

		_lowercase   =self.reshape_batch_dim_to_heads(lowerCAmelCase_       )
		_lowercase   =self.proj_attn(lowerCAmelCase_       )
		return self.dropout_layer(lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )

class 	_a  (							nn.Module					):



	"""simple docstring"""



	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					0.0
	__SCREAMING_SNAKE_CASE              =					False
	__SCREAMING_SNAKE_CASE              =					jnp.floataa
	__SCREAMING_SNAKE_CASE              =					False


	def __lowerCAmelCase      (   self       ):
		# self attention (or cross_attention if only_cross_attention is True)
		_lowercase   =FlaxAttention(
		    self.dim       ,  self.n_heads       ,  self.d_head       ,  self.dropout       ,  self.use_memory_efficient_attention       ,  dtype=self.dtype       )
		# cross attention
		_lowercase   =FlaxAttention(
		    self.dim       ,  self.n_heads       ,  self.d_head       ,  self.dropout       ,  self.use_memory_efficient_attention       ,  dtype=self.dtype       )
		_lowercase   =FlaxFeedForward(dim=self.dim       ,  dropout=self.dropout       ,  dtype=self.dtype       )
		_lowercase   =nn.LayerNorm(epsilon=1e-5       ,  dtype=self.dtype       )
		_lowercase   =nn.LayerNorm(epsilon=1e-5       ,  dtype=self.dtype       )
		_lowercase   =nn.LayerNorm(epsilon=1e-5       ,  dtype=self.dtype       )
		_lowercase   =nn.Dropout(rate=self.dropout       )


	def __call__(   self       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_=True       ):
		# self attention
		_lowercase   =hidden_states
		if self.only_cross_attention:
			_lowercase   =self.attna(self.norma(lowerCAmelCase_       )       ,  lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )
		else:
			_lowercase   =self.attna(self.norma(lowerCAmelCase_       )       ,  deterministic=lowerCAmelCase_       )
		_lowercase   =hidden_states + residual

		# cross attention
		_lowercase   =hidden_states
		_lowercase   =self.attna(self.norma(lowerCAmelCase_       )       ,  lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )
		_lowercase   =hidden_states + residual

		# feed forward
		_lowercase   =hidden_states
		_lowercase   =self.ff(self.norma(lowerCAmelCase_       )       ,  deterministic=lowerCAmelCase_       )
		_lowercase   =hidden_states + residual

		return self.dropout_layer(lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )

class 	_a  (							nn.Module					):



	"""simple docstring"""



	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					1
	__SCREAMING_SNAKE_CASE              =					0.0
	__SCREAMING_SNAKE_CASE              =					False
	__SCREAMING_SNAKE_CASE              =					False
	__SCREAMING_SNAKE_CASE              =					jnp.floataa
	__SCREAMING_SNAKE_CASE              =					False


	def __lowerCAmelCase      (   self       ):
		_lowercase   =nn.GroupNorm(num_groups=32       ,  epsilon=1e-5       )

		_lowercase   =self.n_heads * self.d_head
		if self.use_linear_projection:
			_lowercase   =nn.Dense(lowerCAmelCase_       ,  dtype=self.dtype       )
		else:
			_lowercase   =nn.Conv(
			    lowerCAmelCase_       ,  kernel_size=(1, 1)       ,  strides=(1, 1)       ,  padding="VALID"       ,  dtype=self.dtype       ,  )

		_lowercase   =[
		    FlaxBasicTransformerBlock(
		        lowerCAmelCase_       ,  self.n_heads       ,  self.d_head       ,  dropout=self.dropout       ,  only_cross_attention=self.only_cross_attention       ,  dtype=self.dtype       ,  use_memory_efficient_attention=self.use_memory_efficient_attention       ,  )
		    for _ in range(self.depth       )
		]

		if self.use_linear_projection:
			_lowercase   =nn.Dense(lowerCAmelCase_       ,  dtype=self.dtype       )
		else:
			_lowercase   =nn.Conv(
			    lowerCAmelCase_       ,  kernel_size=(1, 1)       ,  strides=(1, 1)       ,  padding="VALID"       ,  dtype=self.dtype       ,  )

		_lowercase   =nn.Dropout(rate=self.dropout       )


	def __call__(   self       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_=True       ):
		_lowercase   ,  _lowercase   ,  _lowercase   ,  _lowercase   =hidden_states.shape
		_lowercase   =hidden_states
		_lowercase   =self.norm(lowerCAmelCase_       )
		if self.use_linear_projection:
			_lowercase   =hidden_states.reshape(lowerCAmelCase_       ,  height * width       ,  lowerCAmelCase_       )
			_lowercase   =self.proj_in(lowerCAmelCase_       )
		else:
			_lowercase   =self.proj_in(lowerCAmelCase_       )
			_lowercase   =hidden_states.reshape(lowerCAmelCase_       ,  height * width       ,  lowerCAmelCase_       )

		for transformer_block in self.transformer_blocks:
			_lowercase   =transformer_block(lowerCAmelCase_       ,  lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )

		if self.use_linear_projection:
			_lowercase   =self.proj_out(lowerCAmelCase_       )
			_lowercase   =hidden_states.reshape(lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       )
		else:
			_lowercase   =hidden_states.reshape(lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       ,  lowerCAmelCase_       )
			_lowercase   =self.proj_out(lowerCAmelCase_       )

		_lowercase   =hidden_states + residual
		return self.dropout_layer(lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )

class 	_a  (							nn.Module					):



	"""simple docstring"""



	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					0.0
	__SCREAMING_SNAKE_CASE              =					jnp.floataa


	def __lowerCAmelCase      (   self       ):
		# The second linear layer needs to be called
		# net_2 for now to match the index of the Sequential layer
		_lowercase   =FlaxGEGLU(self.dim       ,  self.dropout       ,  self.dtype       )
		_lowercase   =nn.Dense(self.dim       ,  dtype=self.dtype       )


	def __call__(   self       ,  lowerCAmelCase_       ,  lowerCAmelCase_=True       ):
		_lowercase   =self.net_a(lowerCAmelCase_       ,  deterministic=lowerCAmelCase_       )
		_lowercase   =self.net_a(lowerCAmelCase_       )
		return hidden_states

class 	_a  (							nn.Module					):



	"""simple docstring"""



	__SCREAMING_SNAKE_CASE              =					42
	__SCREAMING_SNAKE_CASE              =					0.0
	__SCREAMING_SNAKE_CASE              =					jnp.floataa


	def __lowerCAmelCase      (   self       ):
		_lowercase   =self.dim * 4
		_lowercase   =nn.Dense(inner_dim * 2       ,  dtype=self.dtype       )
		_lowercase   =nn.Dropout(rate=self.dropout       )


	def __call__(   self       ,  lowerCAmelCase_       ,  lowerCAmelCase_=True       ):
		_lowercase   =self.proj(lowerCAmelCase_       )
		_lowercase   ,  _lowercase   =jnp.split(lowerCAmelCase_       ,  2       ,  axis=2       )
		return self.dropout_layer(hidden_linear * nn.gelu(lowerCAmelCase_       )       ,  deterministic=lowerCAmelCase_       )







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


lowerCAmelCase__      				=			logging.get_logger(__name__)

# General docstring
lowerCAmelCase__      				=			"ResNetConfig"

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

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

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



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


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


							def     _snake_case				(      self     ,      _snake_case)				->					tf.Tensor:
								# Pad to match that done in the PyTorch Conv2D model
								UpperCAmelCase_		:   List[str]													=       (self.pad_value, self.pad_value)
								UpperCAmelCase_		:   Dict													=       tf.pad(_snake_case     ,      [(0, 0), height_pad, width_pad, (0, 0)])
								UpperCAmelCase_		:   str													=       self.conv(_snake_case)
								return hidden_state





							def     _snake_case				(      self     ,      _snake_case     ,      _snake_case = False)				->					tf.Tensor:
								UpperCAmelCase_		:   int													=       self.convolution(_snake_case)
								UpperCAmelCase_		:   Union[str, Any]													=       self.normalization(_snake_case     ,      training=_snake_case)
								UpperCAmelCase_		:   Any													=       self.activation(_snake_case)
								return hidden_state



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


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





							def     _snake_case				(      self     ,      _snake_case     ,      _snake_case = False)				->					tf.Tensor:
								UpperCAmelCase_						,     UpperCAmelCase_						,     UpperCAmelCase_						,     UpperCAmelCase_		:   str													=       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_		:   Any													=       pixel_values
								UpperCAmelCase_		:   int													=       self.embedder(_snake_case)
								UpperCAmelCase_		:   Tuple													=       tf.pad(_snake_case     ,      [[0, 0], [1, 1], [1, 1], [0, 0]])
								UpperCAmelCase_		:   Any													=       self.pooler(_snake_case)
								return hidden_state



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


							def __init__(      self     ,      _snake_case     ,      _snake_case = 2     ,      **_snake_case)				->					None:
								super().__init__(**_snake_case)
								UpperCAmelCase_		:   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
								UpperCAmelCase_		:   List[str]													=       tf.keras.layers.BatchNormalization(epsilon=1e-5     ,      momentum=0.9     ,      name='normalization')





							def     _snake_case				(      self     ,      _snake_case     ,      _snake_case = False)				->					tf.Tensor:
								UpperCAmelCase_		:   Dict													=       x
								UpperCAmelCase_		:   List[str]													=       self.convolution(_snake_case)
								UpperCAmelCase_		:   Optional[int]													=       self.normalization(_snake_case     ,      training=_snake_case)
								return hidden_state



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


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





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



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


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





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



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


							def __init__(      self     ,      _snake_case     ,      _snake_case     ,      _snake_case     ,      _snake_case = 2     ,      _snake_case = 2     ,      **_snake_case)				->					None:
								super().__init__(**_snake_case)

								UpperCAmelCase_		:   Dict													=       TFResNetBottleNeckLayer if config.layer_type == 'bottleneck' else TFResNetBasicLayer

								UpperCAmelCase_		:   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)
								]
								UpperCAmelCase_		:   Optional[Any]													=       layers





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



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


							def __init__(      self     ,      _snake_case     ,      **_snake_case)				->					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_		:   Optional[int]													=       [
								    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     _snake_case				(      self     ,      _snake_case     ,      _snake_case = False     ,      _snake_case = True     ,      _snake_case = False     ,      )				->					TFBaseModelOutputWithNoAttention:
								UpperCAmelCase_		:   Optional[Any]													=       () if output_hidden_states else None

								for stage_module in self.stages:
									if output_hidden_states:
										UpperCAmelCase_		:   Optional[Any]													=       hidden_states + (hidden_state,)

									UpperCAmelCase_		:   List[Any]													=       stage_module(_snake_case     ,      training=_snake_case)

								if output_hidden_states:
									UpperCAmelCase_		:   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        lowercase    (	a_			):
							_lowerCamelCase		:   Optional[int]= ResNetConfig
							_lowerCamelCase		:   str= "resnet"
							_lowerCamelCase		:   Optional[int]= "pixel_values"


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


lowerCAmelCase__      				=			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"


lowerCAmelCase__      				=			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        lowercase    (	tf.keras.layers.Layer			):
							_lowerCamelCase		:   Any= ResNetConfig


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





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

								UpperCAmelCase_		:   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_		:   Dict													=       tf.transpose(_snake_case     ,      (0, 3, 1, 2))
								UpperCAmelCase_		:   Any													=       ()
								for hidden_state in encoder_outputs[1:]:
									UpperCAmelCase_		:   str													=       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_		:   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.",       a_,       )
class        lowercase    (	a_			):


							def __init__(      self     ,      _snake_case     ,      **_snake_case)				->					None:
								super().__init__(_snake_case     ,      **_snake_case)
								UpperCAmelCase_		:   str													=       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     _snake_case				(      self     ,      _snake_case     ,      _snake_case = None     ,      _snake_case = None     ,      _snake_case = 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_		:   Tuple													=       return_dict if return_dict is not None else self.config.use_return_dict

								UpperCAmelCase_		:   str													=       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        lowercase    (	a_,       a_			):


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

								UpperCAmelCase_		:   List[Any]													=       self.resnet(
								    _snake_case     ,      output_hidden_states=_snake_case     ,      return_dict=_snake_case     ,      training=_snake_case)

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

								UpperCAmelCase_		:   Union[str, Any]													=       self.classifier(_snake_case)

								UpperCAmelCase_		:   Optional[int]													=       None if labels is None else self.hf_compute_loss(_snake_case     ,      _snake_case)

								if not return_dict:
									UpperCAmelCase_		:   int													=       (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)






