


import inspect
import unittest

from transformers import ConvNextVaConfig
from transformers.models.auto import get_values
from transformers.models.auto.modeling_auto import MODEL_FOR_BACKBONE_MAPPING_NAMES, MODEL_MAPPING_NAMES
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_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 ConvNextVaBackbone, ConvNextVaForImageClassification, ConvNextVaModel
	from transformers.models.convnextva.modeling_convnextva import CONVNEXTV2_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       :		str=13 ,   _UpperCAmelCase       :		List[Any]=32 ,   _UpperCAmelCase       :		List[Any]=3 ,   _UpperCAmelCase       :		List[Any]=4 ,   _UpperCAmelCase       :		Any=[10, 20, 30, 40] ,   _UpperCAmelCase       :		List[str]=[2, 2, 3, 2] ,   _UpperCAmelCase       :		Any=True ,   _UpperCAmelCase       :		List[Any]=True ,   _UpperCAmelCase       :		str=37 ,   _UpperCAmelCase       :		str="gelu" ,   _UpperCAmelCase       :		Optional[Any]=10 ,   _UpperCAmelCase       :		Tuple=0.02 ,   _UpperCAmelCase       :		List[str]=["stage2", "stage3", "stage4"] ,   _UpperCAmelCase       :		Optional[Any]=[2, 3, 4] ,   _UpperCAmelCase       :		Union[str, Any]=None ,   )		->  Dict:




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




							"""simple docstring"""


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




							"""simple docstring"""


							lowercase__	     =						ConvNextVaModel(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       :		int ,   _UpperCAmelCase       :		Any ,   _UpperCAmelCase       :		Optional[Any] ,   _UpperCAmelCase       :		Tuple						)		->  Tuple:




							"""simple docstring"""


							lowercase__	     =						ConvNextVaForImageClassification(_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[int] ,   _UpperCAmelCase       :		Tuple ,   _UpperCAmelCase       :		List[Any] ,   _UpperCAmelCase       :		List[str]						)		->  int:




							"""simple docstring"""


							lowercase__	     =						ConvNextVaBackbone(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__	     =						ConvNextVaBackbone(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       :		Any						)		->  Tuple:




							"""simple docstring"""


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


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




							"""simple docstring"""


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






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






					A__     =					(
					    (
					        ConvNextVaModel,
					        ConvNextVaForImageClassification,
					        ConvNextVaBackbone,
					    )
					    if is_torch_available()
					    else ()
					)
					A__     =					(
					    {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False
					A__     =					False

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




							"""simple docstring"""


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

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




							"""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						)		->  str:




							"""simple docstring"""


							return

					@unittest.skip(reason="""ConvNextV2 does not use inputs_embeds"""						)
					def     lowerCamelCase__	(self       :		Dict						)		->  Tuple:




							"""simple docstring"""


							pass

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




							"""simple docstring"""


							pass

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




							"""simple docstring"""


							pass

					def     lowerCamelCase__	(self       :		Any						)		->  Tuple:




							"""simple docstring"""


							if not self.model_tester.is_training:
									return

							for model_class in self.all_model_classes:
									lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_with_labels()
									lowercase__	     =						True

									if model_class.__name__ in [
									    *get_values(_UpperCAmelCase						),
									    *get_values(_UpperCAmelCase						),
									]:
											continue

									lowercase__	     =						model_class(_UpperCAmelCase						)
									model.to(_UpperCAmelCase						)
									model.train()
									lowercase__	     =						self._prepare_for_class(_UpperCAmelCase ,   _UpperCAmelCase ,   return_labels=_UpperCAmelCase						)
									lowercase__	     =						model(**_UpperCAmelCase						).loss
									loss.backward()

					def     lowerCamelCase__	(self       :		int						)		->  Tuple:




							"""simple docstring"""


							if not self.model_tester.is_training:
									return

							for model_class in self.all_model_classes:
									lowercase__     ,      lowercase__	     =						self.model_tester.prepare_config_and_inputs_with_labels()
									lowercase__	     =						False
									lowercase__	     =						True

									if (
									    model_class.__name__
									    in [*get_values(_UpperCAmelCase						), *get_values(_UpperCAmelCase						)]
									    or not model_class.supports_gradient_checkpointing
									):
											continue

									lowercase__	     =						model_class(_UpperCAmelCase						)
									model.to(_UpperCAmelCase						)
									model.gradient_checkpointing_enable()
									model.train()
									lowercase__	     =						self._prepare_for_class(_UpperCAmelCase ,   _UpperCAmelCase ,   return_labels=_UpperCAmelCase						)
									lowercase__	     =						model(**_UpperCAmelCase						).loss
									loss.backward()

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




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




							"""simple docstring"""


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

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




							"""simple docstring"""


							def check_hidden_states_output(_UpperCAmelCase       :		int ,   _UpperCAmelCase       :		List[str] ,   _UpperCAmelCase       :		Dict						):
									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						)

									# ConvNextV2'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       :		Optional[Any]						)		->  Optional[Any]:




							"""simple docstring"""


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


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




							"""simple docstring"""


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






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




							"""simple docstring"""


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


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




							"""simple docstring"""


							lowercase__	     =						ConvNextVaForImageClassification.from_pretrained("""facebook/convnextv2-tiny-1k-224"""						).to(_UpperCAmelCase						)

							lowercase__	     =						self.default_image_processor
							lowercase__	     =						prepare_img()
							lowercase__	     =						preprocessor(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.9_996, 0.1_966, -0.4_386]						).to(_UpperCAmelCase						)
							self.assertTrue(torch.allclose(outputs.logits[0, :3] ,   _UpperCAmelCase ,   atol=1E-4						)						)





from collections import OrderedDict
from typing import Mapping

from packaging import version

from ...configuration_utils import PretrainedConfig
from ...onnx import OnnxConfig
from ...utils import logging


A			:						Any        =  logging.get_logger(__name__)

A			:						Tuple        =  {
    'sail/poolformer_s12': 'https://huggingface.co/sail/poolformer_s12/resolve/main/config.json',
    # See all PoolFormer models at https://huggingface.co/models?filter=poolformer
}



class 				A       (			UpperCAmelCase__				):
					'''simple docstring'''






					A__     =					'''poolformer'''

					def __init__(self       :		Dict ,   _UpperCAmelCase       :		Union[str, Any]=3 ,   _UpperCAmelCase       :		str=16 ,   _UpperCAmelCase       :		Any=16 ,   _UpperCAmelCase       :		Union[str, Any]=3 ,   _UpperCAmelCase       :		Union[str, Any]=4.0 ,   _UpperCAmelCase       :		str=[2, 2, 6, 2] ,   _UpperCAmelCase       :		int=[64, 128, 320, 512] ,   _UpperCAmelCase       :		Union[str, Any]=[7, 3, 3, 3] ,   _UpperCAmelCase       :		List[Any]=[4, 2, 2, 2] ,   _UpperCAmelCase       :		Union[str, Any]=[2, 1, 1, 1] ,   _UpperCAmelCase       :		Optional[Any]=4 ,   _UpperCAmelCase       :		Dict=0.0 ,   _UpperCAmelCase       :		Union[str, Any]="gelu" ,   _UpperCAmelCase       :		Optional[Any]=True ,   _UpperCAmelCase       :		Tuple=1E-5 ,   _UpperCAmelCase       :		Tuple=0.02 ,   **_UpperCAmelCase       :		Union[str, Any] ,   )		->  Optional[int]:




							"""simple docstring"""


							lowercase__	     =						num_channels
							lowercase__	     =						patch_size
							lowercase__	     =						stride
							lowercase__	     =						padding
							lowercase__	     =						pool_size
							lowercase__	     =						hidden_sizes
							lowercase__	     =						mlp_ratio
							lowercase__	     =						depths
							lowercase__	     =						patch_sizes
							lowercase__	     =						strides
							lowercase__	     =						num_encoder_blocks
							lowercase__	     =						drop_path_rate
							lowercase__	     =						hidden_act
							lowercase__	     =						use_layer_scale
							lowercase__	     =						layer_scale_init_value
							lowercase__	     =						initializer_range
							super().__init__(**_UpperCAmelCase						)






class 				A       (			UpperCAmelCase__				):
					'''simple docstring'''






					A__     =					version.parse('''1.11'''				)

					@property
					def     lowerCamelCase__	(self       :		List[str]						)		->  Mapping[str, Mapping[int, str]]:




							"""simple docstring"""


							return OrderedDict(
							    [
							        ("""pixel_values""", {0: """batch""", 1: """num_channels""", 2: """height""", 3: """width"""}),
							    ]						)


					@property
					def     lowerCamelCase__	(self       :		Dict						)		->  float:




							"""simple docstring"""


							return 2E-3

