


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 				A       :
					'''simple docstring'''






					def __init__(self       :		Optional[int] ,   _UpperCAmelCase       :		Any ,   _UpperCAmelCase       :		List[str]=13 ,   _UpperCAmelCase       :		List[Any]=32 ,   _UpperCAmelCase       :		Any=3 ,   _UpperCAmelCase       :		Tuple=4 ,   _UpperCAmelCase       :		Optional[int]=[10, 20, 30, 40] ,   _UpperCAmelCase       :		str=[2, 2, 3, 2] ,   _UpperCAmelCase       :		Any=True ,   _UpperCAmelCase       :		Optional[int]=True ,   _UpperCAmelCase       :		List[str]=37 ,   _UpperCAmelCase       :		Tuple="gelu" ,   _UpperCAmelCase       :		Dict=10 ,   _UpperCAmelCase       :		Optional[Any]=0.02 ,   _UpperCAmelCase       :		int=["stage2", "stage3", "stage4"] ,   _UpperCAmelCase       :		List[Any]=[2, 3, 4] ,   _UpperCAmelCase       :		int=None ,   )		->  List[str]:




							"""simple docstring"""


							lowercase__	     =						parent
							lowercase__	     =						batch_size
							lowercase__	     =						image_size
							lowercase__	     =						num_channels
							lowercase__	     =						num_stages
							lowercase__	     =						hidden_sizes
							lowercase__	     =						depths
							lowercase__	     =						is_training
							lowercase__	     =						use_labels
							lowercase__	     =						intermediate_size
							lowercase__	     =						hidden_act
							lowercase__	     =						num_labels
							lowercase__	     =						initializer_range
							lowercase__	     =						out_features
							lowercase__	     =						out_indices
							lowercase__	     =						scope

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




							"""simple docstring"""


							lowercase__	     =						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]						)

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

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

					def     lowerCamelCase__	(self       :		Any						)		->  Dict:




							"""simple docstring"""


							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     lowerCamelCase__	(self       :		List[str] ,   _UpperCAmelCase       :		Optional[int] ,   _UpperCAmelCase       :		Tuple ,   _UpperCAmelCase       :		int						)		->  Union[str, Any]:




							"""simple docstring"""


							lowercase__	     =						ConvNextModel(config=_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							lowercase__	     =						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     lowerCamelCase__	(self       :		str ,   _UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		List[Any]						)		->  Union[str, Any]:




							"""simple docstring"""


							lowercase__	     =						ConvNextForImageClassification(_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							lowercase__	     =						model(_UpperCAmelCase ,   labels=_UpperCAmelCase						)
							self.parent.assertEqual(result.logits.shape ,   (self.batch_size, self.num_labels)						)

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




							"""simple docstring"""


							lowercase__	     =						ConvNextBackbone(config=_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							lowercase__	     =						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
							lowercase__	     =						None
							lowercase__	     =						ConvNextBackbone(config=_UpperCAmelCase						)
							model.to(_UpperCAmelCase						)
							model.eval()
							lowercase__	     =						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     lowerCamelCase__	(self       :		str						)		->  List[str]:




							"""simple docstring"""


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






@require_torch
class 				A       (			UpperCAmelCase__					,    UpperCAmelCase__					,    unittest.TestCase				):
					'''simple docstring'''






					A__     =					(
					    (
					        ConvNextModel,
					        ConvNextForImageClassification,
					        ConvNextBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					A__     =					(
					    {'''feature-extraction''': ConvNextModel, '''image-classification''': ConvNextForImageClassification}
					    if is_torch_available()
					    else {}
					)

					A__     =					True
					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False

					def     lowerCamelCase__	(self       :		int						)		->  Any:




							"""simple docstring"""


							lowercase__	     =						ConvNextModelTester(self						)
							lowercase__	     =						ConfigTester(self ,   config_class=_UpperCAmelCase ,   has_text_modality=_UpperCAmelCase ,   hidden_size=37						)

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




							"""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       :		Tuple						)		->  Union[str, Any]:




							"""simple docstring"""


							return

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




							"""simple docstring"""


							pass

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




							"""simple docstring"""


							pass

					@unittest.skip(reason="""ConvNext does not use feedforward chunking"""						)
					def     lowerCamelCase__	(self       :		Optional[Any]						)		->  Any:




							"""simple docstring"""


							pass

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




							"""simple docstring"""


							lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_for_common()

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

									lowercase__	     =						["""pixel_values"""]
									self.assertListEqual(arg_names[:1] ,   _UpperCAmelCase						)

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




							"""simple docstring"""


							lowercase__	     =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*_UpperCAmelCase						)

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




							"""simple docstring"""


							lowercase__	     =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*_UpperCAmelCase						)

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




							"""simple docstring"""


							def check_hidden_states_output(_UpperCAmelCase       :		Union[str, Any] ,   _UpperCAmelCase       :		List[Any] ,   _UpperCAmelCase       :		Any						):
									lowercase__	     =						model_class(_UpperCAmelCase						)
									model.to(_UpperCAmelCase						)
									model.eval()

									with torch.no_grad():
											lowercase__	     =						model(**self._prepare_for_class(_UpperCAmelCase ,   _UpperCAmelCase						)						)

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

									lowercase__	     =						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] ,   )

							lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
									lowercase__	     =						True
									check_hidden_states_output(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

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

									check_hidden_states_output(_UpperCAmelCase ,   _UpperCAmelCase ,   _UpperCAmelCase						)

					def     lowerCamelCase__	(self       :		int						)		->  Dict:




							"""simple docstring"""


							lowercase__	     =						self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase						)


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




							"""simple docstring"""


							for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									lowercase__	     =						ConvNextModel.from_pretrained(_UpperCAmelCase						)
									self.assertIsNotNone(_UpperCAmelCase						)






def 					UpperCamelCase   (      )  ->    List[Any]:
		"""simple docstring"""




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



@require_torch
@require_vision
class 				A       (			unittest.TestCase				):
					'''simple docstring'''






					@cached_property
					def     lowerCamelCase__	(self       :		Any						)		->  Dict:




							"""simple docstring"""


							return AutoImageProcessor.from_pretrained("""facebook/convnext-tiny-224"""						) if is_vision_available() else None


					@slow
					def     lowerCamelCase__	(self       :		Tuple						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						ConvNextForImageClassification.from_pretrained("""facebook/convnext-tiny-224"""						).to(_UpperCAmelCase						)

							lowercase__	     =						self.default_image_processor
							lowercase__	     =						prepare_img()
							lowercase__	     =						image_processor(images=_UpperCAmelCase ,   return_tensors="""pt"""						).to(_UpperCAmelCase						)

							# forward pass
							with torch.no_grad():
									lowercase__	     =						model(**_UpperCAmelCase						)

							# verify the logits
							lowercase__	     =						torch.Size((1, 1000)						)
							self.assertEqual(outputs.logits.shape ,   _UpperCAmelCase						)

							lowercase__	     =						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 				A       (			unittest.TestCase					,    UpperCAmelCase__				):
					'''simple docstring'''






					A__     =					(ConvNextBackbone,) if is_torch_available() else ()
					A__     =					ConvNextConfig

					A__     =					False

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




							"""simple docstring"""


							lowercase__	     =						ConvNextModelTester(self						)





import os
import sys

A			:						Tuple        =  os.path.join(os.path.dirname(__file__), 'src')
sys.path.append(SRC_DIR)


from transformers import (
    AutoConfig,
    AutoModel,
    AutoModelForCausalLM,
    AutoModelForMaskedLM,
    AutoModelForQuestionAnswering,
    AutoModelForSequenceClassification,
    AutoTokenizer,
    add_start_docstrings,
)


A			:						Dict        =  [
    'torch',
    'numpy',
    'tokenizers',
    'filelock',
    'requests',
    'tqdm',
    'regex',
    'sentencepiece',
    'sacremoses',
    'importlib_metadata',
    'huggingface_hub',
]






@add_start_docstrings(AutoConfig.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				str       ,       **__magic_name__	:				List[Any]	)  ->    str:
		"""simple docstring"""




		return AutoConfig.from_pretrained(*__magic_name__       ,       **__magic_name__	)






@add_start_docstrings(AutoTokenizer.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				Any       ,       **__magic_name__	:				Optional[Any]	)  ->    Optional[Any]:
		"""simple docstring"""




		return AutoTokenizer.from_pretrained(*__magic_name__       ,       **__magic_name__	)






@add_start_docstrings(AutoModel.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				str       ,       **__magic_name__	:				Optional[Any]	)  ->    Tuple:
		"""simple docstring"""




		return AutoModel.from_pretrained(*__magic_name__       ,       **__magic_name__	)






@add_start_docstrings(AutoModelForCausalLM.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				str       ,       **__magic_name__	:				Tuple	)  ->    List[str]:
		"""simple docstring"""




		return AutoModelForCausalLM.from_pretrained(*__magic_name__       ,       **__magic_name__	)






@add_start_docstrings(AutoModelForMaskedLM.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				Optional[Any]       ,       **__magic_name__	:				Any	)  ->    Optional[int]:
		"""simple docstring"""




		return AutoModelForMaskedLM.from_pretrained(*__magic_name__       ,       **__magic_name__	)






@add_start_docstrings(AutoModelForSequenceClassification.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				Any       ,       **__magic_name__	:				List[str]	)  ->    Union[str, Any]:
		"""simple docstring"""




		return AutoModelForSequenceClassification.from_pretrained(*__magic_name__       ,       **__magic_name__	)







@add_start_docstrings(AutoModelForQuestionAnswering.__doc__	)
def 					UpperCamelCase   (      *__magic_name__	:				Dict       ,       **__magic_name__	:				List[Any]	)  ->    int:
		"""simple docstring"""




		return AutoModelForQuestionAnswering.from_pretrained(*__magic_name__       ,       **__magic_name__	)

