


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

 '''simple docstring'''

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



 def 		UpperCamelCase__	(      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.type_sequence_label_size   )

       snake_case_			= self.get_config()

       return config, pixel_values, labels



 def 		UpperCamelCase__	(      self   ):
       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						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   ):
       snake_case_			= TFSwinModel(config=_UpperCAmelCase   )
       snake_case_			= model(_UpperCAmelCase   )

       snake_case_			= ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths   ) - 1))
       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						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   ):
       snake_case_			= TFSwinForMaskedImageModeling(config=_UpperCAmelCase   )
       snake_case_			= model(_UpperCAmelCase   )
       self.parent.assertEqual(
           result.logits.shape						, (self.batch_size, self.num_channels, self.image_size, self.image_size)   )

       # test greyscale images
       snake_case_			= 1
       snake_case_			= TFSwinForMaskedImageModeling(_UpperCAmelCase   )

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



 def 		UpperCamelCase__	(      self						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   ):
       snake_case_			= self.type_sequence_label_size
       snake_case_			= TFSwinForImageClassification(_UpperCAmelCase   )
       snake_case_			= model(_UpperCAmelCase						, labels=_UpperCAmelCase   )
       self.parent.assertEqual(result.logits.shape						, (self.batch_size, self.type_sequence_label_size)   )

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





 def 		UpperCamelCase__	(      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







@require_tf
class lowerCAmelCase_		(					lowerCamelCase__   ,		lowerCamelCase__   ,		unittest.TestCase			):

 '''simple docstring'''

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

 __snake_case				=    False
 __snake_case				=    False
 __snake_case				=    False
 __snake_case				=    False



 def 		UpperCamelCase__	(      self   ):
       snake_case_			= TFSwinModelTester(self   )
       snake_case_			= ConfigTester(self						, config_class=_UpperCAmelCase						, embed_dim=37   )



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



 def 		UpperCamelCase__	(      self   ):
       snake_case_			= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_model(*_UpperCAmelCase   )



 def 		UpperCamelCase__	(      self   ):
       snake_case_			= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_masked_image_modeling(*_UpperCAmelCase   )



 def 		UpperCamelCase__	(      self   ):
       snake_case_			= self.model_tester.prepare_config_and_inputs()
       self.model_tester.create_and_check_for_image_classification(*_UpperCAmelCase   )



 @unittest.skip(reason='''Swin does not use inputs_embeds'''   )
 def 		UpperCamelCase__	(      self   ):
       pass



 def 		UpperCamelCase__	(      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(_UpperCAmelCase   )
             self.assertIsInstance(model.get_input_embeddings()						, tf.keras.layers.Layer   )
             snake_case_			= model.get_output_embeddings()
             self.assertTrue(x is None or isinstance(_UpperCAmelCase						, tf.keras.layers.Dense   )   )



 def 		UpperCamelCase__	(      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(_UpperCAmelCase   )
             snake_case_			= inspect.signature(model.call   )
             # 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]						, _UpperCAmelCase   )



 def 		UpperCamelCase__	(      self   ):
       snake_case_			,       snake_case_			= self.model_tester.prepare_config_and_inputs_for_common()
       snake_case_			= True

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

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

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

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

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

             snake_case_			= outputs.attentions

             self.assertEqual(len(_UpperCAmelCase   )						, _UpperCAmelCase   )

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



 def 		UpperCamelCase__	(      self						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   ):
       snake_case_			= model_class(_UpperCAmelCase   )
       snake_case_			= model(**self._prepare_for_class(_UpperCAmelCase						, _UpperCAmelCase   )   )
       snake_case_			= outputs.hidden_states

       snake_case_			= getattr(
           self.model_tester						, '''expected_num_hidden_layers'''						, len(self.model_tester.depths   ) + 1   )
       self.assertEqual(len(_UpperCAmelCase   )						, _UpperCAmelCase   )

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

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

       snake_case_			= outputs.reshaped_hidden_states
       self.assertEqual(len(_UpperCAmelCase   )						, _UpperCAmelCase   )

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

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

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



 def 		UpperCamelCase__	(      self   ):
       snake_case_			,       snake_case_			= self.model_tester.prepare_config_and_inputs_for_common()

       snake_case_			= to_atuple(self.model_tester.image_size   )

       for model_class in self.all_model_classes:
             snake_case_			= True
             self.check_hidden_states_output(_UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   )

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

             self.check_hidden_states_output(_UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase   )



 def 		UpperCamelCase__	(      self   ):
       snake_case_			,       snake_case_			= self.model_tester.prepare_config_and_inputs_for_common()
       snake_case_			= 3

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

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

       for model_class in self.all_model_classes:
             snake_case_			= True
             self.check_hidden_states_output(_UpperCAmelCase						, _UpperCAmelCase						, _UpperCAmelCase						, (padded_height, padded_width)   )

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





 @slow
 def 		UpperCamelCase__	(      self   ):
       for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             snake_case_			= TFSwinModel.from_pretrained(_UpperCAmelCase   )
             self.assertIsNotNone(_UpperCAmelCase   )







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

 '''simple docstring'''

 @cached_property
 def 		UpperCamelCase__	(      self   ):
       return (
           AutoImageProcessor.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''   )
           if is_vision_available()
           else None
       )





 @slow
 def 		UpperCamelCase__	(      self   ):
       snake_case_			= TFSwinForImageClassification.from_pretrained('''microsoft/swin-tiny-patch4-window7-224'''   )
       snake_case_			= self.default_image_processor

       snake_case_			= Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''   )
       snake_case_			= image_processor(images=_UpperCAmelCase						, return_tensors='''tf'''   )

       # forward pass
       snake_case_			= model(_UpperCAmelCase   )

       # verify the logits
       snake_case_			= tf.TensorShape((1, 10_00)   )
       self.assertEqual(outputs.logits.shape						, _UpperCAmelCase   )
       snake_case_			= tf.constant([-0.0_948, -0.6_454, -0.0_921]   )
       self.assertTrue(np.allclose(outputs.logits[0, :3]						, _UpperCAmelCase						, atol=1E-4   )   )



from collections import OrderedDict
from dataclasses import fields
from typing import Any, Tuple

import numpy as np

from .import_utils import is_torch_available






def 			__lowerCAmelCase       (SCREAMING_SNAKE_CASE   )->    Union[str, Any]:




      """simple docstring"""

      if is_torch_available():
            import torch

            if isinstance(SCREAMING_SNAKE_CASE   ,   torch.Tensor   ):
                  return True

      return isinstance(SCREAMING_SNAKE_CASE   ,   np.ndarray   )







class lowerCAmelCase_		(					lowerCamelCase__			):

 '''simple docstring'''

 def 		UpperCamelCase__	(      self   ):
       snake_case_			= fields(self   )

       # Safety and consistency checks
       if not len(_UpperCAmelCase   ):
             raise ValueError(F'''{self.__class__.__name__} has no fields.'''   )

       snake_case_			= getattr(self						, class_fields[0].name   )
       snake_case_			= all(getattr(self						, field.name   ) is None for field in class_fields[1:]   )

       if other_fields_are_none and isinstance(_UpperCAmelCase						, _UpperCAmelCase   ):
             for key, value in first_field.items():
                   snake_case_			= value
       else:
             for field in class_fields:
                   snake_case_			= getattr(self						, field.name   )
                   if v is not None:
                         snake_case_			= v



 def __delitem__(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.'''   )



 def 		UpperCamelCase__	(      self						, *_UpperCAmelCase						, **_UpperCAmelCase   ):
       raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.'''   )



 def __getitem__(      self						, _UpperCAmelCase   ):
       if isinstance(_UpperCAmelCase						, _UpperCAmelCase   ):
             snake_case_			= dict(self.items()   )
             return inner_dict[k]
       else:
             return self.to_tuple()[k]



 def __setattr__(      self						, _UpperCAmelCase						, _UpperCAmelCase   ):
       if name in self.keys() and value is not None:
             # Don't call self.__setitem__ to avoid recursion errors
             super().__setitem__(_UpperCAmelCase						, _UpperCAmelCase   )
       super().__setattr__(_UpperCAmelCase						, _UpperCAmelCase   )



 def __setitem__(      self						, _UpperCAmelCase						, _UpperCAmelCase   ):
       # Will raise a KeyException if needed
       super().__setitem__(_UpperCAmelCase						, _UpperCAmelCase   )
       # Don't call self.__setattr__ to avoid recursion errors
       super().__setattr__(_UpperCAmelCase						, _UpperCAmelCase   )





 def 		UpperCamelCase__	(      self   ):
       return tuple(self[k] for k in self.keys()   )