


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		,							):






     """simple docstring"""





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






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

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

     lowerCamelCase					:   Dict       =							self.get_config()
     return config, pixel_values, labels






   def _snake_case       (						self					):






     """simple docstring"""





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






   def _snake_case       (						self		,							__A		,							__A		,							__A					):






     """simple docstring"""





     lowerCamelCase					:   Dict       =							ConvNextModel(config=__lowerCamelCase					)
     model.to(__lowerCamelCase					)
     model.eval()
     lowerCamelCase					:   Optional[Any]       =							model(__lowerCamelCase					)
     # 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 _snake_case       (						self		,							__A		,							__A		,							__A					):






     """simple docstring"""





     lowerCamelCase					:   Union[str, Any]       =							ConvNextForImageClassification(__lowerCamelCase					)
     model.to(__lowerCamelCase					)
     model.eval()
     lowerCamelCase					:   str       =							model(__lowerCamelCase		,							labels=__lowerCamelCase					)
     self.parent.assertEqual(result.logits.shape		,							(self.batch_size, self.num_labels)					)






   def _snake_case       (						self		,							__A		,							__A		,							__A					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							ConvNextBackbone(config=__lowerCamelCase					)
     model.to(__lowerCamelCase					)
     model.eval()
     lowerCamelCase					:   Optional[int]       =							model(__lowerCamelCase					)

     # 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
     lowerCamelCase					:   List[Any]       =							None
     lowerCamelCase					:   str       =							ConvNextBackbone(config=__lowerCamelCase					)
     model.to(__lowerCamelCase					)
     model.eval()
     lowerCamelCase					:   Tuple       =							model(__lowerCamelCase					)

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






     """simple docstring"""





     lowerCamelCase					:   Dict       =							self.prepare_config_and_inputs()
     lowerCamelCase       ,      lowerCamelCase       ,      lowerCamelCase					:   Dict       =							config_and_inputs
     lowerCamelCase					:   str       =							{"pixel_values": pixel_values}
     return config, inputs_dict



@require_torch
class       UpperCAmelCase_   (   __snake_case						,					__snake_case						,					unittest.TestCase       ):

   '''simple docstring'''




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

   __A					: int							=						True
   __A					: List[str]							=						False
   __A					: Optional[int]							=						False
   __A					: Dict							=						False
   __A					: int							=						False






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Union[str, Any]       =							ConvNextModelTester(self					)
     lowerCamelCase					:   List[Any]       =							ConfigTester(self		,							config_class=__lowerCamelCase		,							has_text_modality=__lowerCamelCase		,							hidden_size=37					)






   def _snake_case       (						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 _snake_case       (						self					):






     """simple docstring"""





     return






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






     """simple docstring"""





     pass






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






     """simple docstring"""





     pass






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






     """simple docstring"""





     pass






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase       ,      lowerCamelCase					:   Dict       =							self.model_tester.prepare_config_and_inputs_for_common()

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

       lowerCamelCase					:   List[Any]       =							["pixel_values"]
       self.assertListEqual(arg_names[:1]		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Optional[Any]       =							self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Tuple       =							self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_backbone(*__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     def check_hidden_states_output(__A		,							__A		,							__A					):
       lowerCamelCase					:   Tuple       =							model_class(__lowerCamelCase					)
       model.to(__lowerCamelCase					)
       model.eval()

       with torch.no_grad():
         lowerCamelCase					:   Any       =							model(**self._prepare_for_class(__lowerCamelCase		,							__lowerCamelCase					)					)

       lowerCamelCase					:   Tuple       =							outputs.encoder_hidden_states if config.is_encoder_decoder else outputs.hidden_states

       lowerCamelCase					:   Optional[int]       =							self.model_tester.num_stages
       self.assertEqual(len(__lowerCamelCase					)		,							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]		,							)

     lowerCamelCase       ,      lowerCamelCase					:   int       =							self.model_tester.prepare_config_and_inputs_for_common()

     for model_class in self.all_model_classes:
       lowerCamelCase					:   Any       =							True
       check_hidden_states_output(__lowerCamelCase		,							__lowerCamelCase		,							__lowerCamelCase					)

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

       check_hidden_states_output(__lowerCamelCase		,							__lowerCamelCase		,							__lowerCamelCase					)






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   List[str]       =							self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_image_classification(*__lowerCamelCase					)






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     for model_name in CONVNEXT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       lowerCamelCase					:   List[str]       =							ConvNextModel.from_pretrained(__lowerCamelCase					)
       self.assertIsNotNone(__lowerCamelCase					)






def 						lowercase_(    ):


  '''simple docstring'''

  lowerCamelCase					:   str       =							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
  return image
@require_torch
@require_vision
class       UpperCAmelCase_   (   unittest.TestCase       ):

   '''simple docstring'''




   @cached_property
   def _snake_case       (						self					):






     """simple docstring"""





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






   @slow
   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   str       =							ConvNextForImageClassification.from_pretrained("facebook/convnext-tiny-224"					).to(__lowerCamelCase					)

     lowerCamelCase					:   List[Any]       =							self.default_image_processor
     lowerCamelCase					:   Optional[Any]       =							prepare_img()
     lowerCamelCase					:   List[str]       =							image_processor(images=__lowerCamelCase		,							return_tensors="pt"					).to(__lowerCamelCase					)

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

     # verify the logits
     lowerCamelCase					:   Optional[Any]       =							torch.Size((1, 1000)					)
     self.assertEqual(outputs.logits.shape		,							__lowerCamelCase					)

     lowerCamelCase					:   Tuple       =							torch.tensor([-0.0260, -0.4739, 0.1911]					).to(__lowerCamelCase					)

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



@require_torch
class       UpperCAmelCase_   (   unittest.TestCase						,					__snake_case       ):

   '''simple docstring'''




   __A					: List[Any]							=						(ConvNextBackbone,) if is_torch_available() else ()
   __A					: str							=						ConvNextConfig

   __A					: int							=						False






   def _snake_case       (						self					):






     """simple docstring"""





     lowerCamelCase					:   Dict       =							ConvNextModelTester(self					)






def 	__a     (      A__			:  float			,  A__			:  float       ):
    if mass < 0:
        raise ValueError("The mass of a body cannot be negative"       )
    return 0.5 * mass * abs(A__       ) * abs(A__       )


if __name__ == "__main__":
    import doctest

    doctest.testmod(verbose=True)