
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        _SCREAMING_SNAKE_CASE	:
      def __init__(      self		,						lowerCamelCase		,						lowerCamelCase=13		,						lowerCamelCase=32		,						lowerCamelCase=3		,						lowerCamelCase=4		,						lowerCamelCase=[10, 20, 30, 40]		,						lowerCamelCase=[2, 2, 3, 2]		,						lowerCamelCase=True		,						lowerCamelCase=True		,						lowerCamelCase=37		,						lowerCamelCase="gelu"		,						lowerCamelCase=10		,						lowerCamelCase=0.0_2		,						lowerCamelCase=["stage2", "stage3", "stage4"]		,						lowerCamelCase=[2, 3, 4]		,						lowerCamelCase=None		,						):
          snake_case__    =					parent
          snake_case__    =					batch_size
          snake_case__    =					image_size
          snake_case__    =					num_channels
          snake_case__    =					num_stages
          snake_case__    =					hidden_sizes
          snake_case__    =					depths
          snake_case__    =					is_training
          snake_case__    =					use_labels
          snake_case__    =					intermediate_size
          snake_case__    =					hidden_act
          snake_case__    =					num_labels
          snake_case__    =					initializer_range
          snake_case__    =					out_features
          snake_case__    =					out_indices
          snake_case__    =					scope
      def A_      (      self			):
          snake_case__    =					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]			)

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

          snake_case__    =					self.get_config()

          return config, pixel_values, labels
      def A_      (      self			):
          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=lowerCamelCase		,						initializer_range=self.initializer_range		,						out_features=self.out_features		,						out_indices=self.out_indices		,						num_labels=self.num_labels		,						)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					ConvNextVaModel(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					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 A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					ConvNextVaForImageClassification(lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					model(lowerCamelCase		,						labels=lowerCamelCase			)
          self.parent.assertEqual(result.logits.shape		,						(self.batch_size, self.num_labels)			)
      def A_      (      self		,						lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
          snake_case__    =					ConvNextVaBackbone(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					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
          snake_case__    =					None
          snake_case__    =					ConvNextVaBackbone(config=lowerCamelCase			)
          model.to(lowerCamelCase			)
          model.eval()
          snake_case__    =					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 A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          snake_case__    ,       snake_case__    ,       snake_case__    =					config_and_inputs
          snake_case__    =					{"pixel_values": pixel_values}
          return config, inputs_dict



      def A_      (      self			):
          snake_case__    =					self.prepare_config_and_inputs()
          snake_case__    ,       snake_case__    ,       snake_case__    =					config_and_inputs
          snake_case__    =					{"pixel_values": pixel_values, "labels": labels}
          return config, inputs_dict





@require_torch
class        _SCREAMING_SNAKE_CASE	(   __UpperCamelCase							,       __UpperCamelCase							,       unittest.TestCase			):
      _A    :		Dict     						=  (
          (
              ConvNextVaModel,
              ConvNextVaForImageClassification,
              ConvNextVaBackbone,
          )
          if is_torch_available()
          else ()
      )
      _A    :		Tuple     						=  (
          {'feature-extraction': ConvNextVaModel, 'image-classification': ConvNextVaForImageClassification}
          if is_torch_available()
          else {}
      )

      _A    :		Tuple     						=  False
      _A    :		List[Any]     						=  False
      _A    :		List[Any]     						=  False
      _A    :		Dict     						=  False
      _A    :		Optional[int]     						=  False
      def A_      (      self			):
          snake_case__    =					ConvNextVaModelTester(self			)
          snake_case__    =					ConfigTester(self		,						config_class=lowerCamelCase		,						has_text_modality=lowerCamelCase		,						hidden_size=37			)
      def A_      (      self			):
          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			):
          return
      @unittest.skip(reason="ConvNextV2 does not use inputs_embeds"			)
      def A_      (      self			):
          pass
      @unittest.skip(reason="ConvNextV2 does not support input and output embeddings"			)
      def A_      (      self			):
          pass
      @unittest.skip(reason="ConvNextV2 does not use feedforward chunking"			)
      def A_      (      self			):
          pass
      def A_      (      self			):
          if not self.model_tester.is_training:
              return

          for model_class in self.all_model_classes:
              snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_with_labels()
              snake_case__    =					True

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

              snake_case__    =					model_class(lowerCamelCase			)
              model.to(lowerCamelCase			)
              model.train()
              snake_case__    =					self._prepare_for_class(lowerCamelCase		,						lowerCamelCase		,						return_labels=lowerCamelCase			)
              snake_case__    =					model(**lowerCamelCase			).loss
              loss.backward()
      def A_      (      self			):
          if not self.model_tester.is_training:
              return

          for model_class in self.all_model_classes:
              snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_with_labels()
              snake_case__    =					False
              snake_case__    =					True

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

              snake_case__    =					model_class(lowerCamelCase			)
              model.to(lowerCamelCase			)
              model.gradient_checkpointing_enable()
              model.train()
              snake_case__    =					self._prepare_for_class(lowerCamelCase		,						lowerCamelCase		,						return_labels=lowerCamelCase			)
              snake_case__    =					model(**lowerCamelCase			).loss
              loss.backward()
      def A_      (      self			):
          snake_case__    ,       snake_case__    =					self.model_tester.prepare_config_and_inputs_for_common()

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

              snake_case__    =					["pixel_values"]
              self.assertListEqual(arg_names[:1]		,						lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*lowerCamelCase			)
      def A_      (      self			):
          def check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			):
              snake_case__    =					model_class(lowerCamelCase			)
              model.to(lowerCamelCase			)
              model.eval()

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

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

              snake_case__    =					self.model_tester.num_stages
              self.assertEqual(len(lowerCamelCase			)		,						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__    =					self.model_tester.prepare_config_and_inputs_for_common()

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

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

              check_hidden_states_output(lowerCamelCase		,						lowerCamelCase		,						lowerCamelCase			)
      def A_      (      self			):
          snake_case__    =					self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*lowerCamelCase			)



      @slow
      def A_      (      self			):
          for model_name in CONVNEXTV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
              snake_case__    =					ConvNextVaModel.from_pretrained(lowerCamelCase			)
              self.assertIsNotNone(lowerCamelCase			)





def 						SCREAMING_SNAKE_CASE__     (   ):
    snake_case__    =					Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
    return image





@require_torch
@require_vision
class        _SCREAMING_SNAKE_CASE	(   unittest.TestCase			):
      @cached_property
      def A_      (      self			):
          return AutoImageProcessor.from_pretrained("facebook/convnextv2-tiny-1k-224"			) if is_vision_available() else None



      @slow
      def A_      (      self			):
          snake_case__    =					ConvNextVaForImageClassification.from_pretrained("facebook/convnextv2-tiny-1k-224"			).to(lowerCamelCase			)

          snake_case__    =					self.default_image_processor
          snake_case__    =					prepare_img()
          snake_case__    =					preprocessor(images=lowerCamelCase		,						return_tensors="pt"			).to(lowerCamelCase			)

          # forward pass
          with torch.no_grad():
              snake_case__    =					model(**lowerCamelCase			)

          # verify the logits
          snake_case__    =					torch.Size((1, 10_00)			)
          self.assertEqual(outputs.logits.shape		,						lowerCamelCase			)

          snake_case__    =					torch.tensor([0.9_9_9_6, 0.1_9_6_6, -0.4_3_8_6]			).to(lowerCamelCase			)
          self.assertTrue(torch.allclose(outputs.logits[0, :3]		,						lowerCamelCase		,						atol=1e-4			)			)





import math





def 						SCREAMING_SNAKE_CASE__     (   __lowerCAmelCase     ,		__lowerCAmelCase				):

    if initial_intensity < 0:
        raise ValueError("The value of intensity cannot be negative"				)
        # handling of negative values of initial intensity
    if angle < 0 or angle > 360:
        raise ValueError("In Malus Law, the angle is in the range 0-360 degrees"				)
        # handling of values out of allowed range
    return initial_intensity * (math.cos(math.radians(__lowerCAmelCase				)				) ** 2)


if __name__ == "__main__":
     import doctest

     doctest.testmod(name='''malus_law''')



