



import inspect
from typing import Callable, List, Optional, Set, Tuple, Union

import torch
from packaging import version
from safetensors.torch import storage_ptr, storage_size
from torch import nn

from .utils import logging


_lowerCamelCase         =	[nn.LayerNorm]

_lowerCamelCase         =	logging.get_logger(__name__)

_lowerCamelCase         =	version.parse(version.parse(torch.__version__).base_version)

_lowerCamelCase         =	parsed_torch_version_base >= version.parse("""2.0""")
_lowerCamelCase         =	parsed_torch_version_base >= version.parse("""1.12""")
_lowerCamelCase         =	parsed_torch_version_base >= version.parse("""1.11""")
_lowerCamelCase         =	parsed_torch_version_base < version.parse("""1.11""")






def 						_lowerCAmelCase    (					__lowerCamelCase :  int		,						__lowerCamelCase :  Any		,						__lowerCamelCase :  List[str]		,						__lowerCamelCase :  Union[str, Any]		,						self :  Dict  ):



 """simple docstring"""





 from torch import _softmax_backward_data

 if is_torch_less_than_1_11:
  return _softmax_backward_data(__lowerCamelCase		,						__lowerCamelCase		,						parent.dim		,						self  )
 else:
  return _softmax_backward_data(__lowerCamelCase		,						__lowerCamelCase		,						parent.dim		,						self.dtype  )






def 						_lowerCAmelCase    (					__lowerCamelCase :  str		,						__lowerCamelCase :  str		,						__lowerCamelCase :  Tuple = 0  ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE							:     Tuple							=						index.to(layer.weight.device  )
 __SCREAMING_SNAKE_CASE							:     Tuple							=						layer.weight.index_select(__lowerCamelCase		,						__lowerCamelCase  ).clone().detach()
 if layer.bias is not None:
  if dim == 1:
   __SCREAMING_SNAKE_CASE							:     List[Any]							=						layer.bias.clone().detach()
  else:
   __SCREAMING_SNAKE_CASE							:     Tuple							=						layer.bias[index].clone().detach()
 __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						list(layer.weight.size()  )
 __SCREAMING_SNAKE_CASE							:     int							=						len(__lowerCamelCase  )
 __SCREAMING_SNAKE_CASE							:     str							=						nn.Linear(new_size[1]		,						new_size[0]		,						bias=layer.bias is not None  ).to(layer.weight.device  )
 __SCREAMING_SNAKE_CASE							:     str							=						False
 new_layer.weight.copy_(W.contiguous()  )
 __SCREAMING_SNAKE_CASE							:     Tuple							=						True
 if layer.bias is not None:
  __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						False
  new_layer.bias.copy_(b.contiguous()  )
  __SCREAMING_SNAKE_CASE							:     Any							=						True
 return new_layer

class    _SCREAMING_SNAKE_CASE						(nn.Module			):





     def __init__(							self			:				Any  ,	UpperCamelCase			:				Union[str, Any]  ,	UpperCamelCase			:				Optional[Any]					)->int:
      super().__init__()
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						nf
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						nn.Parameter(torch.empty(_snake_case  ,	_snake_case					)					)
      __SCREAMING_SNAKE_CASE							:     List[Any]							=						nn.Parameter(torch.zeros(_snake_case					)					)
      nn.init.normal_(self.weight  ,	std=0.0_2					)






     def 						__snake_case     (							self			:				Tuple  ,	UpperCamelCase			:				Optional[Any]					)->Optional[int]:
      __SCREAMING_SNAKE_CASE							:     Dict							=						x.size()[:-1] + (self.nf,)
      __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						torch.addmm(self.bias  ,	x.view(-1  ,	x.size(-1					)					)  ,	self.weight					)
      __SCREAMING_SNAKE_CASE							:     List[str]							=						x.view(_snake_case					)
      return x






def 						_lowerCAmelCase    (					__lowerCamelCase :  Optional[int]		,						__lowerCamelCase :  Dict		,						__lowerCamelCase :  Tuple = 1  ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE							:     List[str]							=						index.to(layer.weight.device  )
 __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						layer.weight.index_select(__lowerCamelCase		,						__lowerCamelCase  ).clone().detach()
 if dim == 0:
  __SCREAMING_SNAKE_CASE							:     Tuple							=						layer.bias.clone().detach()
 else:
  __SCREAMING_SNAKE_CASE							:     str							=						layer.bias[index].clone().detach()
 __SCREAMING_SNAKE_CASE							:     str							=						list(layer.weight.size()  )
 __SCREAMING_SNAKE_CASE							:     List[str]							=						len(__lowerCamelCase  )
 __SCREAMING_SNAKE_CASE							:     List[Any]							=						ConvaD(new_size[1]		,						new_size[0]  ).to(layer.weight.device  )
 __SCREAMING_SNAKE_CASE							:     Tuple							=						False
 new_layer.weight.copy_(W.contiguous()  )
 __SCREAMING_SNAKE_CASE							:     Optional[Any]							=						True
 __SCREAMING_SNAKE_CASE							:     Any							=						False
 new_layer.bias.copy_(b.contiguous()  )
 __SCREAMING_SNAKE_CASE							:     Union[str, Any]							=						True
 return new_layer






def 						_lowerCAmelCase    (					__lowerCamelCase :  str		,						__lowerCamelCase :  Any		,						__lowerCamelCase :  Optional[int] = None  ):



 """simple docstring"""





 if isinstance(__lowerCamelCase		,						nn.Linear  ):
  return prune_linear_layer(__lowerCamelCase		,						__lowerCamelCase		,						dim=0 if dim is None else dim  )
 elif isinstance(__lowerCamelCase		,						__lowerCamelCase  ):
  return prune_convad_layer(__lowerCamelCase		,						__lowerCamelCase		,						dim=1 if dim is None else dim  )
 else:
  raise ValueError(F"""Can't prune layer of class {layer.__class__}"""  )






def 						_lowerCAmelCase    (					__lowerCamelCase :  List[str]		,						__lowerCamelCase :  int		,						__lowerCamelCase :  Union[str, Any]		,						*__lowerCamelCase :  Union[str, Any]  ):



 """simple docstring"""





 assert len(__lowerCamelCase  ) > 0, F"""{input_tensors} has to be a tuple/list of tensors"""

 # inspect.signature exist since python 3.5 and is a python method -> no problem with backward compatibility
 __SCREAMING_SNAKE_CASE							:     str							=						len(inspect.signature(__lowerCamelCase  ).parameters  )
 if num_args_in_forward_chunk_fn != len(__lowerCamelCase  ):
  raise ValueError(
      F"""forward_chunk_fn expects {num_args_in_forward_chunk_fn} arguments, but only {len(__lowerCamelCase  )} input """
      "tensors are given"  )

 if chunk_size > 0:
  __SCREAMING_SNAKE_CASE							:     Optional[int]							=						input_tensors[0].shape[chunk_dim]
  for input_tensor in input_tensors:
   if input_tensor.shape[chunk_dim] != tensor_shape:
    raise ValueError(
        F"""All input tenors have to be of the same shape: {tensor_shape}, """
        F"""found shape {input_tensor.shape[chunk_dim]}"""  )

  if input_tensors[0].shape[chunk_dim] % chunk_size != 0:
   raise ValueError(
       F"""The dimension to be chunked {input_tensors[0].shape[chunk_dim]} has to be a multiple of the chunk """
       F"""size {chunk_size}"""  )

  __SCREAMING_SNAKE_CASE							:     Any							=						input_tensors[0].shape[chunk_dim] // chunk_size

  # chunk input tensor into tuples
  __SCREAMING_SNAKE_CASE							:     int							=						tuple(input_tensor.chunk(__lowerCamelCase		,						dim=__lowerCamelCase  ) for input_tensor in input_tensors  )
  # apply forward fn to every tuple
  __SCREAMING_SNAKE_CASE							:     List[str]							=						tuple(forward_fn(*__lowerCamelCase  ) for input_tensors_chunk in zip(*__lowerCamelCase  )  )
  # concatenate output at same dimension
  return torch.cat(__lowerCamelCase		,						dim=__lowerCamelCase  )

 return forward_fn(*__lowerCamelCase  )






def 						_lowerCAmelCase    (					__lowerCamelCase :  Dict		,						__lowerCamelCase :  str		,						__lowerCamelCase :  Union[str, Any]		,						__lowerCamelCase :  int  ):



 """simple docstring"""





 __SCREAMING_SNAKE_CASE							:     List[Any]							=						torch.ones(__lowerCamelCase		,						__lowerCamelCase  )
 __SCREAMING_SNAKE_CASE							:     Optional[int]							=						set(__lowerCamelCase  ) - already_pruned_heads  # Convert to set and remove already pruned heads
 for head in heads:
  # Compute how many pruned heads are before the head and move the index accordingly
  __SCREAMING_SNAKE_CASE							:     Any							=						head - sum(1 if h < head else 0 for h in already_pruned_heads  )
  __SCREAMING_SNAKE_CASE							:     List[Any]							=						0
 __SCREAMING_SNAKE_CASE							:     str							=						mask.view(-1  ).contiguous().eq(1  )
 __SCREAMING_SNAKE_CASE							:     torch.LongTensor							=						torch.arange(len(__lowerCamelCase  )  )[mask].long()
 return heads, index






def 						_lowerCAmelCase    (					*__lowerCamelCase :  List[str]		,						__lowerCamelCase :  str = None  ):



 """simple docstring"""





 return torch.meshgrid(*__lowerCamelCase		,						indexing=__lowerCamelCase  )






def 						_lowerCAmelCase    (					__lowerCamelCase :  str  ):



 """simple docstring"""





 return tensor.device, storage_ptr(__lowerCamelCase  ), storage_size(__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)






