
import inspect
import unittest

import requests

from transformers import MgpstrConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import is_torch_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch
				from torch import nn

				from transformers import MgpstrForSceneTextRecognition


if is_vision_available():
				from PIL import Image

				from transformers import MgpstrProcessor






class 							SCREAMING_SNAKE_CASE__     :

							"""simple docstring"""






							def __init__(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_=False  ,						SCREAMING_SNAKE_CASE_=13  ,						SCREAMING_SNAKE_CASE_=(32, 128)  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=3  ,						SCREAMING_SNAKE_CASE_=27  ,						SCREAMING_SNAKE_CASE_=38  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=99  ,						SCREAMING_SNAKE_CASE_=32  ,						SCREAMING_SNAKE_CASE_=5  ,						SCREAMING_SNAKE_CASE_=4  ,						SCREAMING_SNAKE_CASE_=4.0  ,						SCREAMING_SNAKE_CASE_=257  ,						SCREAMING_SNAKE_CASE_=None  ,						)-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      parent
													__UpperCamelCase  	=      is_training
													__UpperCamelCase  	=      batch_size
													__UpperCamelCase  	=      image_size
													__UpperCamelCase  	=      patch_size
													__UpperCamelCase  	=      num_channels
													__UpperCamelCase  	=      max_token_length
													__UpperCamelCase  	=      num_character_labels
													__UpperCamelCase  	=      num_bpe_labels
													__UpperCamelCase  	=      num_wordpiece_labels
													__UpperCamelCase  	=      hidden_size
													__UpperCamelCase  	=      num_hidden_layers
													__UpperCamelCase  	=      num_attention_heads
													__UpperCamelCase  	=      mlp_ratio
													__UpperCamelCase  	=      patch_embeds_hidden_size
													__UpperCamelCase  	=      output_hidden_states



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase  	=      floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]      )
													__UpperCamelCase  	=      self.get_config()
													return config, pixel_values



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													return MgpstrConfig(
													    image_size=self.image_size  ,						patch_size=self.patch_size  ,						num_channels=self.num_channels  ,						max_token_length=self.max_token_length  ,						num_character_labels=self.num_character_labels  ,						num_bpe_labels=self.num_bpe_labels  ,						num_wordpiece_labels=self.num_wordpiece_labels  ,						hidden_size=self.hidden_size  ,						num_hidden_layers=self.num_hidden_layers  ,						num_attention_heads=self.num_attention_heads  ,						mlp_ratio=self.mlp_ratio  ,						output_hidden_states=self.output_hidden_states  ,						)



							def      A__		(	self  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )-> Dict:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrForSceneTextRecognition(SCREAMING_SNAKE_CASE_      )
													model.to(SCREAMING_SNAKE_CASE_      )
													model.eval()
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )
													self.parent.assertEqual(
													    generated_ids[0][0].shape  ,						(self.batch_size, self.max_token_length, self.num_character_labels)      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.prepare_config_and_inputs()
													__UpperCamelCase	,				__UpperCamelCase  	=      config_and_inputs
													__UpperCamelCase  	=      {'''pixel_values''': pixel_values}
													return config, inputs_dict






@require_torch
class 							SCREAMING_SNAKE_CASE__     (				SCREAMING_SNAKE_CASE_ ,		SCREAMING_SNAKE_CASE_ ,		unittest.TestCase     ):

							"""simple docstring"""






							_snake_case  		=	(MgpstrForSceneTextRecognition,) if is_torch_available() else ()
							_snake_case  		=	{'feature-extraction': MgpstrForSceneTextRecognition} if is_torch_available() else {}
							_snake_case  		=	False

							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False
							_snake_case  		=	False



							def      A__		(	self      )-> Tuple:





													'''simple docstring'''






													__UpperCamelCase  	=      MgpstrModelTester(self      )
													__UpperCamelCase  	=      ConfigTester(self  ,						config_class=SCREAMING_SNAKE_CASE_  ,						has_text_modality=SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Any:





													'''simple docstring'''






													self.config_tester.run_common_tests()



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_model(*SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not use inputs_embeds'''      )
							def      A__		(	self      )-> List[str]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> str:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertIsInstance(model.get_input_embeddings()  ,						(nn.Module)      )
																			__UpperCamelCase  	=      model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(SCREAMING_SNAKE_CASE_  ,						nn.Linear      )      )



							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			__UpperCamelCase  	=      inspect.signature(model.forward      )
																			# signature.parameters is an OrderedDict => so arg_names order is deterministic
																			__UpperCamelCase  	=      [*signature.parameters.keys()]

																			__UpperCamelCase  	=      ['''pixel_values''']
																			self.assertListEqual(arg_names[:1]  ,						SCREAMING_SNAKE_CASE_      )



							@unittest.skip(reason='''MgpstrModel does not support feedforward chunking'''      )
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													pass



							def      A__		(	self      )-> int:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			if not model_class.supports_gradient_checkpointing:
																									continue

																			__UpperCamelCase  	=      True
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			self.assertTrue(model.is_gradient_checkpointing      )



							def      A__		(	self      )-> str:





													'''simple docstring'''






													def check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      ):
																			__UpperCamelCase  	=      model_class(SCREAMING_SNAKE_CASE_      )
																			model.to(SCREAMING_SNAKE_CASE_      )
																			model.eval()

																			with torch.no_grad():
																									__UpperCamelCase  	=      model(**self._prepare_for_class(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )      )

																			__UpperCamelCase  	=      outputs.hidden_states

																			__UpperCamelCase  	=      getattr(
																			    self.model_tester  ,						'''expected_num_hidden_layers'''  ,						self.model_tester.num_hidden_layers + 1      )
																			self.assertEqual(len(SCREAMING_SNAKE_CASE_      )  ,						SCREAMING_SNAKE_CASE_      )

																			self.assertListEqual(
																			    list(hidden_states[0].shape[-2:]      )  ,						[self.model_tester.patch_embeds_hidden_size, self.model_tester.hidden_size]  ,						)

													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      True
																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			__UpperCamelCase  	=      True

																			check_hidden_states_output(SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_  ,						SCREAMING_SNAKE_CASE_      )



							def      A__		(	self      )-> Optional[int]:





													'''simple docstring'''






													__UpperCamelCase	,				__UpperCamelCase  	=      self.model_tester.prepare_config_and_inputs_for_common()

													__UpperCamelCase  	=      _config_zero_init(SCREAMING_SNAKE_CASE_      )
													for model_class in self.all_model_classes:
																			__UpperCamelCase  	=      model_class(config=SCREAMING_SNAKE_CASE_      )
																			for name, param in model.named_parameters():
																									if isinstance(SCREAMING_SNAKE_CASE_  ,						(nn.Linear, nn.Convad, nn.LayerNorm)      ):
																															if param.requires_grad:
																																					self.assertIn(
																																					    ((param.data.mean() * 1E9).round() / 1E9).item()  ,						[0.0, 1.0]  ,						msg=F"Parameter {name} of model {model_class} seems not properly initialized"  ,						)



							@unittest.skip(reason='''Retain_grad is tested in individual model tests'''      )
							def      A__		(	self      )-> List[Any]:





													'''simple docstring'''






													pass





def 						A_			(				)   ->     Dict:



						'''simple docstring'''

						__UpperCamelCase  	=      '''https://i.postimg.cc/ZKwLg2Gw/367-14.png'''
						__UpperCamelCase  	=      Image.open(requests.get(snake_case			,   stream=snake_case			).raw			).convert('''RGB'''			)
						return im






@require_vision
@require_torch
class 							SCREAMING_SNAKE_CASE__     (				unittest.TestCase     ):

							"""simple docstring"""






							@slow
							def      A__		(	self      )-> Optional[Any]:





													'''simple docstring'''






													__UpperCamelCase  	=      '''alibaba-damo/mgp-str-base'''
													__UpperCamelCase  	=      MgpstrForSceneTextRecognition.from_pretrained(SCREAMING_SNAKE_CASE_      ).to(SCREAMING_SNAKE_CASE_      )
													__UpperCamelCase  	=      MgpstrProcessor.from_pretrained(SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      prepare_img()
													__UpperCamelCase  	=      processor(images=SCREAMING_SNAKE_CASE_  ,						return_tensors='''pt'''      ).pixel_values.to(SCREAMING_SNAKE_CASE_      )

													# forward pass
													with torch.no_grad():
																			__UpperCamelCase  	=      model(SCREAMING_SNAKE_CASE_      )

													# verify the logits
													self.assertEqual(outputs.logits[0].shape  ,						torch.Size((1, 27, 38)      )      )

													__UpperCamelCase  	=      processor.batch_decode(outputs.logits      )
													__UpperCamelCase  	=      '''ticket'''

													self.assertEqual(out_strs['''generated_text'''][0]  ,						SCREAMING_SNAKE_CASE_      )

													__UpperCamelCase  	=      torch.tensor(
													    [[[-3_9.5_3_9_7, -4_4.4_0_2_4, -3_6.1_8_4_4], [-6_1.4_7_0_9, -6_3.8_6_3_9, -5_8.3_4_5_4], [-7_4.0_2_2_5, -6_8.5_4_9_4, -7_1.2_1_6_4]]]  ,						device=SCREAMING_SNAKE_CASE_  ,						)

													self.assertTrue(torch.allclose(outputs.logits[0][:, 1:4, 1:4]  ,						SCREAMING_SNAKE_CASE_  ,						atol=1E-4      )      )







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






