





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 ,  lowercase ,  lowercase=13 ,  lowercase=32 ,  lowercase=3 ,  lowercase=4 ,  lowercase=[10, 20, 30, 40] ,  lowercase=[2, 2, 3, 2] ,  lowercase=True ,  lowercase=True ,  lowercase=37 ,  lowercase="gelu" ,  lowercase=10 ,  lowercase=0.02 ,  lowercase=["stage2", "stage3", "stage4"] ,  lowercase=[2, 3, 4] ,  lowercase=None ,  )      ->						Any:







										'''simple docstring'''

										a__						:     int			=    parent
										a__						:     Optional[Any]			=    batch_size
										a__						:     str			=    image_size
										a__						:     List[str]			=    num_channels
										a__						:     Tuple			=    num_stages
										a__						:     List[Any]			=    hidden_sizes
										a__						:     Optional[Any]			=    depths
										a__						:     Dict			=    is_training
										a__						:     Optional[Any]			=    use_labels
										a__						:     List[Any]			=    intermediate_size
										a__						:     Any			=    hidden_act
										a__						:     str			=    num_labels
										a__						:     List[str]			=    initializer_range
										a__						:     str			=    out_features
										a__						:     str			=    out_indices
										a__						:     Union[str, Any]			=    scope

			def 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

										a__						:     List[Any]			=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

										a__						:     Any			=    None
										if self.use_labels:
																	a__						:     List[str]			=    ids_tensor([self.batch_size] ,  self.num_labels)

										a__						:     Optional[int]			=    self.get_config()

										return config, pixel_values, labels

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







										'''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=lowercase ,  initializer_range=self.initializer_range ,  out_features=self.out_features ,  out_indices=self.out_indices ,  num_labels=self.num_labels ,  )

			def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						Union[str, Any]:







										'''simple docstring'''

										a__						:     List[Any]			=    ConvNextVaModel(config=lowercase)
										model.to(lowercase)
										model.eval()
										a__						:     int			=    model(lowercase)
										# 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 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						Optional[int]:







										'''simple docstring'''

										a__						:     Optional[Any]			=    ConvNextVaForImageClassification(lowercase)
										model.to(lowercase)
										model.eval()
										a__						:     Any			=    model(lowercase ,  labels=lowercase)
										self.parent.assertEqual(result.logits.shape ,  (self.batch_size, self.num_labels))

			def 							__lowercase		( self ,  lowercase ,  lowercase ,  lowercase)      ->						Optional[Any]:







										'''simple docstring'''

										a__						:     Union[str, Any]			=    ConvNextVaBackbone(config=lowercase)
										model.to(lowercase)
										model.eval()
										a__						:     List[str]			=    model(lowercase)

										# 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
										a__						:     List[Any]			=    None
										a__						:     Union[str, Any]			=    ConvNextVaBackbone(config=lowercase)
										model.to(lowercase)
										model.eval()
										a__						:     Dict			=    model(lowercase)

										# 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 							__lowercase		( self)      ->						int:







										'''simple docstring'''

										a__						:     str			=    self.prepare_config_and_inputs()
										a__						:     Tuple			=    config_and_inputs
										a__						:     Tuple			=    {'pixel_values': pixel_values}
										return config, inputs_dict

			def 							__lowercase		( self)      ->						int:







										'''simple docstring'''

										a__						:     Optional[int]			=    self.prepare_config_and_inputs()
										a__						:     str			=    config_and_inputs
										a__						:     Tuple			=    {'pixel_values': pixel_values, 'labels': labels}
										return config, inputs_dict





@require_torch
class 			A__   (							__UpperCAmelCase			,  __UpperCAmelCase			,  unittest.TestCase     ):




			"""simple docstring"""



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

			__A       :    List[str]	  =  False
			__A       :    List[str]	  =  False
			__A       :    int	  =  False
			__A       :    Tuple	  =  False
			__A       :    Optional[int]	  =  False

			def 							__lowercase		( self)      ->						Optional[Any]:







										'''simple docstring'''

										a__						:     Dict			=    ConvNextVaModelTester(self)
										a__						:     List[str]			=    ConfigTester(self ,  config_class=lowercase ,  has_text_modality=lowercase ,  hidden_size=37)

			def 							__lowercase		( self)      ->						Tuple:







										'''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 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

										return

			@unittest.skip(reason='ConvNextV2 does not use inputs_embeds')
			def 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

										pass

			@unittest.skip(reason='ConvNextV2 does not support input and output embeddings')
			def 							__lowercase		( self)      ->						Optional[int]:







										'''simple docstring'''

										pass

			@unittest.skip(reason='ConvNextV2 does not use feedforward chunking')
			def 							__lowercase		( self)      ->						Dict:







										'''simple docstring'''

										pass

			def 							__lowercase		( self)      ->						Dict:







										'''simple docstring'''

										if not self.model_tester.is_training:
																	return

										for model_class in self.all_model_classes:
																	a__						:     Tuple			=    self.model_tester.prepare_config_and_inputs_with_labels()
																	a__						:     Union[str, Any]			=    True

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

																	a__						:     Optional[int]			=    model_class(lowercase)
																	model.to(lowercase)
																	model.train()
																	a__						:     Dict			=    self._prepare_for_class(lowercase ,  lowercase ,  return_labels=lowercase)
																	a__						:     Optional[int]			=    model(**lowercase).loss
																	loss.backward()

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







										'''simple docstring'''

										if not self.model_tester.is_training:
																	return

										for model_class in self.all_model_classes:
																	a__						:     int			=    self.model_tester.prepare_config_and_inputs_with_labels()
																	a__						:     Optional[int]			=    False
																	a__						:     Tuple			=    True

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

																	a__						:     Optional[Any]			=    model_class(lowercase)
																	model.to(lowercase)
																	model.gradient_checkpointing_enable()
																	model.train()
																	a__						:     Any			=    self._prepare_for_class(lowercase ,  lowercase ,  return_labels=lowercase)
																	a__						:     int			=    model(**lowercase).loss
																	loss.backward()

			def 							__lowercase		( self)      ->						Optional[Any]:







										'''simple docstring'''

										a__						:     List[str]			=    self.model_tester.prepare_config_and_inputs_for_common()

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

																	a__						:     Dict			=    ['pixel_values']
																	self.assertListEqual(arg_names[:1] ,  lowercase)

			def 							__lowercase		( self)      ->						Dict:







										'''simple docstring'''

										a__						:     List[str]			=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowercase)

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







										'''simple docstring'''

										def check_hidden_states_output(lowercase ,  lowercase ,  lowercase):
																	a__						:     Dict			=    model_class(lowercase)
																	model.to(lowercase)
																	model.eval()

																	with torch.no_grad():
																								a__						:     List[str]			=    model(**self._prepare_for_class(lowercase ,  lowercase))

																	a__						:     int			=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

																	a__						:     Dict			=    self.model_tester.num_stages
																	self.assertEqual(len(lowercase) ,  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] ,  )

										a__						:     List[str]			=    self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
																	a__						:     Optional[Any]			=    True
																	check_hidden_states_output(lowercase ,  lowercase ,  lowercase)

																	# check that output_hidden_states also work using config
																	del inputs_dict["output_hidden_states"]
																	a__						:     Dict			=    True

																	check_hidden_states_output(lowercase ,  lowercase ,  lowercase)

			def 							__lowercase		( self)      ->						Optional[Any]:







										'''simple docstring'''

										a__						:     str			=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*lowercase)

			@slow
			def 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	a__						:     str			=    ConvNextVaModel.from_pretrained(lowercase)
																	self.assertIsNotNone(lowercase)



def A_     (		)  ->		str:
							a__						:     Dict			=    Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'    )
							return image





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




			"""simple docstring"""



			@cached_property
			def 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

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

			@slow
			def 							__lowercase		( self)      ->						Tuple:







										'''simple docstring'''

										a__						:     int			=    ConvNextVaForImageClassification.from_pretrained('facebook/convnextv2-tiny-1k-224').to(lowercase)

										a__						:     Tuple			=    self.default_image_processor
										a__						:     str			=    prepare_img()
										a__						:     Union[str, Any]			=    preprocessor(images=lowercase ,  return_tensors='pt').to(lowercase)

										# forward pass
										with torch.no_grad():
																	a__						:     List[Any]			=    model(**lowercase)

										# verify the logits
										a__						:     Dict			=    torch.Size((1, 1000))
										self.assertEqual(outputs.logits.shape ,  lowercase)

										a__						:     Tuple			=    torch.tensor([0.99_96, 0.19_66, -0.43_86]).to(lowercase)
										self.assertTrue(torch.allclose(outputs.logits[0, :3] ,  lowercase ,  atol=1e-4))









def A_     (		A__		,				A__		,				A__    )  ->		float:
       if principal <= 0:
              raise Exception('Principal borrowed must be > 0'    )
       if rate_per_annum < 0:
              raise Exception('Rate of interest must be >= 0'    )
       if years_to_repay <= 0 or not isinstance(A__		,				A__    ):
              raise Exception('Years to repay must be an integer > 0'    )

       # Yearly rate is divided by 12 to get monthly rate
       a__						:     str			=    rate_per_annum / 12

       # Years to repay is multiplied by 12 to get number of payments as payment is monthly
       a__						:     List[Any]			=    years_to_repay * 12

       return (
           principal
           * rate_per_month
           * (1 + rate_per_month) ** number_of_payments
           / ((1 + rate_per_month) ** number_of_payments - 1)
       )


if __name__ == "__main__":
    import doctest

    doctest.testmod()


