

import argparse
import json
from pathlib import Path

import requests
import torch
from huggingface_hub import cached_download, hf_hub_url
from PIL import Image

from transformers import DeformableDetrConfig, DeformableDetrForObjectDetection, DeformableDetrImageProcessor
from transformers.utils import logging


logging.set_verbosity_info()
SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     Optional[int]       )      ->				str:
				if "backbone.0.body" in orig_key:
								_UpperCAmelCase				:						Any       						=			orig_key.replace("backbone.0.body"     ,					"backbone.conv_encoder.model"       )
				if "transformer" in orig_key:
								_UpperCAmelCase				:						Union[str, Any]       						=			orig_key.replace("transformer."     ,					""       )
				if "norm1" in orig_key:
								if "encoder" in orig_key:
												_UpperCAmelCase				:						int       						=			orig_key.replace("norm1"     ,					"self_attn_layer_norm"       )
								else:
												_UpperCAmelCase				:						Any       						=			orig_key.replace("norm1"     ,					"encoder_attn_layer_norm"       )
				if "norm2" in orig_key:
								if "encoder" in orig_key:
												_UpperCAmelCase				:						Dict       						=			orig_key.replace("norm2"     ,					"final_layer_norm"       )
								else:
												_UpperCAmelCase				:						Dict       						=			orig_key.replace("norm2"     ,					"self_attn_layer_norm"       )
				if "norm3" in orig_key:
								_UpperCAmelCase				:						Any       						=			orig_key.replace("norm3"     ,					"final_layer_norm"       )
				if "linear1" in orig_key:
								_UpperCAmelCase				:						str       						=			orig_key.replace("linear1"     ,					"fc1"       )
				if "linear2" in orig_key:
								_UpperCAmelCase				:						Any       						=			orig_key.replace("linear2"     ,					"fc2"       )
				if "query_embed" in orig_key:
								_UpperCAmelCase				:						Tuple       						=			orig_key.replace("query_embed"     ,					"query_position_embeddings"       )
				if "cross_attn" in orig_key:
								_UpperCAmelCase				:						List[Any]       						=			orig_key.replace("cross_attn"     ,					"encoder_attn"       )

				return orig_key

def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     str       )      ->				Optional[int]:
				# transformer decoder self-attention layers
				for i in range(6       ):
								# read in weights + bias of input projection layer of self-attention
								_UpperCAmelCase				:						Tuple       						=			state_dict.pop(F'decoder.layers.{i}.self_attn.in_proj_weight'       )
								_UpperCAmelCase				:						Optional[Any]       						=			state_dict.pop(F'decoder.layers.{i}.self_attn.in_proj_bias'       )
								# next, add query, keys and values (in that order) to the state dict
								_UpperCAmelCase				:						Tuple       						=			in_proj_weight[:256, :]
								_UpperCAmelCase				:						Dict       						=			in_proj_bias[:256]
								_UpperCAmelCase				:						int       						=			in_proj_weight[256:512, :]
								_UpperCAmelCase				:						Dict       						=			in_proj_bias[256:512]
								_UpperCAmelCase				:						Optional[int]       						=			in_proj_weight[-256:, :]
								_UpperCAmelCase				:						Optional[int]       						=			in_proj_bias[-256:]

def 							__SCREAMING_SNAKE_CASE							( )      ->				List[str]:
				_UpperCAmelCase				:						List[str]       						=			"http://images.cocodataset.org/val2017/000000039769.jpg"
				_UpperCAmelCase				:						Dict       						=			Image.open(requests.get(lowerCAmelCase     ,					stream=lowerCAmelCase       ).raw       )

				return im

@torch.no_grad()
def 							__SCREAMING_SNAKE_CASE							( lowerCAmelCase:     Union[str, Any]     ,					lowerCAmelCase:     List[str]     ,					lowerCAmelCase:     Optional[int]     ,					lowerCAmelCase:     int     ,					lowerCAmelCase:     Optional[Any]     ,					lowerCAmelCase:     Union[str, Any]     ,					lowerCAmelCase:     int     ,					)      ->				int:
				_UpperCAmelCase				:						Dict       						=			DeformableDetrConfig()
				# set config attributes
				if single_scale:
								_UpperCAmelCase				:						List[str]       						=			1
				_UpperCAmelCase				:						Optional[Any]       						=			dilation
				_UpperCAmelCase				:						int       						=			with_box_refine
				_UpperCAmelCase				:						int       						=			two_stage
				# set labels
				_UpperCAmelCase				:						Union[str, Any]       						=			91
				_UpperCAmelCase				:						Optional[int]       						=			"huggingface/label-files"
				_UpperCAmelCase				:						Tuple       						=			"coco-detection-id2label.json"
				_UpperCAmelCase				:						Optional[int]       						=			json.load(open(cached_download(hf_hub_url(lowerCAmelCase     ,					lowerCAmelCase     ,					repo_type="dataset"       )       )     ,					"r"       )       )
				_UpperCAmelCase				:						str       						=			{int(lowerCAmelCase       ): v for k, v in idalabel.items()}
				_UpperCAmelCase				:						Tuple       						=			idalabel
				_UpperCAmelCase				:						Any       						=			{v: k for k, v in idalabel.items()}

				# load image processor
				_UpperCAmelCase				:						List[Any]       						=			DeformableDetrImageProcessor(format="coco_detection"       )

				# prepare image
				_UpperCAmelCase				:						str       						=			prepare_img()
				_UpperCAmelCase				:						Union[str, Any]       						=			image_processor(images=lowerCAmelCase     ,					return_tensors="pt"       )
				_UpperCAmelCase				:						Any       						=			encoding["pixel_values"]

				logger.info("Converting model..."       )

				# load original state dict
				_UpperCAmelCase				:						Optional[Any]       						=			torch.load(lowerCAmelCase     ,					map_location="cpu"       )["model"]
				# rename keys
				for key in state_dict.copy().keys():
								_UpperCAmelCase				:						Optional[int]       						=			state_dict.pop(lowerCAmelCase       )
								_UpperCAmelCase				:						Optional[Any]       						=			val
				# query, key and value matrices need special treatment
				read_in_q_k_v(lowerCAmelCase       )
				# important: we need to prepend a prefix to each of the base model keys as the head models use different attributes for them
				_UpperCAmelCase				:						Optional[Any]       						=			"model."
				for key in state_dict.copy().keys():
								if not key.startswith("class_embed"       ) and not key.startswith("bbox_embed"       ):
												_UpperCAmelCase				:						Dict       						=			state_dict.pop(lowerCAmelCase       )
												_UpperCAmelCase				:						List[str]       						=			val
    # finally, create HuggingFace model and load state dict
				_UpperCAmelCase				:						Union[str, Any]       						=			DeformableDetrForObjectDetection(lowerCAmelCase       )
				model.load_state_dict(lowerCAmelCase       )
				model.eval()

				_UpperCAmelCase				:						Tuple       						=			"cuda" if torch.cuda.is_available() else "cpu"
				model.to(lowerCAmelCase       )
				# verify our conversion
				_UpperCAmelCase				:						List[Any]       						=			model(pixel_values.to(lowerCAmelCase       )       )

				_UpperCAmelCase				:						Dict       						=			torch.tensor(
				    [[-9.6_645, -4.3_449, -5.8_705], [-9.7_035, -3.8_504, -5.0_724], [-10.5_634, -5.3_379, -7.5_116]]       )
				_UpperCAmelCase				:						Optional[Any]       						=			torch.tensor([[0.8_693, 0.2_289, 0.2_492], [0.3_150, 0.5_489, 0.5_845], [0.5_563, 0.7_580, 0.8_518]]       )

				if single_scale:
								_UpperCAmelCase				:						Optional[int]       						=			torch.tensor(
								    [[-9.9_051, -4.2_541, -6.4_852], [-9.6_947, -4.0_854, -6.8_033], [-10.0_665, -5.8_470, -7.7_003]]       )
								_UpperCAmelCase				:						List[Any]       						=			torch.tensor([[0.7_292, 0.4_991, 0.5_532], [0.7_959, 0.2_426, 0.4_236], [0.7_582, 0.3_518, 0.4_451]]       )

				if single_scale and dilation:
								_UpperCAmelCase				:						List[Any]       						=			torch.tensor(
								    [[-8.9_652, -4.1_074, -5.6_635], [-9.0_596, -4.9_447, -6.6_075], [-10.1_178, -4.5_275, -6.2_671]]       )
								_UpperCAmelCase				:						Any       						=			torch.tensor([[0.7_665, 0.4_130, 0.4_769], [0.8_364, 0.1_841, 0.3_391], [0.6_261, 0.3_895, 0.7_978]]       )

				if with_box_refine:
								_UpperCAmelCase				:						Any       						=			torch.tensor(
								    [[-8.8_895, -5.4_187, -6.8_153], [-8.4_706, -6.1_668, -7.6_184], [-9.0_042, -5.5_359, -6.9_141]]       )
								_UpperCAmelCase				:						Optional[int]       						=			torch.tensor([[0.7_828, 0.2_208, 0.4_323], [0.0_892, 0.5_996, 0.1_319], [0.5_524, 0.6_389, 0.8_914]]       )

				if with_box_refine and two_stage:
								_UpperCAmelCase				:						Union[str, Any]       						=			torch.tensor(
								    [[-6.7_108, -4.3_213, -6.3_777], [-8.9_014, -6.1_799, -6.7_240], [-6.9_315, -4.4_735, -6.2_298]]       )
								_UpperCAmelCase				:						List[Any]       						=			torch.tensor([[0.2_583, 0.5_499, 0.4_683], [0.7_652, 0.9_068, 0.4_882], [0.5_490, 0.2_763, 0.0_564]]       )

				print("Logits:"     ,					outputs.logits[0, :3, :3]       )

				assert torch.allclose(outputs.logits[0, :3, :3]     ,					expected_logits.to(lowerCAmelCase       )     ,					atol=1E-4       )
				assert torch.allclose(outputs.pred_boxes[0, :3, :3]     ,					expected_boxes.to(lowerCAmelCase       )     ,					atol=1E-4       )

				print("Everything ok!"       )

				# Save model and image processor
				logger.info(F'Saving PyTorch model and image processor to {pytorch_dump_folder_path}...'       )
				Path(lowerCAmelCase       ).mkdir(exist_ok=lowerCAmelCase       )
				model.save_pretrained(lowerCAmelCase       )
				image_processor.save_pretrained(lowerCAmelCase       )

				# Push to hub
				if push_to_hub:
								_UpperCAmelCase				:						str       						=			"deformable-detr"
								model_name += "-single-scale" if single_scale else ""
								model_name += "-dc5" if dilation else ""
								model_name += "-with-box-refine" if with_box_refine else ""
								model_name += "-two-stage" if two_stage else ""
								print("Pushing model to hub..."       )
								model.push_to_hub(repo_path_or_name=lowerCAmelCase     ,					organization="nielsr"     ,					commit_message="Add model"       )


if __name__ == "__main__":
					SCREAMING_SNAKE_CASE_						=					argparse.ArgumentParser()

					parser.add_argument(
					    '--checkpoint_path',
					    type=str,
					    default='/home/niels/checkpoints/deformable_detr/r50_deformable_detr-checkpoint.pth',
					    help='Path to Pytorch checkpoint (.pth file) you\'d like to convert.',
					)
					parser.add_argument('--single_scale', action='store_true', help='Whether to set config.num_features_levels = 1.')
					parser.add_argument('--dilation', action='store_true', help='Whether to set config.dilation=True.')
					parser.add_argument('--with_box_refine', action='store_true', help='Whether to set config.with_box_refine=True.')
					parser.add_argument('--two_stage', action='store_true', help='Whether to set config.two_stage=True.')
					parser.add_argument(
					    '--pytorch_dump_folder_path',
					    default=None,
					    type=str,
					    required=True,
					    help='Path to the folder to output PyTorch model.',
					)
					parser.add_argument(
					    '--push_to_hub', action='store_true', help='Whether or not to push the converted model to the 🤗 hub.'
					)
					SCREAMING_SNAKE_CASE_						=					parser.parse_args()
					convert_deformable_detr_checkpoint(
					    args.checkpoint_path,
					    args.single_scale,
					    args.dilation,
					    args.with_box_refine,
					    args.two_stage,
					    args.pytorch_dump_folder_path,
					    args.push_to_hub,
					)





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


SCREAMING_SNAKE_CASE_						=					logging.get_logger(__name__)

# General docstring
SCREAMING_SNAKE_CASE_						=					'ResNetConfig'

# Base docstring
SCREAMING_SNAKE_CASE_						=					'microsoft/resnet-50'
SCREAMING_SNAKE_CASE_						=					[1, 2048, 7, 7]

# Image classification docstring
SCREAMING_SNAKE_CASE_						=					'microsoft/resnet-50'
SCREAMING_SNAKE_CASE_						=					'tiger cat'

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

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


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







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						int       						=			kernel_size // 2
										_UpperCAmelCase				:						Dict       						=			tf.keras.layers.ConvaD(
										    A_  ,    kernel_size=A_  ,    strides=A_  ,    padding="valid"  ,    use_bias=A_  ,    name="convolution"		)
										# Use same default momentum and epsilon as PyTorch equivalent
										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.BatchNormalization(epsilon=1e-5  ,    momentum=0.9  ,    name="normalization"		)
										_UpperCAmelCase				:						int       						=			ACTaFN[activation] if activation is not None else tf.keras.layers.Activation("linear"		)


						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Dict       						=			(self.pad_value, self.pad_value)
										_UpperCAmelCase				:						List[Any]       						=			tf.pad(A_  ,    [(0, 0), height_pad, width_pad, (0, 0)]		)
										_UpperCAmelCase				:						int       						=			self.conv(A_		)
										return hidden_state





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Optional[int]       						=			self.convolution(A_		)
										_UpperCAmelCase				:						Optional[Any]       						=			self.normalization(A_  ,    training=A_		)
										_UpperCAmelCase				:						Dict       						=			self.activation(A_		)
										return hidden_state







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


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







										'''simple docstring'''


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





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase						,							_UpperCAmelCase				:						Dict       						=			shape_list(A_		)
										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				:						List[str]       						=			self.embedder(A_		)
										_UpperCAmelCase				:						int       						=			tf.pad(A_  ,    [[0, 0], [1, 1], [1, 1], [0, 0]]		)
										_UpperCAmelCase				:						Dict       						=			self.pooler(A_		)
										return hidden_state







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


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







										'''simple docstring'''


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





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			x
										_UpperCAmelCase				:						str       						=			self.convolution(A_		)
										_UpperCAmelCase				:						str       						=			self.normalization(A_  ,    training=A_		)
										return hidden_state







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


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







										'''simple docstring'''


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





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										_UpperCAmelCase				:						Union[str, Any]       						=			hidden_state
										_UpperCAmelCase				:						Optional[int]       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						Union[str, Any]       						=			self.conva(A_  ,    training=A_		)
										_UpperCAmelCase				:						List[Any]       						=			self.shortcut(A_  ,    training=A_		)
										hidden_state += residual
										_UpperCAmelCase				:						Any       						=			self.activation(A_		)
										return hidden_state







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


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







										'''simple docstring'''


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





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


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







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


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







										'''simple docstring'''


										super().__init__(**A_		)

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

										_UpperCAmelCase				:						List[str]       						=			[layer(A_  ,    A_  ,    stride=A_  ,    activation=config.hidden_act  ,    name="layers.0"		)]
										layers += [
										    layer(A_  ,    A_  ,    activation=config.hidden_act  ,    name=f'layers.{i + 1}'		)
										    for i in range(depth - 1		)
										]
										_UpperCAmelCase				:						Optional[Any]       						=			layers





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False		):







										'''simple docstring'''


										for layer in self.stage_layers:
														_UpperCAmelCase				:						Union[str, Any]       						=			layer(A_  ,    training=A_		)
										return hidden_state







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


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







										'''simple docstring'''


										super().__init__(**A_		)
										# based on `downsample_in_first_stage` the first layer of the first stage may or may not downsample the input
										_UpperCAmelCase				:						List[str]       						=			[
										    TFResNetStage(
										        A_  ,    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(A_  ,    A_  ,    A_  ,    depth=A_  ,    name=f'stages.{i + 1}'		)		)





						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = False  ,    A_ = True  ,    A_ = False  ,    ):







										'''simple docstring'''


										_UpperCAmelCase				:						str       						=			() if output_hidden_states else None

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

														_UpperCAmelCase				:						Union[str, Any]       						=			stage_module(A_  ,    training=A_		)

										if output_hidden_states:
														_UpperCAmelCase				:						Union[str, Any]       						=			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=A_  ,    hidden_states=A_		)







class  a     (		UpperCAmelCase ):
						_lowercase			  =	ResNetConfig
						_lowercase			  =	"resnet"
						_lowercase			  =	"pixel_values"


						@property
						def 				_UpperCAmelCase (				self		):







										'''simple docstring'''


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







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


SCREAMING_SNAKE_CASE_						=					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  a     (		tf.keras.layers.Layer ):
						_lowercase			  =	ResNetConfig


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







										'''simple docstring'''


										super().__init__(**A_		)
										_UpperCAmelCase				:						List[Any]       						=			config
										_UpperCAmelCase				:						Optional[Any]       						=			TFResNetEmbeddings(A_  ,    name="embedder"		)
										_UpperCAmelCase				:						Tuple       						=			TFResNetEncoder(A_  ,    name="encoder"		)
										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.GlobalAveragePoolingaD(keepdims=A_		)





						@unpack_inputs
						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


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

										# TF 2.0 image layers can't use NCHW format when running on CPU.
										# We transpose to NHWC format and then transpose back after the full forward pass.
										# (batch_size, num_channels, height, width) -> (batch_size, height, width, num_channels)
										_UpperCAmelCase				:						List[Any]       						=			tf.transpose(A_  ,    perm=[0, 2, 3, 1]		)
										_UpperCAmelCase				:						Dict       						=			self.embedder(A_  ,    training=A_		)

										_UpperCAmelCase				:						Any       						=			self.encoder(
										    A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_		)

										_UpperCAmelCase				:						Optional[int]       						=			encoder_outputs[0]

										_UpperCAmelCase				:						Tuple       						=			self.pooler(A_		)

										# Transpose all the outputs to the NCHW format
										# (batch_size, height, width, num_channels) -> (batch_size, num_channels, height, width)
										_UpperCAmelCase				:						Union[str, Any]       						=			tf.transpose(A_  ,    (0, 3, 1, 2)		)
										_UpperCAmelCase				:						Any       						=			tf.transpose(A_  ,    (0, 3, 1, 2)		)
										_UpperCAmelCase				:						Tuple       						=			()
										for hidden_state in encoder_outputs[1:]:
														_UpperCAmelCase				:						Optional[int]       						=			hidden_states + tuple(tf.transpose(A_  ,    (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=A_  ,    pooler_output=A_  ,    hidden_states=A_  ,    )







@add_start_docstrings(
    "The bare ResNet model outputting raw features without any specific head on top."							,       UpperCAmelCase							,       )
class  a     (		UpperCAmelCase ):


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







										'''simple docstring'''


										super().__init__(A_  ,    **A_		)
										_UpperCAmelCase				:						int       						=			TFResNetMainLayer(config=A_  ,    name="resnet"		)





						@add_start_docstrings_to_model_forward(A_		)
						@add_code_sample_docstrings(
						    checkpoint=_CHECKPOINT_FOR_DOC  ,    output_type=A_  ,    config_class=_CONFIG_FOR_DOC  ,    modality="vision"  ,    expected_output=_EXPECTED_OUTPUT_SHAPE  ,    )
						@unpack_inputs
						def 				_UpperCAmelCase (				self  ,    A_  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


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

										_UpperCAmelCase				:						List[Any]       						=			self.resnet(
										    pixel_values=A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_  ,    )
										return resnet_outputs







@add_start_docstrings(
    "\n    ResNet Model with an image classification head on top (a linear layer on top of the pooled features), e.g. for\n    ImageNet.\n    "							,       UpperCAmelCase							,       )
class  a     (		UpperCAmelCase							,       UpperCAmelCase ):


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







										'''simple docstring'''


										super().__init__(A_  ,    **A_		)
										_UpperCAmelCase				:						Dict       						=			config.num_labels
										_UpperCAmelCase				:						List[Any]       						=			TFResNetMainLayer(A_  ,    name="resnet"		)
										# classification head
										_UpperCAmelCase				:						Union[str, Any]       						=			(
										    tf.keras.layers.Dense(config.num_labels  ,    name="classifier.1"		)
										    if config.num_labels > 0
										    else tf.keras.layers.Activation("linear"  ,    name="classifier.1"		)
										)


						def 				_UpperCAmelCase (				self  ,    A_		):







										'''simple docstring'''


										_UpperCAmelCase				:						Tuple       						=			tf.keras.layers.Flatten()(A_		)
										_UpperCAmelCase				:						Dict       						=			self.classifier_layer(A_		)
										return logits





						@add_start_docstrings_to_model_forward(A_		)
						@add_code_sample_docstrings(
						    checkpoint=_IMAGE_CLASS_CHECKPOINT  ,    output_type=A_  ,    config_class=_CONFIG_FOR_DOC  ,    expected_output=_IMAGE_CLASS_EXPECTED_OUTPUT  ,    )
						@unpack_inputs
						def 				_UpperCAmelCase (				self  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = None  ,    A_ = False  ,    ):







										'''simple docstring'''


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

										_UpperCAmelCase				:						Optional[Any]       						=			self.resnet(
										    A_  ,    output_hidden_states=A_  ,    return_dict=A_  ,    training=A_		)

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

										_UpperCAmelCase				:						int       						=			self.classifier(A_		)

										_UpperCAmelCase				:						str       						=			None if labels is None else self.hf_compute_loss(A_  ,    A_		)

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

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


