



"""simple docstring"""






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 						__lowerCAmelCase				:


					'''simple docstring'''


					def __init__(   self     ,							a     ,							a=13     ,							a=32     ,							a=3     ,							a=4     ,							a=[10, 20, 30, 40]     ,							a=[2, 2, 3, 2]     ,							a=True     ,							a=True     ,							a=37     ,							a="gelu"     ,							a=10     ,							a=0.02     ,							a=["stage2", "stage3", "stage4"]     ,							a=[2, 3, 4]     ,							a=None     ,							):




										"""simple docstring"""





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







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :str										=    floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

										snake_case_    :Dict										=    None
										if self.use_labels:
															snake_case_    :Tuple										=    ids_tensor([self.batch_size]     ,							self.num_labels )

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

										return config, pixel_values, labels







					def 		_a			(   self ):




										"""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 		_a			(   self     ,							a     ,							a     ,							a ):




										"""simple docstring"""





										snake_case_    :Optional[Any]										=    ConvNextVaModel(config=_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.eval()
										snake_case_    :List[str]										=    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 		_a			(   self     ,							a     ,							a     ,							a ):




										"""simple docstring"""





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







					def 		_a			(   self     ,							a     ,							a     ,							a ):




										"""simple docstring"""





										snake_case_    :Dict										=    ConvNextVaBackbone(config=_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.eval()
										snake_case_    :Dict										=    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
										snake_case_    :Dict										=    None
										snake_case_    :Optional[int]										=    ConvNextVaBackbone(config=_UpperCamelCase )
										model.to(_UpperCamelCase )
										model.eval()
										snake_case_    :Optional[Any]										=    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 		_a			(   self ):




										"""simple docstring"""





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







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :List[str]										=    self.prepare_config_and_inputs()
										snake_case_						,	snake_case_						,	snake_case_    :Optional[Any]										=    config_and_inputs
										snake_case_    :List[Any]										=    {"pixel_values": pixel_values, "labels": labels}
										return config, inputs_dict



@require_torch
class 						__lowerCAmelCase				(A__       ,A__       ,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 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :int										=    ConvNextVaModelTester(self )
										snake_case_    :Union[str, Any]										=    ConfigTester(self     ,							config_class=_UpperCamelCase     ,							has_text_modality=_UpperCamelCase     ,							hidden_size=37 )







					def 		_a			(   self ):




										"""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 		_a			(   self ):




										"""simple docstring"""





										return







					@unittest.skip(reason="ConvNextV2 does not use inputs_embeds" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@unittest.skip(reason="ConvNextV2 does not support input and output embeddings" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					@unittest.skip(reason="ConvNextV2 does not use feedforward chunking" )
					def 		_a			(   self ):




										"""simple docstring"""





										pass







					def 		_a			(   self ):




										"""simple docstring"""





										if not self.model_tester.is_training:
															return

										for model_class in self.all_model_classes:
															snake_case_						,	snake_case_    :List[Any]										=    self.model_tester.prepare_config_and_inputs_with_labels()
															snake_case_    :str										=    True

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

															snake_case_    :Any										=    model_class(_UpperCamelCase )
															model.to(_UpperCamelCase )
															model.train()
															snake_case_    :Tuple										=    self._prepare_for_class(_UpperCamelCase     ,							_UpperCamelCase     ,							return_labels=_UpperCamelCase )
															snake_case_    :Optional[Any]										=    model(**_UpperCamelCase ).loss
															loss.backward()







					def 		_a			(   self ):




										"""simple docstring"""





										if not self.model_tester.is_training:
															return

										for model_class in self.all_model_classes:
															snake_case_						,	snake_case_    :str										=    self.model_tester.prepare_config_and_inputs_with_labels()
															snake_case_    :Tuple										=    False
															snake_case_    :List[str]										=    True

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

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







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_						,	snake_case_    :Any										=    self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															snake_case_    :List[Any]										=    model_class(_UpperCamelCase )
															snake_case_    :Union[str, Any]										=    inspect.signature(model.forward )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															snake_case_    :Tuple										=    [*signature.parameters.keys()]

															snake_case_    :List[str]										=    ["pixel_values"]
															self.assertListEqual(arg_names[:1]     ,							_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :List[str]										=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										def check_hidden_states_output(a     ,							a     ,							a ):
															snake_case_    :Optional[Any]										=    model_class(_UpperCamelCase )
															model.to(_UpperCamelCase )
															model.eval()

															with torch.no_grad():
																				snake_case_    :Any										=    model(**self._prepare_for_class(_UpperCamelCase     ,							_UpperCamelCase ) )

															snake_case_    :str										=    outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

															snake_case_    :Dict										=    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]     ,							)

										snake_case_						,	snake_case_    :str										=    self.model_tester.prepare_config_and_inputs_for_common()

										for model_class in self.all_model_classes:
															snake_case_    :Union[str, Any]										=    True
															check_hidden_states_output(_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase )

															# check that output_hidden_states also work using config
															del inputs_dict["output_hidden_states"]
															snake_case_    :Optional[Any]										=    True

															check_hidden_states_output(_UpperCamelCase     ,							_UpperCamelCase     ,							_UpperCamelCase )







					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :int										=    self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_image_classification(*_UpperCamelCase )







					@slow
					def 		_a			(   self ):




										"""simple docstring"""





										for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															snake_case_    :Union[str, Any]										=    ConvNextVaModel.from_pretrained(_UpperCamelCase )
															self.assertIsNotNone(_UpperCamelCase )



def   A   (      ):




					"""simple docstring"""
					snake_case_    :Optional[Any]										=    Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
					return image

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


					'''simple docstring'''


					@cached_property
					def 		_a			(   self ):




										"""simple docstring"""





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







					@slow
					def 		_a			(   self ):




										"""simple docstring"""





										snake_case_    :Optional[int]										=    ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224" ).to(_UpperCamelCase )

										snake_case_    :Dict										=    self.default_image_processor
										snake_case_    :Optional[Any]										=    prepare_img()
										snake_case_    :Optional[int]										=    preprocessor(images=_UpperCamelCase     ,							return_tensors="pt" ).to(_UpperCamelCase )

										# forward pass
										with torch.no_grad():
															snake_case_    :Optional[Any]										=    model(**_UpperCamelCase )

										# verify the logits
										snake_case_    :Dict										=    torch.Size((1, 10_00) )
										self.assertEqual(outputs.logits.shape     ,							_UpperCamelCase )

										snake_case_    :Dict										=    torch.tensor([0.9996, 0.1966, -0.4386] ).to(_UpperCamelCase )
										self.assertTrue(torch.allclose(outputs.logits[0, :3]     ,							_UpperCamelCase     ,							atol=1e-4 ) )








import numpy as np
def      A__       (    SCREAMING_SNAKE_CASE_   :      np.ndarray				,	SCREAMING_SNAKE_CASE_   :      float						)  ->  np.ndarray:






   """simple docstring"""







   return np.where(vector > 0				,	SCREAMING_SNAKE_CASE_				,	(alpha * (np.exp(SCREAMING_SNAKE_CASE_						) - 1))						)


if __name__ == "__main__":
   import doctest

   doctest.testmod()