
'''simple docstring'''



from __future__ import annotations

import inspect
import unittest

import numpy as np

from transformers import SwinConfig
from transformers.testing_utils import require_tf, require_vision, slow, to_atuple
from transformers.utils import cached_property, is_tf_available, is_vision_available

from ...test_configuration_common import ConfigTester
from ...test_modeling_tf_common import TFModelTesterMixin, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_tf_available():
     import tensorflow as tf

     from transformers.models.swin.modeling_tf_swin import (
         TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST,
         TFSwinForImageClassification,
         TFSwinForMaskedImageModeling,
         TFSwinModel,
     )


if is_vision_available():
     from PIL import Image

     from transformers import AutoImageProcessor

class       _a :





       """simple docstring"""




       def __init__(							self				,							A__				,							A__=13				,							A__=32				,							A__=2				,							A__=3				,							A__=16				,							A__=[1, 2, 1]				,							A__=[2, 2, 4]				,							A__=2				,							A__=2.0				,							A__=True				,							A__=0.0				,							A__=0.0				,							A__=0.1				,							A__="gelu"				,							A__=False				,							A__=True				,							A__=0.02				,							A__=1E-5				,							A__=True				,							A__=None				,							A__=True				,							A__=10				,							A__=8				,							)			->	None:
          _SCREAMING_SNAKE_CASE          = parent
          _SCREAMING_SNAKE_CASE          = batch_size
          _SCREAMING_SNAKE_CASE          = image_size
          _SCREAMING_SNAKE_CASE          = patch_size
          _SCREAMING_SNAKE_CASE          = num_channels
          _SCREAMING_SNAKE_CASE          = embed_dim
          _SCREAMING_SNAKE_CASE          = depths
          _SCREAMING_SNAKE_CASE          = num_heads
          _SCREAMING_SNAKE_CASE          = window_size
          _SCREAMING_SNAKE_CASE          = mlp_ratio
          _SCREAMING_SNAKE_CASE          = qkv_bias
          _SCREAMING_SNAKE_CASE          = hidden_dropout_prob
          _SCREAMING_SNAKE_CASE          = attention_probs_dropout_prob
          _SCREAMING_SNAKE_CASE          = drop_path_rate
          _SCREAMING_SNAKE_CASE          = hidden_act
          _SCREAMING_SNAKE_CASE          = use_absolute_embeddings
          _SCREAMING_SNAKE_CASE          = patch_norm
          _SCREAMING_SNAKE_CASE          = layer_norm_eps
          _SCREAMING_SNAKE_CASE          = initializer_range
          _SCREAMING_SNAKE_CASE          = is_training
          _SCREAMING_SNAKE_CASE          = scope
          _SCREAMING_SNAKE_CASE          = use_labels
          _SCREAMING_SNAKE_CASE          = type_sequence_label_size
          _SCREAMING_SNAKE_CASE          = encoder_stride






       def 				UpperCamelCase (							self					)			->	List[Any]:
          _SCREAMING_SNAKE_CASE          = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]					)

          _SCREAMING_SNAKE_CASE          = None
          if self.use_labels:
             _SCREAMING_SNAKE_CASE          = ids_tensor([self.batch_size]				,							self.type_sequence_label_size					)

          _SCREAMING_SNAKE_CASE          = self.get_config()

          return config, pixel_values, labels






       def 				UpperCamelCase (							self					)			->	Dict:
          return SwinConfig(
              image_size=self.image_size				,							patch_size=self.patch_size				,							num_channels=self.num_channels				,							embed_dim=self.embed_dim				,							depths=self.depths				,							num_heads=self.num_heads				,							window_size=self.window_size				,							mlp_ratio=self.mlp_ratio				,							qkv_bias=self.qkv_bias				,							hidden_dropout_prob=self.hidden_dropout_prob				,							attention_probs_dropout_prob=self.attention_probs_dropout_prob				,							drop_path_rate=self.drop_path_rate				,							hidden_act=self.hidden_act				,							use_absolute_embeddings=self.use_absolute_embeddings				,							path_norm=self.patch_norm				,							layer_norm_eps=self.layer_norm_eps				,							initializer_range=self.initializer_range				,							encoder_stride=self.encoder_stride				,							)






       def 				UpperCamelCase (							self				,							A__				,							A__				,							A__					)			->	Optional[Any]:
          _SCREAMING_SNAKE_CASE          = TFSwinModel(config=A__					)
          _SCREAMING_SNAKE_CASE          = model(A__					)

          _SCREAMING_SNAKE_CASE          = ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths					) - 1))
          _SCREAMING_SNAKE_CASE          = int(config.embed_dim * 2 ** (len(config.depths					) - 1)					)

          self.parent.assertEqual(result.last_hidden_state.shape				,							(self.batch_size, expected_seq_len, expected_dim)					)






       def 				UpperCamelCase (							self				,							A__				,							A__				,							A__					)			->	Optional[int]:
          _SCREAMING_SNAKE_CASE          = TFSwinForMaskedImageModeling(config=A__					)
          _SCREAMING_SNAKE_CASE          = model(A__					)
          self.parent.assertEqual(
              result.logits.shape				,							(self.batch_size, self.num_channels, self.image_size, self.image_size)					)

          # test greyscale images
          _SCREAMING_SNAKE_CASE          = 1
          _SCREAMING_SNAKE_CASE          = TFSwinForMaskedImageModeling(A__					)

          _SCREAMING_SNAKE_CASE          = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
          _SCREAMING_SNAKE_CASE          = model(A__					)
          self.parent.assertEqual(result.logits.shape				,							(self.batch_size, 1, self.image_size, self.image_size)					)






       def 				UpperCamelCase (							self				,							A__				,							A__				,							A__					)			->	Union[str, Any]:
          _SCREAMING_SNAKE_CASE          = self.type_sequence_label_size
          _SCREAMING_SNAKE_CASE          = TFSwinForImageClassification(A__					)
          _SCREAMING_SNAKE_CASE          = model(A__				,							labels=A__					)
          self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.type_sequence_label_size)					)

          # test greyscale images
          _SCREAMING_SNAKE_CASE          = 1
          _SCREAMING_SNAKE_CASE          = TFSwinForImageClassification(A__					)
          _SCREAMING_SNAKE_CASE          = floats_tensor([self.batch_size, 1, self.image_size, self.image_size]					)
          _SCREAMING_SNAKE_CASE          = model(A__					)
          self.parent.assertEqual(result.logits.shape				,							(self.batch_size, self.type_sequence_label_size)					)






       def 				UpperCamelCase (							self					)			->	Tuple:
          _SCREAMING_SNAKE_CASE          = self.prepare_config_and_inputs()
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = config_and_inputs
          _SCREAMING_SNAKE_CASE          = {"""pixel_values""": pixel_values}
          return config, inputs_dict






@require_tf
class       _a (_lowerCamelCase     ,    _lowerCamelCase     ,    unittest.TestCase):





       """simple docstring"""




       SCREAMING_SNAKE_CASE					=     (
           (
               TFSwinModel,
               TFSwinForImageClassification,
               TFSwinForMaskedImageModeling,
           )
           if is_tf_available()
           else ()
       )
       SCREAMING_SNAKE_CASE					=     (
           {'feature-extraction': TFSwinModel, 'image-classification': TFSwinForImageClassification}
           if is_tf_available()
           else {}
       )

       SCREAMING_SNAKE_CASE					=     False
       SCREAMING_SNAKE_CASE					=     False
       SCREAMING_SNAKE_CASE					=     False
       SCREAMING_SNAKE_CASE					=     False






       def 				UpperCamelCase (							self					)			->	List[str]:
          _SCREAMING_SNAKE_CASE          = TFSwinModelTester(self					)
          _SCREAMING_SNAKE_CASE          = ConfigTester(self				,							config_class=A__				,							embed_dim=37					)






       def 				UpperCamelCase (							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 				UpperCamelCase (							self					)			->	Optional[Any]:
          return






       def 				UpperCamelCase (							self					)			->	List[Any]:
          _SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_model(*A__					)






       def 				UpperCamelCase (							self					)			->	Union[str, Any]:
          _SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_masked_image_modeling(*A__					)






       def 				UpperCamelCase (							self					)			->	List[Any]:
          _SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs()
          self.model_tester.create_and_check_for_image_classification(*A__					)






       @unittest.skip(reason="""Swin does not use inputs_embeds"""					)
       def 				UpperCamelCase (							self					)			->	int:
          pass






       def 				UpperCamelCase (							self					)			->	Any:
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs_for_common()

          for model_class in self.all_model_classes:
             _SCREAMING_SNAKE_CASE          = model_class(A__					)
             self.assertIsInstance(model.get_input_embeddings()				,							tf.keras.layers.Layer					)
             _SCREAMING_SNAKE_CASE          = model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(A__				,							tf.keras.layers.Dense					)					)






       def 				UpperCamelCase (							self					)			->	List[Any]:
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs_for_common()

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

             _SCREAMING_SNAKE_CASE          = ["""pixel_values"""]
             self.assertListEqual(arg_names[:1]				,							A__					)






       def 				UpperCamelCase (							self					)			->	Optional[int]:
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs_for_common()
          _SCREAMING_SNAKE_CASE          = True

          for model_class in self.all_model_classes:
             _SCREAMING_SNAKE_CASE          = True
             _SCREAMING_SNAKE_CASE          = False
             _SCREAMING_SNAKE_CASE          = True
             _SCREAMING_SNAKE_CASE          = model_class(A__					)
             _SCREAMING_SNAKE_CASE          = model(**self._prepare_for_class(A__				,							A__					)					)
             _SCREAMING_SNAKE_CASE          = outputs.attentions
             _SCREAMING_SNAKE_CASE          = len(self.model_tester.depths					)
             self.assertEqual(len(A__					)				,							A__					)

             # check that output_attentions also work using config
             del inputs_dict["output_attentions"]
             _SCREAMING_SNAKE_CASE          = True
             _SCREAMING_SNAKE_CASE          = config.window_size**2
             _SCREAMING_SNAKE_CASE          = model_class(A__					)
             _SCREAMING_SNAKE_CASE          = model(**self._prepare_for_class(A__				,							A__					)					)
             _SCREAMING_SNAKE_CASE          = outputs.attentions
             self.assertEqual(len(A__					)				,							A__					)

             self.assertListEqual(
                 list(attentions[0].shape[-3:]					)				,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,							)
             _SCREAMING_SNAKE_CASE          = len(A__					)

             # Check attention is always last and order is fine
             _SCREAMING_SNAKE_CASE          = True
             _SCREAMING_SNAKE_CASE          = True
             _SCREAMING_SNAKE_CASE          = model_class(A__					)
             _SCREAMING_SNAKE_CASE          = model(**self._prepare_for_class(A__				,							A__					)					)

             if hasattr(self.model_tester				,							"""num_hidden_states_types"""					):
                _SCREAMING_SNAKE_CASE          = self.model_tester.num_hidden_states_types
             else:
                # also another +1 for reshaped_hidden_states
                _SCREAMING_SNAKE_CASE          = 2
             self.assertEqual(out_len + added_hidden_states				,							len(A__					)					)

             _SCREAMING_SNAKE_CASE          = outputs.attentions

             self.assertEqual(len(A__					)				,							A__					)

             self.assertListEqual(
                 list(self_attentions[0].shape[-3:]					)				,							[self.model_tester.num_heads[0], window_size_squared, window_size_squared]				,							)






       def 				UpperCamelCase (							self				,							A__				,							A__				,							A__				,							A__					)			->	List[Any]:
          _SCREAMING_SNAKE_CASE          = model_class(A__					)
          _SCREAMING_SNAKE_CASE          = model(**self._prepare_for_class(A__				,							A__					)					)
          _SCREAMING_SNAKE_CASE          = outputs.hidden_states

          _SCREAMING_SNAKE_CASE          = getattr(
              self.model_tester				,							"""expected_num_hidden_layers"""				,							len(self.model_tester.depths					) + 1					)
          self.assertEqual(len(A__					)				,							A__					)

          # Swin has a different seq_length
          _SCREAMING_SNAKE_CASE          = to_atuple(config.patch_size					)

          _SCREAMING_SNAKE_CASE          = (image_size[1] // patch_size[1]) * (image_size[0] // patch_size[0])

          self.assertListEqual(
              list(hidden_states[0].shape[-2:]					)				,							[num_patches, self.model_tester.embed_dim]				,							)

          _SCREAMING_SNAKE_CASE          = outputs.reshaped_hidden_states
          self.assertEqual(len(A__					)				,							A__					)

          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = reshaped_hidden_states[0].shape

          _SCREAMING_SNAKE_CASE          = tf.reshape(reshaped_hidden_states[0]				,							(batch_size, num_channels, height * width)					)
          _SCREAMING_SNAKE_CASE          = tf.transpose(A__				,							(0, 2, 1)					)

          self.assertListEqual(
              list(reshaped_hidden_states.shape[-2:]					)				,							[num_patches, self.model_tester.embed_dim]				,							)






       def 				UpperCamelCase (							self					)			->	Optional[int]:
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs_for_common()

          _SCREAMING_SNAKE_CASE          = to_atuple(self.model_tester.image_size					)

          for model_class in self.all_model_classes:
             _SCREAMING_SNAKE_CASE          = True
             self.check_hidden_states_output(A__				,							A__				,							A__				,							A__					)

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

             self.check_hidden_states_output(A__				,							A__				,							A__				,							A__					)






       def 				UpperCamelCase (							self					)			->	Union[str, Any]:
          _SCREAMING_SNAKE_CASE       ,							_SCREAMING_SNAKE_CASE          = self.model_tester.prepare_config_and_inputs_for_common()
          _SCREAMING_SNAKE_CASE          = 3

          _SCREAMING_SNAKE_CASE          = to_atuple(self.model_tester.image_size					)
          _SCREAMING_SNAKE_CASE          = to_atuple(config.patch_size					)

          _SCREAMING_SNAKE_CASE          = image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
          _SCREAMING_SNAKE_CASE          = image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

          for model_class in self.all_model_classes:
             _SCREAMING_SNAKE_CASE          = True
             self.check_hidden_states_output(A__				,							A__				,							A__				,							(padded_height, padded_width)					)

             # check that output_hidden_states also work using config
             del inputs_dict["output_hidden_states"]
             _SCREAMING_SNAKE_CASE          = True
             self.check_hidden_states_output(A__				,							A__				,							A__				,							(padded_height, padded_width)					)






       @slow
       def 				UpperCamelCase (							self					)			->	List[str]:
          for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             _SCREAMING_SNAKE_CASE          = TFSwinModel.from_pretrained(A__					)
             self.assertIsNotNone(A__					)






@require_vision
@require_tf
class       _a (unittest.TestCase):





       """simple docstring"""




       @cached_property
       def 				UpperCamelCase (							self					)			->	Union[str, Any]:
          return (
              AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					)
              if is_vision_available()
              else None
          )






       @slow
       def 				UpperCamelCase (							self					)			->	Union[str, Any]:
          _SCREAMING_SNAKE_CASE          = TFSwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""					)
          _SCREAMING_SNAKE_CASE          = self.default_image_processor

          _SCREAMING_SNAKE_CASE          = Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""					)
          _SCREAMING_SNAKE_CASE          = image_processor(images=A__				,							return_tensors="""tf"""					)

          # forward pass
          _SCREAMING_SNAKE_CASE          = model(A__					)

          # verify the logits
          _SCREAMING_SNAKE_CASE          = tf.TensorShape((1, 10_00)					)
          self.assertEqual(outputs.logits.shape				,							A__					)
          _SCREAMING_SNAKE_CASE          = tf.constant([-0.0948, -0.6454, -0.0921]					)
          self.assertTrue(np.allclose(outputs.logits[0, :3]				,							A__				,							atol=1E-4					)					)














def 		_UpperCamelCase      (			UpperCamelCase_				:    float			,				UpperCamelCase_				:    float			,				UpperCamelCase_				:    float						)     ->      list[int]:

						"""simple docstring"""



						if hue < 0 or hue > 360:
												raise Exception('hue should be between 0 and 360'						)

						if saturation < 0 or saturation > 1:
												raise Exception('saturation should be between 0 and 1'						)

						if value < 0 or value > 1:
												raise Exception('value should be between 0 and 1'						)

						lowerCAmelCase__			  =  value * saturation
						lowerCAmelCase__			  =  hue / 60
						lowerCAmelCase__			  =  chroma * (1 - abs(hue_section % 2 - 1						))
						lowerCAmelCase__			  =  value - chroma

						if hue_section >= 0 and hue_section <= 1:
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)
												lowerCAmelCase__			  =  round(255 * (match_value)						)
						elif hue_section > 1 and hue_section <= 2:
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
												lowerCAmelCase__			  =  round(255 * (match_value)						)
						elif hue_section > 2 and hue_section <= 3:
												lowerCAmelCase__			  =  round(255 * (match_value)						)
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)
						elif hue_section > 3 and hue_section <= 4:
												lowerCAmelCase__			  =  round(255 * (match_value)						)
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
						elif hue_section > 4 and hue_section <= 5:
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)
												lowerCAmelCase__			  =  round(255 * (match_value)						)
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
						else:
												lowerCAmelCase__			  =  round(255 * (chroma + match_value)						)
												lowerCAmelCase__			  =  round(255 * (match_value)						)
												lowerCAmelCase__			  =  round(255 * (second_largest_component + match_value)						)

						return [red, green, blue]







def 		_UpperCamelCase      (			UpperCamelCase_				:    int			,				UpperCamelCase_				:    int			,				UpperCamelCase_				:    int						)     ->      list[float]:

						"""simple docstring"""



						if red < 0 or red > 255:
												raise Exception('red should be between 0 and 255'						)

						if green < 0 or green > 255:
												raise Exception('green should be between 0 and 255'						)

						if blue < 0 or blue > 255:
												raise Exception('blue should be between 0 and 255'						)

						lowerCAmelCase__			  =  red / 255
						lowerCAmelCase__			  =  green / 255
						lowerCAmelCase__			  =  blue / 255
						lowerCAmelCase__			  =  max(UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  value - min(UpperCamelCase_			,				UpperCamelCase_			,				UpperCamelCase_						)
						lowerCAmelCase__			  =  0 if value == 0 else chroma / value

						if chroma == 0:
												lowerCAmelCase__			  =  0.0
						elif value == float_red:
												lowerCAmelCase__			  =  60 * (0 + (float_green - float_blue) / chroma)
						elif value == float_green:
												lowerCAmelCase__			  =  60 * (2 + (float_blue - float_red) / chroma)
						else:
												lowerCAmelCase__			  =  60 * (4 + (float_red - float_green) / chroma)

						lowerCAmelCase__			  =  (hue + 360) % 360

						return [hue, saturation, value]







def 		_UpperCamelCase      (			UpperCamelCase_				:    list[float]			,				UpperCamelCase_				:    list[float]						)     ->      bool:

						"""simple docstring"""



						lowerCAmelCase__			  =  abs(hsv_a[0] - hsv_a[0]						) < 0.2
						lowerCAmelCase__			  =  abs(hsv_a[1] - hsv_a[1]						) < 0.002
						lowerCAmelCase__			  =  abs(hsv_a[2] - hsv_a[2]						) < 0.002

						return check_hue and check_saturation and check_value





