


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



    """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					,   )  ->       Union[str, Any]:
         __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 _a					(			self    )  ->       int:
         __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 _a					(			self    )  ->       Optional[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 _a					(			self					,   A_					,   A_					,   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 // 32, self.image_size // 32)					,   )






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






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



    """simple docstring"""






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

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






    def _a					(			self    )  ->       Tuple:
         __UpperCamelCase    							=ConvNextModelTester(self    )
         __UpperCamelCase    							=ConfigTester(self					,   config_class=A_					,   has_text_modality=A_					,   hidden_size=37    )






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






    @unittest.skip(reason='ConvNext does not use inputs_embeds'    )
    def _a					(			self    )  ->       Optional[int]:
         pass






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






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






    def _a					(			self    )  ->       Union[str, Any]:
         __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 _a					(			self    )  ->       List[str]:
         __UpperCamelCase    							=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A_    )






    def _a					(			self    )  ->       List[Any]:
         __UpperCamelCase    							=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*A_    )






    def _a					(			self    )  ->       Optional[Any]:
         def check_hidden_states_output(A_					,   A_					,   A_    ):
              __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 _a					(			self    )  ->       int:
         __UpperCamelCase    							=self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_image_classification(*A_    )






    @slow
    def _a					(			self    )  ->       Optional[Any]:
         for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              __UpperCamelCase    							=ConvNextModel.from_pretrained(A_    )
              self.assertIsNotNone(A_    )

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






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



    """simple docstring"""






    @cached_property
    def _a					(			self    )  ->       Optional[int]:
         return AutoImageProcessor.from_pretrained('facebook/convnext-tiny-224'    ) if is_vision_available() else None






    @slow
    def _a					(			self    )  ->       int:
         __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, 1000)    )
         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     UpperCAmelCase__       (					unittest.TestCase   ,  A_		):



    """simple docstring"""






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

    UpperCAmelCase__						:		Any      =  False






    def _a					(			self    )  ->       Dict:
         __UpperCamelCase    							=ConvNextModelTester(self    )












def   a_    ( lowerCAmelCase_      :			int	):
   if number < 0:
      raise ValueError('number must not be negative'	)
   return number & (number - 1) == 0


if __name__ == "__main__":
     import doctest

     doctest.testmod()

