


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							:

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





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





									"""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:	List[str]							)			->   int:





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





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





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





									"""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:	int							)			->   Optional[Any]:





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





									"""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			):
							_lowercase	:			Optional[Any]        = (
							    (
							        ConvNextVaModel,
							        ConvNextVaForImageClassification,
							        ConvNextVaBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							_lowercase	:			List[str]        = (
							    {'''feature-extraction''': ConvNextVaModel, '''image-classification''': ConvNextVaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							_lowercase	:			Union[str, Any]        = False
							_lowercase	:			Any        = False
							_lowercase	:			str        = False
							_lowercase	:			Tuple        = False
							_lowercase	:			Dict        = False

							def       lowerCamelCase_ (							self:	Any							)			->   int:





									"""simple docstring"""







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

							def       lowerCamelCase_ (							self:	Any							)			->   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:	Optional[Any]							)			->   Union[str, Any]:





									"""simple docstring"""







									return

							@unittest.skip(reason='''ConvNextV2 does not use inputs_embeds'''							)
							def       lowerCamelCase_ (							self:	Any							)			->   Union[str, Any]:





									"""simple docstring"""







									pass

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





									"""simple docstring"""







									pass

							@unittest.skip(reason='''ConvNextV2 does not use feedforward chunking'''							)
							def       lowerCamelCase_ (							self:	Optional[int]							)			->   int:





									"""simple docstring"""







									pass

							def       lowerCamelCase_ (							self:	str							)			->   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:	Union[str, Any]							)			->   Union[str, Any]:





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





									"""simple docstring"""







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

							def       lowerCamelCase_ (							self:	str							)			->   str:





									"""simple docstring"""







									def check_hidden_states_output(UpperCamelCase_:	Optional[int]    ,						UpperCamelCase_:	Dict    ,						UpperCamelCase_:	Union[str, 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							)

											# 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[int]							)			->   int:





									"""simple docstring"""







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


							@slow
							def       lowerCamelCase_ (							self:	List[Any]							)			->   int:





									"""simple docstring"""







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


		"""simple docstring"""




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


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

							@cached_property
							def       lowerCamelCase_ (							self:	Dict							)			->   Dict:





									"""simple docstring"""







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


							@slow
							def       lowerCamelCase_ (							self:	Union[str, Any]							)			->   Tuple:





									"""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, 1_000)							)
									self.assertEqual(outputs.logits.shape    ,						UpperCamelCase_							)

									lowercase__            =      torch.tensor([0.9996, 0.1966, -0.4386]							).to(UpperCamelCase_							)
									self.assertTrue(torch.allclose(outputs.logits[0, :3]    ,						UpperCamelCase_    ,						atol=1E-4							)							)






from ..utils import DummyObject, requires_backends


class        _a							(			metaclass=UpperCamelCase__			):
							_lowercase	:			Any        = ['''torch''', '''scipy''']

							def __init__(							self:	int    ,						*UpperCamelCase_:	Any    ,						**UpperCamelCase_:	Optional[Any]							)			->   List[str]:





									"""simple docstring"""







									requires_backends(self    ,						['''torch''', '''scipy''']							)

							@classmethod
							def       lowerCamelCase_ (							cls:	Optional[int]    ,						*UpperCamelCase_:	Any    ,						**UpperCamelCase_:	List[Any]							)			->   int:





									"""simple docstring"""







									requires_backends(cls    ,						['''torch''', '''scipy''']							)


							@classmethod
							def       lowerCamelCase_ (							cls:	Any    ,						*UpperCamelCase_:	Any    ,						**UpperCamelCase_:	Dict							)			->   Optional[int]:





									"""simple docstring"""







									requires_backends(cls    ,						['''torch''', '''scipy''']							)


