





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




 """simple docstring"""



 def __init__(       self       :							List[str]							,	__A       :							Dict							,	__A       :							Any=1_3							,	__A       :							Union[str, Any]=3_2							,	__A       :							Dict=3							,	__A       :							List[Any]=4							,	__A       :							str=[1_0, 2_0, 3_0, 4_0]							,	__A       :							Tuple=[2, 2, 3, 2]							,	__A       :							Optional[Any]=True							,	__A       :							Optional[int]=True							,	__A       :							Tuple=3_7							,	__A       :							int="gelu"							,	__A       :							Optional[int]=1_0							,	__A       :							List[Any]=0.02							,	__A       :							Union[str, Any]=["stage2", "stage3", "stage4"]							,	__A       :							Dict=[2, 3, 4]							,	__A       :							Union[str, Any]=None							,	):
        __UpperCamelCase       =  parent
        __UpperCamelCase       =  batch_size
        __UpperCamelCase       =  image_size
        __UpperCamelCase       =  num_channels
        __UpperCamelCase       =  num_stages
        __UpperCamelCase       =  hidden_sizes
        __UpperCamelCase       =  depths
        __UpperCamelCase       =  is_training
        __UpperCamelCase       =  use_labels
        __UpperCamelCase       =  intermediate_size
        __UpperCamelCase       =  hidden_act
        __UpperCamelCase       =  num_labels
        __UpperCamelCase       =  initializer_range
        __UpperCamelCase       =  out_features
        __UpperCamelCase       =  out_indices
        __UpperCamelCase       =  scope






 def        _lowerCamelCase					(       self       :							str	):
        __UpperCamelCase       =  floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

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

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






 def        _lowerCamelCase					(       self       :							int	):
        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=A_							,	initializer_range=self.initializer_range							,	out_features=self.out_features							,	out_indices=self.out_indices							,	num_labels=self.num_labels							,	)






 def        _lowerCamelCase					(       self       :							Tuple							,	__A       :							List[Any]							,	__A       :							int							,	__A       :							List[Any]	):
        __UpperCamelCase       =  ConvNextModel(config=A_	)
        model.to(A_	)
        model.eval()
        __UpperCamelCase       =  model(A_	)
        # 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 // 3_2, self.image_size // 3_2)							,	)






 def        _lowerCamelCase					(       self       :							Tuple							,	__A       :							Union[str, Any]							,	__A       :							Optional[int]							,	__A       :							Dict	):
        __UpperCamelCase       =  ConvNextForImageClassification(A_	)
        model.to(A_	)
        model.eval()
        __UpperCamelCase       =  model(A_							,	labels=A_	)
        self.parent.assertEqual(result.logits.shape							,	(self.batch_size, self.num_labels)	)






 def        _lowerCamelCase					(       self       :							Any							,	__A       :							List[str]							,	__A       :							Union[str, Any]							,	__A       :							Union[str, Any]	):
        __UpperCamelCase       =  ConvNextBackbone(config=A_	)
        model.to(A_	)
        model.eval()
        __UpperCamelCase       =  model(A_	)

        # 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
        __UpperCamelCase       =  None
        __UpperCamelCase       =  ConvNextBackbone(config=A_	)
        model.to(A_	)
        model.eval()
        __UpperCamelCase       =  model(A_	)

        # 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       :							Optional[Any]	):
        __UpperCamelCase       =  self.prepare_config_and_inputs()
        __UpperCamelCase       ,						__UpperCamelCase       ,						__UpperCamelCase       =  config_and_inputs
        __UpperCamelCase       =  {'pixel_values': pixel_values}
        return config, inputs_dict






@require_torch
class      snake_case     (    A_			,       A_			,       unittest.TestCase       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					Optional[Any]					=(
     (
         ConvNextModel,
         ConvNextForImageClassification,
         ConvNextBackbone,
     )
     if is_torch_available()
     else ()
 )
 SCREAMING_SNAKE_CASE_	:					Dict					=(
     {"feature-extraction": ConvNextModel, "image-classification": ConvNextForImageClassification}
     if is_torch_available()
     else {}
 )

 SCREAMING_SNAKE_CASE_	:					Dict					=True
 SCREAMING_SNAKE_CASE_	:					Tuple					=False
 SCREAMING_SNAKE_CASE_	:					Optional[Any]					=False
 SCREAMING_SNAKE_CASE_	:					List[Any]					=False
 SCREAMING_SNAKE_CASE_	:					str					=False






 def        _lowerCamelCase					(       self       :							Tuple	):
        __UpperCamelCase       =  ConvNextModelTester(self	)
        __UpperCamelCase       =  ConfigTester(self							,	config_class=A_							,	has_text_modality=A_							,	hidden_size=3_7	)






 def        _lowerCamelCase					(       self       :							Dict	):
        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       :							Dict	):
        return






 @unittest.skip(reason='ConvNext does not use inputs_embeds'	)
 def        _lowerCamelCase					(       self       :							List[str]	):
        pass






 @unittest.skip(reason='ConvNext does not support input and output embeddings'	)
 def        _lowerCamelCase					(       self       :							Optional[int]	):
        pass






 @unittest.skip(reason='ConvNext does not use feedforward chunking'	)
 def        _lowerCamelCase					(       self       :							List[Any]	):
        pass






 def        _lowerCamelCase					(       self       :							Tuple	):
        __UpperCamelCase       ,						__UpperCamelCase       =  self.model_tester.prepare_config_and_inputs_for_common()

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

               __UpperCamelCase       =  ['pixel_values']
               self.assertListEqual(arg_names[:1]							,	A_	)






 def        _lowerCamelCase					(       self       :							str	):
        __UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_model(*A_	)






 def        _lowerCamelCase					(       self       :							str	):
        __UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_backbone(*A_	)






 def        _lowerCamelCase					(       self       :							Any	):
        def check_hidden_states_output(__A       :							Optional[int]							,	__A       :							Optional[int]							,	__A       :							List[str]	):
               __UpperCamelCase       =  model_class(A_	)
               model.to(A_	)
               model.eval()

               with torch.no_grad():
                      __UpperCamelCase       =  model(**self._prepare_for_class(A_							,	A_	)	)

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

               __UpperCamelCase       =  self.model_tester.num_stages
               self.assertEqual(len(A_	)							,	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]							,	)

        __UpperCamelCase       ,						__UpperCamelCase       =  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
               __UpperCamelCase       =  True
               check_hidden_states_output(A_							,	A_							,	A_	)

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

               check_hidden_states_output(A_							,	A_							,	A_	)






 def        _lowerCamelCase					(       self       :							Tuple	):
        __UpperCamelCase       =  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_for_image_classification(*A_	)






 @slow
 def        _lowerCamelCase					(       self       :							Union[str, Any]	):
        for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
               __UpperCamelCase       =  ConvNextModel.from_pretrained(A_	)
               self.assertIsNotNone(A_	)






def 				lowercase__   (   ) ->      Tuple:



       """simple docstring"""






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

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




 """simple docstring"""



 @cached_property
 def        _lowerCamelCase					(       self       :							List[Any]	):
        return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224'	) if is_vision_available() else None






 @slow
 def        _lowerCamelCase					(       self       :							str	):
        __UpperCamelCase       =  ConvNextForImageClassification.from_pretrained('facebook/convnext-tiny-224'	).to(A_	)

        __UpperCamelCase       =  self.default_image_processor
        __UpperCamelCase       =  prepare_img()
        __UpperCamelCase       =  image_processor(images=A_							,	return_tensors='pt'	).to(A_	)

        # forward pass
        with torch.no_grad():
               __UpperCamelCase       =  model(**A_	)

        # verify the logits
        __UpperCamelCase       =  torch.Size((1, 1_0_0_0)	)
        self.assertEqual(outputs.logits.shape							,	A_	)

        __UpperCamelCase       =  torch.tensor([-0.0260, -0.4739, 0.1911]	).to(A_	)

        self.assertTrue(torch.allclose(outputs.logits[0, :3]							,	A_							,	atol=1e-4	)	)






@require_torch
class      snake_case     (    unittest.TestCase			,       A_       ):




 """simple docstring"""



 SCREAMING_SNAKE_CASE_	:					Optional[Any]					=(ConvNextBackbone,) if is_torch_available() else ()
 SCREAMING_SNAKE_CASE_	:					Optional[Any]					=ConvNextConfig

 SCREAMING_SNAKE_CASE_	:					Any					=False






 def        _lowerCamelCase					(       self       :							Optional[int]	):
        __UpperCamelCase       =  ConvNextModelTester(self	)




from numpy import exp, pi, sqrt

def 						_UpperCAmelCase				(			SCREAMING_SNAKE_CASE__			:					Tuple			,     SCREAMING_SNAKE_CASE__			:					float = 0.0			,     SCREAMING_SNAKE_CASE__			:					float = 1.0				):
     return 1 / sqrt(2 * pi * sigma**2				) * exp(-((x - mu) ** 2) / (2 * sigma**2)				)


if __name__ == "__main__":
   import doctest

   doctest.testmod()





