
import argparse
from collections import OrderedDict
from pathlib import Path

import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from torchvision.transforms import functional as F

from transformers import DetrImageProcessor, TableTransformerConfig, TableTransformerForObjectDetection
from transformers.utils import logging


logging.set_verbosity_info()
UpperCamelCase_					:						List[Any]				= logging.get_logger(__name__)

# here we list all keys to be renamed (original name on the left, our name on the right)
UpperCamelCase_					:						Any				= []
for i in range(6):
		# encoder layers: output projection, 2 feedforward neural networks and 2 layernorms
		rename_keys.append(
		    (F"""transformer.encoder.layers.{i}.self_attn.out_proj.weight""", F"""encoder.layers.{i}.self_attn.out_proj.weight""")
		)
		rename_keys.append(
		    (F"""transformer.encoder.layers.{i}.self_attn.out_proj.bias""", F"""encoder.layers.{i}.self_attn.out_proj.bias""")
		)
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.weight""", F"""encoder.layers.{i}.fc1.weight"""))
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear1.bias""", F"""encoder.layers.{i}.fc1.bias"""))
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.weight""", F"""encoder.layers.{i}.fc2.weight"""))
		rename_keys.append((F"""transformer.encoder.layers.{i}.linear2.bias""", F"""encoder.layers.{i}.fc2.bias"""))
		rename_keys.append(
		    (F"""transformer.encoder.layers.{i}.norm1.weight""", F"""encoder.layers.{i}.self_attn_layer_norm.weight""")
		)
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm1.bias""", F"""encoder.layers.{i}.self_attn_layer_norm.bias"""))
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.weight""", F"""encoder.layers.{i}.final_layer_norm.weight"""))
		rename_keys.append((F"""transformer.encoder.layers.{i}.norm2.bias""", F"""encoder.layers.{i}.final_layer_norm.bias"""))
		# decoder layers: 2 times output projection, 2 feedforward neural networks and 3 layernorms
		rename_keys.append(
		    (F"""transformer.decoder.layers.{i}.self_attn.out_proj.weight""", F"""decoder.layers.{i}.self_attn.out_proj.weight""")
		)
		rename_keys.append(
		    (F"""transformer.decoder.layers.{i}.self_attn.out_proj.bias""", F"""decoder.layers.{i}.self_attn.out_proj.bias""")
		)
		rename_keys.append(
		    (
		        F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.weight""",
		        F"""decoder.layers.{i}.encoder_attn.out_proj.weight""",
		    )
		)
		rename_keys.append(
		    (
		        F"""transformer.decoder.layers.{i}.multihead_attn.out_proj.bias""",
		        F"""decoder.layers.{i}.encoder_attn.out_proj.bias""",
		    )
		)
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.weight""", F"""decoder.layers.{i}.fc1.weight"""))
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear1.bias""", F"""decoder.layers.{i}.fc1.bias"""))
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.weight""", F"""decoder.layers.{i}.fc2.weight"""))
		rename_keys.append((F"""transformer.decoder.layers.{i}.linear2.bias""", F"""decoder.layers.{i}.fc2.bias"""))
		rename_keys.append(
		    (F"""transformer.decoder.layers.{i}.norm1.weight""", F"""decoder.layers.{i}.self_attn_layer_norm.weight""")
		)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm1.bias""", F"""decoder.layers.{i}.self_attn_layer_norm.bias"""))
		rename_keys.append(
		    (F"""transformer.decoder.layers.{i}.norm2.weight""", F"""decoder.layers.{i}.encoder_attn_layer_norm.weight""")
		)
		rename_keys.append(
		    (F"""transformer.decoder.layers.{i}.norm2.bias""", F"""decoder.layers.{i}.encoder_attn_layer_norm.bias""")
		)
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.weight""", F"""decoder.layers.{i}.final_layer_norm.weight"""))
		rename_keys.append((F"""transformer.decoder.layers.{i}.norm3.bias""", F"""decoder.layers.{i}.final_layer_norm.bias"""))

# convolutional projection + query embeddings + layernorm of encoder + layernorm of decoder + class and bounding box heads
rename_keys.extend(
    [
        ('''input_proj.weight''', '''input_projection.weight'''),
        ('''input_proj.bias''', '''input_projection.bias'''),
        ('''query_embed.weight''', '''query_position_embeddings.weight'''),
        ('''transformer.encoder.norm.weight''', '''encoder.layernorm.weight'''),
        ('''transformer.encoder.norm.bias''', '''encoder.layernorm.bias'''),
        ('''transformer.decoder.norm.weight''', '''decoder.layernorm.weight'''),
        ('''transformer.decoder.norm.bias''', '''decoder.layernorm.bias'''),
        ('''class_embed.weight''', '''class_labels_classifier.weight'''),
        ('''class_embed.bias''', '''class_labels_classifier.bias'''),
        ('''bbox_embed.layers.0.weight''', '''bbox_predictor.layers.0.weight'''),
        ('''bbox_embed.layers.0.bias''', '''bbox_predictor.layers.0.bias'''),
        ('''bbox_embed.layers.1.weight''', '''bbox_predictor.layers.1.weight'''),
        ('''bbox_embed.layers.1.bias''', '''bbox_predictor.layers.1.bias'''),
        ('''bbox_embed.layers.2.weight''', '''bbox_predictor.layers.2.weight'''),
        ('''bbox_embed.layers.2.bias''', '''bbox_predictor.layers.2.bias'''),
    ]
)
def 							A_     (__a				,   __a				,   __a				):

					'''simple docstring'''





					A_				 =						state_dict.pop(lowerCAmelCase__				)
					A_				 =						val
def 							A_     (__a				):

					'''simple docstring'''





					A_				 =						OrderedDict()
					for key, value in state_dict.items():
										if "backbone.0.body" in key:
															A_				 =						key.replace("backbone.0.body"				,   "backbone.conv_encoder.model"				)
															A_				 =						value
										else:
															A_				 =						value

					return new_state_dict
def 							A_     (__a				):

					'''simple docstring'''





					A_				 =						''

					# first: transformer encoder
					for i in range(6				):
										# read in weights + bias of input projection layer (in PyTorch's MultiHeadAttention, this is a single matrix + bias)
										A_				 =						state_dict.pop(f'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_weight'				)
										A_				 =						state_dict.pop(f'{prefix}transformer.encoder.layers.{i}.self_attn.in_proj_bias'				)
										# next, add query, keys and values (in that order) to the state dict
										A_				 =						in_proj_weight[:256, :]
										A_				 =						in_proj_bias[:256]
										A_				 =						in_proj_weight[256:512, :]
										A_				 =						in_proj_bias[256:512]
										A_				 =						in_proj_weight[-256:, :]
										A_				 =						in_proj_bias[-256:]
					# next: transformer decoder (which is a bit more complex because it also includes cross-attention)
					for i in range(6				):
										# read in weights + bias of input projection layer of self-attention
										A_				 =						state_dict.pop(f'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_weight'				)
										A_				 =						state_dict.pop(f'{prefix}transformer.decoder.layers.{i}.self_attn.in_proj_bias'				)
										# next, add query, keys and values (in that order) to the state dict
										A_				 =						in_proj_weight[:256, :]
										A_				 =						in_proj_bias[:256]
										A_				 =						in_proj_weight[256:512, :]
										A_				 =						in_proj_bias[256:512]
										A_				 =						in_proj_weight[-256:, :]
										A_				 =						in_proj_bias[-256:]
										# read in weights + bias of input projection layer of cross-attention
										A_				 =						state_dict.pop(
										    f'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_weight'				)
										A_				 =						state_dict.pop(f'{prefix}transformer.decoder.layers.{i}.multihead_attn.in_proj_bias'				)
										# next, add query, keys and values (in that order) of cross-attention to the state dict
										A_				 =						in_proj_weight_cross_attn[:256, :]
										A_				 =						in_proj_bias_cross_attn[:256]
										A_				 =						in_proj_weight_cross_attn[256:512, :]
										A_				 =						in_proj_bias_cross_attn[256:512]
										A_				 =						in_proj_weight_cross_attn[-256:, :]
										A_				 =						in_proj_bias_cross_attn[-256:]
def 							A_     (__a				,   __a				):

					'''simple docstring'''





					A_				 =						image.size
					A_				 =						max(lowerCAmelCase__				,   lowerCAmelCase__				)
					A_				 =						800 if 'detection' in checkpoint_url else 1000
					A_				 =						target_max_size / current_max_size
					A_				 =						image.resize((int(round(scale * width				)				), int(round(scale * height				)				))				)

					return resized_image
def 							A_     (__a				):

					'''simple docstring'''





					A_				 =						F.to_tensor(lowerCAmelCase__				)
					A_				 =						F.normalize(lowerCAmelCase__				,   mean=[0.485, 0.456, 0.406]				,   std=[0.229, 0.224, 0.225]				)
					return image
@torch.no_grad()
def 							A_     (__a				,   __a				,   __a				):

					'''simple docstring'''





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

					# load original state dict
					A_				 =						torch.hub.load_state_dict_from_url(lowerCAmelCase__				,   map_location="cpu"				)
					# rename keys
					for src, dest in rename_keys:
										rename_key(lowerCAmelCase__				,   lowerCAmelCase__				,   lowerCAmelCase__				)
					A_				 =						rename_backbone_keys(lowerCAmelCase__				)
					# 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
					A_				 =						'model.'
					for key in state_dict.copy().keys():
										if not key.startswith("class_labels_classifier"				) and not key.startswith("bbox_predictor"				):
															A_				 =						state_dict.pop(lowerCAmelCase__				)
															A_				 =						val
    # create HuggingFace model and load state dict
					A_				 =						TableTransformerConfig(
					    backbone="resnet18"				,   mask_loss_coefficient=1				,   dice_loss_coefficient=1				,   ce_loss_coefficient=1				,   bbox_loss_coefficient=5				,   giou_loss_coefficient=2				,   eos_coefficient=0.4				,   class_cost=1				,   bbox_cost=5				,   giou_cost=2				,   )

					if "detection" in checkpoint_url:
										A_				 =						15
										A_				 =						2
										A_				 =						{0: 'table', 1: 'table rotated'}
										A_				 =						idalabel
										A_				 =						{v: k for k, v in idalabel.items()}
					else:
										A_				 =						125
										A_				 =						6
										A_				 =						{
										    0: 'table',
										    1: 'table column',
										    2: 'table row',
										    3: 'table column header',
										    4: 'table projected row header',
										    5: 'table spanning cell',
										}
										A_				 =						idalabel
										A_				 =						{v: k for k, v in idalabel.items()}

					A_				 =						DetrImageProcessor(
					    format="coco_detection"				,   max_size=800 if "detection" in checkpoint_url else 1000				)
					A_				 =						TableTransformerForObjectDetection(lowerCAmelCase__				)
					model.load_state_dict(lowerCAmelCase__				)
					model.eval()

					# verify our conversion
					A_				 =						'example_pdf.png' if 'detection' in checkpoint_url else 'example_table.png'
					A_				 =						hf_hub_download(repo_id="nielsr/example-pdf"				,   repo_type="dataset"				,   filename=lowerCAmelCase__				)
					A_				 =						Image.open(lowerCAmelCase__				).convert("RGB"				)
					A_				 =						normalize(resize(lowerCAmelCase__				,   lowerCAmelCase__				)				).unsqueeze(0				)

					A_				 =						model(lowerCAmelCase__				)

					if "detection" in checkpoint_url:
										A_				 =						(1, 15, 3)
										A_				 =						torch.tensor(
										    [[-6.7897, -16.9985, 6.7937], [-8.0186, -22.2192, 6.9677], [-7.3117, -21.0708, 7.4055]]				)
										A_				 =						torch.tensor([[0.4867, 0.1767, 0.6732], [0.6718, 0.4479, 0.3830], [0.4716, 0.1760, 0.6364]]				)

					else:
										A_				 =						(1, 125, 7)
										A_				 =						torch.tensor(
										    [[-18.1430, -8.3214, 4.8274], [-18.4685, -7.1361, -4.2667], [-26.3693, -9.3429, -4.9962]]				)
										A_				 =						torch.tensor([[0.4983, 0.5595, 0.9440], [0.4916, 0.6315, 0.5954], [0.6108, 0.8637, 0.1135]]				)

					assert outputs.logits.shape == expected_shape
					assert torch.allclose(outputs.logits[0, :3, :3]				,   lowerCAmelCase__				,   atol=1e-4				)
					assert torch.allclose(outputs.pred_boxes[0, :3, :3]				,   lowerCAmelCase__				,   atol=1e-4				)
					print("Looks ok!"				)

					if pytorch_dump_folder_path is not None:
										# 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__				)

					if push_to_hub:
										# Push model to HF hub
										logger.info("Pushing model to the hub..."				)
										A_				 =						(
										    'microsoft/table-transformer-detection'
										    if 'detection' in checkpoint_url
										    else 'microsoft/table-transformer-structure-recognition'
										)
										model.push_to_hub(lowerCAmelCase__				)
										image_processor.push_to_hub(lowerCAmelCase__				)


if __name__ == "__main__":
		UpperCamelCase_					:						Union[str, Any]				= argparse.ArgumentParser()

		parser.add_argument(
		    '''--checkpoint_url''',
		    default='''https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth''',
		    type=str,
		    choices=[
		        '''https://pubtables1m.blob.core.windows.net/model/pubtables1m_detection_detr_r18.pth''',
		        '''https://pubtables1m.blob.core.windows.net/model/pubtables1m_structure_detr_r18.pth''',
		    ],
		    help='''URL of the Table Transformer checkpoint you\'d like to convert.''',
		)
		parser.add_argument(
		    '''--pytorch_dump_folder_path''', default=None, type=str, 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.'''
		)
		UpperCamelCase_					:						int				= parser.parse_args()
		convert_table_transformer_checkpoint(args.checkpoint_url, args.pytorch_dump_folder_path, args.push_to_hub)






"""simple docstring"""





import inspect
import unittest

from transformers import RegNetConfig
from transformers.file_utils import cached_property, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

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


if is_torch_available():
		import torch
		from torch import nn

		from transformers import RegNetForImageClassification, RegNetModel
		from transformers.models.regnet.modeling_regnet import REGNET_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
		from PIL import Image

		from transformers import AutoImageProcessor



class __lowerCAmelCase				:




			"""simple docstring"""







			def __init__(				self						:					Optional[int]       ,   _snake_case						:					Any       ,   _snake_case						:					int=3       ,   _snake_case						:					List[Any]=32       ,   _snake_case						:					str=3       ,   _snake_case						:					Any=10       ,   _snake_case						:					List[Any]=[10, 20, 30, 40]       ,   _snake_case						:					Dict=[1, 1, 2, 1]       ,   _snake_case						:					Dict=True       ,   _snake_case						:					Any=True       ,   _snake_case						:					List[str]="relu"       ,   _snake_case						:					List[Any]=3       ,   _snake_case						:					List[str]=None       ,   )      -> int:







								"""simple docstring"""
								A_				 =						parent
								A_				 =						batch_size
								A_				 =						image_size
								A_				 =						num_channels
								A_				 =						embeddings_size
								A_				 =						hidden_sizes
								A_				 =						depths
								A_				 =						is_training
								A_				 =						use_labels
								A_				 =						hidden_act
								A_				 =						num_labels
								A_				 =						scope
								A_				 =						len(_snake_case	)




			def      lowerCamelCase__     (				self						:					Any	)      -> Optional[int]:







								"""simple docstring"""
								A_				 =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

								A_				 =						None
								if self.use_labels:
													A_				 =						ids_tensor([self.batch_size]       ,   self.num_labels	)

								A_				 =						self.get_config()

								return config, pixel_values, labels




			def      lowerCamelCase__     (				self						:					List[str]	)      -> Union[str, Any]:







								"""simple docstring"""
								return RegNetConfig(
								    num_channels=self.num_channels       ,   embeddings_size=self.embeddings_size       ,   hidden_sizes=self.hidden_sizes       ,   depths=self.depths       ,   hidden_act=self.hidden_act       ,   num_labels=self.num_labels       ,   )




			def      lowerCamelCase__     (				self						:					Union[str, Any]       ,   _snake_case						:					str       ,   _snake_case						:					Tuple       ,   _snake_case						:					Tuple	)      -> List[str]:







								"""simple docstring"""
								A_				 =						RegNetModel(config=_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case	)
								# expected last hidden states: B, C, H // 32, W // 32
								self.parent.assertEqual(
								    result.last_hidden_state.shape       ,   (self.batch_size, self.hidden_sizes[-1], self.image_size // 32, self.image_size // 32)       ,   )




			def      lowerCamelCase__     (				self						:					Dict       ,   _snake_case						:					Tuple       ,   _snake_case						:					Optional[Any]       ,   _snake_case						:					Optional[Any]	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						self.num_labels
								A_				 =						RegNetForImageClassification(_snake_case	)
								model.to(_snake_case	)
								model.eval()
								A_				 =						model(_snake_case       ,   labels=_snake_case	)
								self.parent.assertEqual(result.logits.shape       ,   (self.batch_size, self.num_labels)	)






			def      lowerCamelCase__     (				self						:					int	)      -> Optional[Any]:







								"""simple docstring"""
								A_				 =						self.prepare_config_and_inputs()
								A_ ,    A_ ,    A_				 =						config_and_inputs
								A_				 =						{"pixel_values": pixel_values}
								return config, inputs_dict





@require_torch
class __lowerCAmelCase				(					_lowercase     ,				_lowercase     ,				unittest.TestCase      ):




			"""simple docstring"""







			snake_case	      =				(RegNetModel, RegNetForImageClassification) if is_torch_available() else ()
			snake_case	      =				(
			    {"feature-extraction": RegNetModel, "image-classification": RegNetForImageClassification}
			    if is_torch_available()
			    else {}
			)

			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False
			snake_case	      =				False




			def      lowerCamelCase__     (				self						:					str	)      -> str:







								"""simple docstring"""
								A_				 =						RegNetModelTester(self	)
								A_				 =						ConfigTester(self       ,   config_class=_snake_case       ,   has_text_modality=_snake_case	)




			def      lowerCamelCase__     (				self						:					Tuple	)      -> List[Any]:







								"""simple docstring"""
								self.create_and_test_config_common_properties()
								self.config_tester.create_and_test_config_to_json_string()
								self.config_tester.create_and_test_config_to_json_file()
								self.config_tester.create_and_test_config_from_and_save_pretrained()
								self.config_tester.create_and_test_config_with_num_labels()
								self.config_tester.check_config_can_be_init_without_params()
								self.config_tester.check_config_arguments_init()




			def      lowerCamelCase__     (				self						:					int	)      -> List[Any]:







								"""simple docstring"""
								return




			@unittest.skip(reason="RegNet does not use inputs_embeds"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Optional[Any]:







								"""simple docstring"""
								pass




			@unittest.skip(reason="RegNet does not support input and output embeddings"	)
			def      lowerCamelCase__     (				self						:					int	)      -> Union[str, Any]:







								"""simple docstring"""
								pass




			def      lowerCamelCase__     (				self						:					Optional[int]	)      -> List[Any]:







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

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

													A_				 =						["pixel_values"]
													self.assertListEqual(arg_names[:1]       ,   _snake_case	)




			def      lowerCamelCase__     (				self						:					Any	)      -> int:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*_snake_case	)




			def      lowerCamelCase__     (				self						:					List[str]	)      -> int:







								"""simple docstring"""
								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
													A_				 =						model_class(config=_snake_case	)
													for name, module in model.named_modules():
																		if isinstance(_snake_case       ,   (nn.BatchNormad, nn.GroupNorm)	):
																							self.assertTrue(
																							    torch.all(module.weight == 1	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )
																							self.assertTrue(
																							    torch.all(module.bias == 0	)       ,   msg=F'Parameter {name} of model {model_class} seems not properly initialized'       ,   )




			def      lowerCamelCase__     (				self						:					List[Any]	)      -> List[str]:







								"""simple docstring"""
								def check_hidden_states_output(_snake_case						:					Tuple       ,   _snake_case						:					Optional[int]       ,   _snake_case						:					Optional[int]	):
													A_				 =						model_class(_snake_case	)
													model.to(_snake_case	)
													model.eval()

													with torch.no_grad():
																		A_				 =						model(**self._prepare_for_class(_snake_case       ,   _snake_case	)	)

													A_				 =						outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

													A_				 =						self.model_tester.num_stages
													self.assertEqual(len(_snake_case	)       ,   expected_num_stages + 1	)

													# RegNet's feature maps are of shape (batch_size, num_channels, height, width)
													self.assertListEqual(
													    list(hidden_states[0].shape[-2:]	)       ,   [self.model_tester.image_size // 2, self.model_tester.image_size // 2]       ,   )

								A_ ,    A_				 =						self.model_tester.prepare_config_and_inputs_for_common()
								A_				 =						["basic", "bottleneck"]
								for model_class in self.all_model_classes:
													for layer_type in layers_type:
																		A_				 =						layer_type
																		A_				 =						True
																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)

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

																		check_hidden_states_output(_snake_case       ,   _snake_case       ,   _snake_case	)




			def      lowerCamelCase__     (				self						:					str	)      -> List[str]:







								"""simple docstring"""
								A_				 =						self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_image_classification(*_snake_case	)






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







								"""simple docstring"""
								for model_name in REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													A_				 =						RegNetModel.from_pretrained(_snake_case	)
													self.assertIsNotNone(_snake_case	)





def 							A_     ():

					'''simple docstring'''





					A_				 =						Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
					return image




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




			"""simple docstring"""







			@cached_property
			def      lowerCamelCase__     (				self						:					Union[str, Any]	)      -> int:







								"""simple docstring"""
								return (
								    AutoImageProcessor.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	)
								    if is_vision_available()
								    else None
								)






			@slow
			def      lowerCamelCase__     (				self						:					str	)      -> List[Any]:







								"""simple docstring"""
								A_				 =						RegNetForImageClassification.from_pretrained(REGNET_PRETRAINED_MODEL_ARCHIVE_LIST[0]	).to(_snake_case	)

								A_				 =						self.default_image_processor
								A_				 =						prepare_img()
								A_				 =						image_processor(images=_snake_case       ,   return_tensors="pt"	).to(_snake_case	)

								# forward pass
								with torch.no_grad():
													A_				 =						model(**_snake_case	)

								# verify the logits
								A_				 =						torch.Size((1, 1_000)	)
								self.assertEqual(outputs.logits.shape       ,   _snake_case	)

								A_				 =						torch.tensor([-0.4_1_8_0, -1.5_0_5_1, -3.4_8_3_6]	).to(_snake_case	)

								self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,   _snake_case       ,   atol=1e-4	)	)




