



import argparse
import json
import os

import numpy as np
import PIL
import requests
import tensorflow.keras.applications.efficientnet as efficientnet
import torch
from huggingface_hub import hf_hub_download
from PIL import Image
from tensorflow.keras.preprocessing import image

from transformers import (
    EfficientNetConfig,
    EfficientNetForImageClassification,
    EfficientNetImageProcessor,
)
from transformers.utils import logging


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

__A       =						{
    '''b0''': efficientnet.EfficientNetBa,
    '''b1''': efficientnet.EfficientNetBa,
    '''b2''': efficientnet.EfficientNetBa,
    '''b3''': efficientnet.EfficientNetBa,
    '''b4''': efficientnet.EfficientNetBa,
    '''b5''': efficientnet.EfficientNetBa,
    '''b6''': efficientnet.EfficientNetBa,
    '''b7''': efficientnet.EfficientNetBa,
}

__A       =						{
    '''b0''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.0,
        '''image_size''': 224,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [],
    },
    '''b1''': {
        '''hidden_dim''': 1280,
        '''width_coef''': 1.0,
        '''depth_coef''': 1.1,
        '''image_size''': 240,
        '''dropout_rate''': 0.2,
        '''dw_padding''': [16],
    },
    '''b2''': {
        '''hidden_dim''': 1408,
        '''width_coef''': 1.1,
        '''depth_coef''': 1.2,
        '''image_size''': 260,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 8, 16],
    },
    '''b3''': {
        '''hidden_dim''': 1536,
        '''width_coef''': 1.2,
        '''depth_coef''': 1.4,
        '''image_size''': 300,
        '''dropout_rate''': 0.3,
        '''dw_padding''': [5, 18],
    },
    '''b4''': {
        '''hidden_dim''': 1792,
        '''width_coef''': 1.4,
        '''depth_coef''': 1.8,
        '''image_size''': 380,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [6],
    },
    '''b5''': {
        '''hidden_dim''': 2048,
        '''width_coef''': 1.6,
        '''depth_coef''': 2.2,
        '''image_size''': 456,
        '''dropout_rate''': 0.4,
        '''dw_padding''': [13, 27],
    },
    '''b6''': {
        '''hidden_dim''': 2304,
        '''width_coef''': 1.8,
        '''depth_coef''': 2.6,
        '''image_size''': 528,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [31],
    },
    '''b7''': {
        '''hidden_dim''': 2560,
        '''width_coef''': 2.0,
        '''depth_coef''': 3.1,
        '''image_size''': 600,
        '''dropout_rate''': 0.5,
        '''dw_padding''': [18],
    },
}



def 	__a					(   lowerCAmelCase_       : Tuple    )				->			List[Any]:






						'''simple docstring'''



						UpperCAmelCase_=       EfficientNetConfig()
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""hidden_dim"""]
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""width_coef"""]
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""depth_coef"""]
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""image_size"""]
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""dropout_rate"""]
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""dw_padding"""]

						UpperCAmelCase_=       """huggingface/label-files"""
						UpperCAmelCase_=       """imagenet-1k-id2label.json"""
						UpperCAmelCase_=       10_00
						UpperCAmelCase_=       json.load(open(hf_hub_download(lowerCAmelCase_      ,lowerCAmelCase_      ,repo_type="""dataset"""    )      ,"""r"""    )    )
						UpperCAmelCase_=       {int(lowerCAmelCase_    ): v for k, v in idalabel.items()}

						UpperCAmelCase_=       idalabel
						UpperCAmelCase_=       {v: k for k, v in idalabel.items()}
						return config



def 	__a					(   )				->			Union[str, Any]:






						'''simple docstring'''



						UpperCAmelCase_=       """http://images.cocodataset.org/val2017/000000039769.jpg"""
						UpperCAmelCase_=       Image.open(requests.get(lowerCAmelCase_      ,stream=lowerCAmelCase_    ).raw    )
						return im



def 	__a					(   lowerCAmelCase_       : List[str]    )				->			Union[str, Any]:






						'''simple docstring'''



						UpperCAmelCase_=       CONFIG_MAP[model_name]["""image_size"""]
						UpperCAmelCase_=       EfficientNetImageProcessor(
						    size={"""height""": size, """width""": size}      ,image_mean=[0.485, 0.456, 0.406]      ,image_std=[0.47_853_944, 0.4_732_864, 0.47_434_163]      ,do_center_crop=lowerCAmelCase_      ,)
						return preprocessor



def 	__a					(   lowerCAmelCase_       : Any    )				->			Dict:






						'''simple docstring'''



						UpperCAmelCase_=       [v.split("""_"""    )[0].split("""block"""    )[1] for v in original_param_names if v.startswith("""block"""    )]
						UpperCAmelCase_=       sorted(set(lowerCAmelCase_    )    )
						UpperCAmelCase_=       len(lowerCAmelCase_    )
						UpperCAmelCase_=       {b: str(lowerCAmelCase_    ) for b, i in zip(lowerCAmelCase_      ,range(lowerCAmelCase_    )    )}

						UpperCAmelCase_=       []
						rename_keys.append(("""stem_conv/kernel:0""", """embeddings.convolution.weight""")    )
						rename_keys.append(("""stem_bn/gamma:0""", """embeddings.batchnorm.weight""")    )
						rename_keys.append(("""stem_bn/beta:0""", """embeddings.batchnorm.bias""")    )
						rename_keys.append(("""stem_bn/moving_mean:0""", """embeddings.batchnorm.running_mean""")    )
						rename_keys.append(("""stem_bn/moving_variance:0""", """embeddings.batchnorm.running_var""")    )

						for b in block_names:
												UpperCAmelCase_=       block_name_mapping[b]
												rename_keys.append((F"""block{b}_expand_conv/kernel:0""", F"""encoder.blocks.{hf_b}.expansion.expand_conv.weight""")    )
												rename_keys.append((F"""block{b}_expand_bn/gamma:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.weight""")    )
												rename_keys.append((F"""block{b}_expand_bn/beta:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.bias""")    )
												rename_keys.append(
												    (F"""block{b}_expand_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_mean""")    )
												rename_keys.append(
												    (F"""block{b}_expand_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.expansion.expand_bn.running_var""")    )
												rename_keys.append(
												    (F"""block{b}_dwconv/depthwise_kernel:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_conv.weight""")    )
												rename_keys.append((F"""block{b}_bn/gamma:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.weight""")    )
												rename_keys.append((F"""block{b}_bn/beta:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.bias""")    )
												rename_keys.append(
												    (F"""block{b}_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_mean""")    )
												rename_keys.append(
												    (F"""block{b}_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.depthwise_conv.depthwise_norm.running_var""")    )

												rename_keys.append((F"""block{b}_se_reduce/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.weight""")    )
												rename_keys.append((F"""block{b}_se_reduce/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.reduce.bias""")    )
												rename_keys.append((F"""block{b}_se_expand/kernel:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.weight""")    )
												rename_keys.append((F"""block{b}_se_expand/bias:0""", F"""encoder.blocks.{hf_b}.squeeze_excite.expand.bias""")    )
												rename_keys.append(
												    (F"""block{b}_project_conv/kernel:0""", F"""encoder.blocks.{hf_b}.projection.project_conv.weight""")    )
												rename_keys.append((F"""block{b}_project_bn/gamma:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.weight""")    )
												rename_keys.append((F"""block{b}_project_bn/beta:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.bias""")    )
												rename_keys.append(
												    (F"""block{b}_project_bn/moving_mean:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_mean""")    )
												rename_keys.append(
												    (F"""block{b}_project_bn/moving_variance:0""", F"""encoder.blocks.{hf_b}.projection.project_bn.running_var""")    )

						rename_keys.append(("""top_conv/kernel:0""", """encoder.top_conv.weight""")    )
						rename_keys.append(("""top_bn/gamma:0""", """encoder.top_bn.weight""")    )
						rename_keys.append(("""top_bn/beta:0""", """encoder.top_bn.bias""")    )
						rename_keys.append(("""top_bn/moving_mean:0""", """encoder.top_bn.running_mean""")    )
						rename_keys.append(("""top_bn/moving_variance:0""", """encoder.top_bn.running_var""")    )

						UpperCAmelCase_=       {}
						for item in rename_keys:
												if item[0] in original_param_names:
																		UpperCAmelCase_=       """efficientnet.""" + item[1]

						UpperCAmelCase_=       """classifier.weight"""
						UpperCAmelCase_=       """classifier.bias"""
						return key_mapping



def 	__a					(   lowerCAmelCase_       : List[Any]      ,lowerCAmelCase_       : Optional[int]      ,lowerCAmelCase_       : Union[str, Any]    )				->			Union[str, Any]:






						'''simple docstring'''



						for key, value in tf_params.items():
												if "normalization" in key:
																		continue

												UpperCAmelCase_=       key_mapping[key]
												if "_conv" in key and "kernel" in key:
																		UpperCAmelCase_=       torch.from_numpy(lowerCAmelCase_    ).permute(3      ,2      ,0      ,1    )
												elif "depthwise_kernel" in key:
																		UpperCAmelCase_=       torch.from_numpy(lowerCAmelCase_    ).permute(2      ,3      ,0      ,1    )
												elif "kernel" in key:
																		UpperCAmelCase_=       torch.from_numpy(np.transpose(lowerCAmelCase_    )    )
												else:
																		UpperCAmelCase_=       torch.from_numpy(lowerCAmelCase_    )

												# Replace HF parameters with original TF model parameters
												assert hf_params[hf_key].shape == new_hf_value.shape
												hf_params[hf_key].copy_(lowerCAmelCase_    )



@torch.no_grad()
def 	__a					(   lowerCAmelCase_       : int      ,lowerCAmelCase_       : str      ,lowerCAmelCase_       : Dict      ,lowerCAmelCase_       : Optional[Any]    )				->			str:






						'''simple docstring'''



						UpperCAmelCase_=       model_classes[model_name](
						    include_top=lowerCAmelCase_      ,weights="""imagenet"""      ,input_tensor=lowerCAmelCase_      ,input_shape=lowerCAmelCase_      ,pooling=lowerCAmelCase_      ,classes=10_00      ,classifier_activation="""softmax"""      ,)

						UpperCAmelCase_=       original_model.trainable_variables
						UpperCAmelCase_=       original_model.non_trainable_variables
						UpperCAmelCase_=       {param.name: param.numpy() for param in tf_params}
						for param in tf_non_train_params:
												UpperCAmelCase_=       param.numpy()
						UpperCAmelCase_=       list(tf_params.keys()    )

						# Load HuggingFace model
						UpperCAmelCase_=       get_efficientnet_config(lowerCAmelCase_    )
						UpperCAmelCase_=       EfficientNetForImageClassification(lowerCAmelCase_    ).eval()
						UpperCAmelCase_=       hf_model.state_dict()

						# Create src-to-dst parameter name mapping dictionary
						print("""Converting parameters..."""    )
						UpperCAmelCase_=       rename_keys(lowerCAmelCase_    )
						replace_params(lowerCAmelCase_      ,lowerCAmelCase_      ,lowerCAmelCase_    )

						# Initialize preprocessor and preprocess input image
						UpperCAmelCase_=       convert_image_processor(lowerCAmelCase_    )
						UpperCAmelCase_=       preprocessor(images=prepare_img()      ,return_tensors="""pt"""    )

						# HF model inference
						hf_model.eval()
						with torch.no_grad():
												UpperCAmelCase_=       hf_model(**lowerCAmelCase_    )
						UpperCAmelCase_=       outputs.logits.detach().numpy()

						# Original model inference
						UpperCAmelCase_=       False
						UpperCAmelCase_=       CONFIG_MAP[model_name]["""image_size"""]
						UpperCAmelCase_=       prepare_img().resize((image_size, image_size)      ,resample=PIL.Image.NEAREST    )
						UpperCAmelCase_=       image.img_to_array(lowerCAmelCase_    )
						UpperCAmelCase_=       np.expand_dims(lowerCAmelCase_      ,axis=0    )
						UpperCAmelCase_=       original_model.predict(lowerCAmelCase_    )

						# Check whether original and HF model outputs match  -> np.allclose
						assert np.allclose(lowerCAmelCase_      ,lowerCAmelCase_      ,atol=1E-3    ), "The predicted logits are not the same."
						print("""Model outputs match!"""    )

						if save_model:
												# Create folder to save model
												if not os.path.isdir(lowerCAmelCase_    ):
																		os.mkdir(lowerCAmelCase_    )
												# Save converted model and image processor
												hf_model.save_pretrained(lowerCAmelCase_    )
												preprocessor.save_pretrained(lowerCAmelCase_    )

						if push_to_hub:
												# Push model and image processor to hub
												print(F"""Pushing converted {model_name} to the hub..."""    )
												UpperCAmelCase_=       F"""efficientnet-{model_name}"""
												preprocessor.push_to_hub(lowerCAmelCase_    )
												hf_model.push_to_hub(lowerCAmelCase_    )


if __name__ == "__main__":
	__A       =						argparse.ArgumentParser()
	# Required parameters
	parser.add_argument(
	    '''--model_name''',
	    default='''b0''',
	    type=str,
	    help='''Version name of the EfficientNet model you want to convert, select from [b0, b1, b2, b3, b4, b5, b6, b7].''',
	)
	parser.add_argument(
	    '''--pytorch_dump_folder_path''',
	    default='''hf_model''',
	    type=str,
	    help='''Path to the output PyTorch model directory.''',
	)
	parser.add_argument('''--save_model''', action='''store_true''', help='''Save model to local''')
	parser.add_argument('''--push_to_hub''', action='''store_true''', help='''Push model and image processor to the hub''')

	__A       =						parser.parse_args()
	convert_efficientnet_checkpoint(args.model_name, args.pytorch_dump_folder_path, args.save_model, args.push_to_hub)









import inspect
import unittest

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

from ...test_backbone_common import BackboneTesterMixin
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 transformers import ConvNextBackbone, ConvNextForImageClassification, ConvNextModel
	from transformers.models.convnext.modeling_convnext import CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
	from PIL import Image

	from transformers import AutoImageProcessor






class 		lowercase						:






	"""simple docstring"""


	def __init__(     self     :						Any						,  __UpperCAmelCase     :						Union[str, Any]						,  __UpperCAmelCase     :						Optional[Any]=13						,  __UpperCAmelCase     :						Dict=32						,  __UpperCAmelCase     :						Union[str, Any]=3						,  __UpperCAmelCase     :						int=4						,  __UpperCAmelCase     :						Any=[10, 20, 30, 40]						,  __UpperCAmelCase     :						int=[2, 2, 3, 2]						,  __UpperCAmelCase     :						Tuple=True						,  __UpperCAmelCase     :						Optional[Any]=True						,  __UpperCAmelCase     :						Union[str, Any]=37						,  __UpperCAmelCase     :						List[Any]="gelu"						,  __UpperCAmelCase     :						Dict=10						,  __UpperCAmelCase     :						Dict=0.02						,  __UpperCAmelCase     :						List[str]=["stage2", "stage3", "stage4"]						,  __UpperCAmelCase     :						Dict=[2, 3, 4]						,  __UpperCAmelCase     :						List[str]=None						,  )      ->			List[Any]:
							UpperCAmelCase_=       parent
							UpperCAmelCase_=       batch_size
							UpperCAmelCase_=       image_size
							UpperCAmelCase_=       num_channels
							UpperCAmelCase_=       num_stages
							UpperCAmelCase_=       hidden_sizes
							UpperCAmelCase_=       depths
							UpperCAmelCase_=       is_training
							UpperCAmelCase_=       use_labels
							UpperCAmelCase_=       intermediate_size
							UpperCAmelCase_=       hidden_act
							UpperCAmelCase_=       num_labels
							UpperCAmelCase_=       initializer_range
							UpperCAmelCase_=       out_features
							UpperCAmelCase_=       out_indices
							UpperCAmelCase_=       scope




	def   _SCREAMING_SNAKE_CASE		(     self     :						Any					)      ->			Union[str, Any]:
							UpperCAmelCase_=       floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

							UpperCAmelCase_=       self.get_config()
							return config, pixel_values, labels




	def   _SCREAMING_SNAKE_CASE		(     self     :						str					)      ->			List[Any]:
							return ConvNextConfig(
							    num_channels=self.num_channels						,  hidden_sizes=self.hidden_sizes						,  depths=self.depths						,  num_stages=self.num_stages						,  hidden_act=self.hidden_act						,  is_decoder=__UpperCAmelCase						,  initializer_range=self.initializer_range						,  out_features=self.out_features						,  out_indices=self.out_indices						,  num_labels=self.num_labels						,  )




	def   _SCREAMING_SNAKE_CASE		(     self     :						Any						,  __UpperCAmelCase     :						Optional[int]						,  __UpperCAmelCase     :						int						,  __UpperCAmelCase     :						Dict					)      ->			int:
							UpperCAmelCase_=       ConvNextModel(config=__UpperCAmelCase					)
							model.to(__UpperCAmelCase					)
							model.eval()
							UpperCAmelCase_=       model(__UpperCAmelCase					)
							# 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   _SCREAMING_SNAKE_CASE		(     self     :						Union[str, Any]						,  __UpperCAmelCase     :						str						,  __UpperCAmelCase     :						int						,  __UpperCAmelCase     :						Dict					)      ->			List[str]:
							UpperCAmelCase_=       ConvNextForImageClassification(__UpperCAmelCase					)
							model.to(__UpperCAmelCase					)
							model.eval()
							UpperCAmelCase_=       model(__UpperCAmelCase						,  labels=__UpperCAmelCase					)
							self.parent.assertEqual(result.logits.shape						,  (self.batch_size, self.num_labels)					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						int						,  __UpperCAmelCase     :						Tuple						,  __UpperCAmelCase     :						Dict						,  __UpperCAmelCase     :						List[Any]					)      ->			Optional[Any]:
							UpperCAmelCase_=       ConvNextBackbone(config=__UpperCAmelCase					)
							model.to(__UpperCAmelCase					)
							model.eval()
							UpperCAmelCase_=       model(__UpperCAmelCase					)

							# verify hidden states
							self.parent.assertEqual(len(result.feature_maps					)						,  len(config.out_features					)					)
							self.parent.assertListEqual(list(result.feature_maps[0].shape					)						,  [self.batch_size, self.hidden_sizes[1], 4, 4]					)

							# verify channels
							self.parent.assertEqual(len(model.channels					)						,  len(config.out_features					)					)
							self.parent.assertListEqual(model.channels						,  config.hidden_sizes[1:]					)

							# verify backbone works with out_features=None
							UpperCAmelCase_=       None
							UpperCAmelCase_=       ConvNextBackbone(config=__UpperCAmelCase					)
							model.to(__UpperCAmelCase					)
							model.eval()
							UpperCAmelCase_=       model(__UpperCAmelCase					)

							# verify feature maps
							self.parent.assertEqual(len(result.feature_maps					)						,  1					)
							self.parent.assertListEqual(list(result.feature_maps[0].shape					)						,  [self.batch_size, self.hidden_sizes[-1], 1, 1]					)

							# verify channels
							self.parent.assertEqual(len(model.channels					)						,  1					)
							self.parent.assertListEqual(model.channels						,  [config.hidden_sizes[-1]]					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			List[Any]:
							UpperCAmelCase_=       self.prepare_config_and_inputs()
							UpperCAmelCase_,       UpperCAmelCase_,       UpperCAmelCase_=       config_and_inputs
							UpperCAmelCase_=       {"""pixel_values""": pixel_values}
							return config, inputs_dict






@require_torch
class 		lowercase						(			snake_case__			,   snake_case__			,   unittest.TestCase):






	"""simple docstring"""


	a__				: Tuple		       =							(
	    (
	        ConvNextModel,
	        ConvNextForImageClassification,
	        ConvNextBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	a__				: Union[str, Any]		       =							(
	    {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
	    if is_torch_available()
	    else {}
	)

	a__				: Optional[int]		       =							True
	a__				: Optional[Any]		       =							False
	a__				: str		       =							False
	a__				: str		       =							False
	a__				: List[str]		       =							False




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			Union[str, Any]:
							UpperCAmelCase_=       ConvNextModelTester(self					)
							UpperCAmelCase_=       ConfigTester(self						,  config_class=__UpperCAmelCase						,  has_text_modality=__UpperCAmelCase						,  hidden_size=37					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Any:
							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   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			Dict:
							return




	@unittest.skip(reason="""ConvNext does not use inputs_embeds"""					)
	def   _SCREAMING_SNAKE_CASE		(     self     :						Union[str, Any]					)      ->			List[str]:
							pass




	@unittest.skip(reason="""ConvNext does not support input and output embeddings"""					)
	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Any:
							pass




	@unittest.skip(reason="""ConvNext does not use feedforward chunking"""					)
	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			Union[str, Any]:
							pass




	def   _SCREAMING_SNAKE_CASE		(     self     :						List[Any]					)      ->			Tuple:
							UpperCAmelCase_,       UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													UpperCAmelCase_=       model_class(__UpperCAmelCase					)
													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]						,  __UpperCAmelCase					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[int]					)      ->			str:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*__UpperCAmelCase					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			Dict:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*__UpperCAmelCase					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Optional[Any]					)      ->			Dict:
							def check_hidden_states_output(__UpperCAmelCase     :						List[Any]						,  __UpperCAmelCase     :						Optional[Any]						,  __UpperCAmelCase     :						Any					):
													UpperCAmelCase_=       model_class(__UpperCAmelCase					)
													model.to(__UpperCAmelCase					)
													model.eval()

													with torch.no_grad():
																			UpperCAmelCase_=       model(**self._prepare_for_class(__UpperCAmelCase						,  __UpperCAmelCase					)					)

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

													UpperCAmelCase_=       self.model_tester.num_stages
													self.assertEqual(len(__UpperCAmelCase					)						,  expected_num_stages + 1					)

													# ConvNext'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 // 4, self.model_tester.image_size // 4]						,  )

							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(__UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase					)

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

													check_hidden_states_output(__UpperCAmelCase						,  __UpperCAmelCase						,  __UpperCAmelCase					)




	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			Tuple:
							UpperCAmelCase_=       self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*__UpperCAmelCase					)




	@slow
	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			List[Any]:
							for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
													UpperCAmelCase_=       ConvNextModel.from_pretrained(__UpperCAmelCase					)
													self.assertIsNotNone(__UpperCAmelCase					)



def 	__a					(   )				->			Optional[Any]:






						'''simple docstring'''



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






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






	"""simple docstring"""


	@cached_property
	def   _SCREAMING_SNAKE_CASE		(     self     :						Dict					)      ->			List[str]:
							return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""					) if is_vision_available() else None




	@slow
	def   _SCREAMING_SNAKE_CASE		(     self     :						Any					)      ->			List[Any]:
							UpperCAmelCase_=       ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""					).to(__UpperCAmelCase					)

							UpperCAmelCase_=       self.default_image_processor
							UpperCAmelCase_=       prepare_img()
							UpperCAmelCase_=       image_processor(images=__UpperCAmelCase						,  return_tensors="""pt"""					).to(__UpperCAmelCase					)

							# forward pass
							with torch.no_grad():
													UpperCAmelCase_=       model(**__UpperCAmelCase					)

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

							UpperCAmelCase_=       torch.tensor([-0.0_260, -0.4_739, 0.1_911]					).to(__UpperCAmelCase					)

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






@require_torch
class 		lowercase						(			unittest.TestCase			,   snake_case__):






	"""simple docstring"""


	a__				: List[str]		       =							(ConvNextBackbone,) if is_torch_available() else ()
	a__				: Dict		       =							ConvNextConfig

	a__				: Union[str, Any]		       =							False




	def   _SCREAMING_SNAKE_CASE		(     self     :						Tuple					)      ->			Union[str, Any]:
							UpperCAmelCase_=       ConvNextModelTester(self					)




