


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      __snake_case				:
					def __init__(						self       :						Any	,      _lowerCAmelCase       :						Dict	,      _lowerCAmelCase       :						Dict=1_3	,      _lowerCAmelCase       :						Union[str, Any]=3_2	,      _lowerCAmelCase       :						Optional[Any]=2	,      _lowerCAmelCase       :						Optional[Any]=3	,      _lowerCAmelCase       :						Dict=1_6	,      _lowerCAmelCase       :						Dict=[1, 2, 1]	,      _lowerCAmelCase       :						Dict=[2, 2, 4]	,      _lowerCAmelCase       :						List[Any]=2	,      _lowerCAmelCase       :						Optional[int]=2.0	,      _lowerCAmelCase       :						Dict=True	,      _lowerCAmelCase       :						Tuple=0.0	,      _lowerCAmelCase       :						Any=0.0	,      _lowerCAmelCase       :						Optional[int]=0.1	,      _lowerCAmelCase       :						Optional[Any]="gelu"	,      _lowerCAmelCase       :						Union[str, Any]=False	,      _lowerCAmelCase       :						int=True	,      _lowerCAmelCase       :						Any=0.02	,      _lowerCAmelCase       :						Any=1E-5	,      _lowerCAmelCase       :						Optional[int]=True	,      _lowerCAmelCase       :						int=None	,      _lowerCAmelCase       :						List[str]=True	,      _lowerCAmelCase       :						Dict=1_0	,      _lowerCAmelCase       :						Optional[int]=8	,      )							->					None:



											'''simple docstring'''





											__magic_name__					=      parent
											__magic_name__					=      batch_size
											__magic_name__					=      image_size
											__magic_name__					=      patch_size
											__magic_name__					=      num_channels
											__magic_name__					=      embed_dim
											__magic_name__					=      depths
											__magic_name__					=      num_heads
											__magic_name__					=      window_size
											__magic_name__					=      mlp_ratio
											__magic_name__					=      qkv_bias
											__magic_name__					=      hidden_dropout_prob
											__magic_name__					=      attention_probs_dropout_prob
											__magic_name__					=      drop_path_rate
											__magic_name__					=      hidden_act
											__magic_name__					=      use_absolute_embeddings
											__magic_name__					=      patch_norm
											__magic_name__					=      layer_norm_eps
											__magic_name__					=      initializer_range
											__magic_name__					=      is_training
											__magic_name__					=      scope
											__magic_name__					=      use_labels
											__magic_name__					=      type_sequence_label_size
											__magic_name__					=      encoder_stride
					def 	a			(						self       :						str  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

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

											__magic_name__					=      self.get_config()

											return config, pixel_values, labels
					def 	a			(						self       :						Union[str, Any]  )							->					Dict:



											'''simple docstring'''





											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 	a			(						self       :						Dict	,      _lowerCAmelCase       :						int	,      _lowerCAmelCase       :						List[str]	,      _lowerCAmelCase       :						Union[str, Any]  )							->					str:



											'''simple docstring'''





											__magic_name__					=      TFSwinModel(config=_lowerCAmelCase  )
											__magic_name__					=      model(_lowerCAmelCase  )

											__magic_name__					=      ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
											__magic_name__					=      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 	a			(						self       :						Tuple	,      _lowerCAmelCase       :						str	,      _lowerCAmelCase       :						Optional[int]	,      _lowerCAmelCase       :						str  )							->					Tuple:



											'''simple docstring'''





											__magic_name__					=      TFSwinForMaskedImageModeling(config=_lowerCAmelCase  )
											__magic_name__					=      model(_lowerCAmelCase  )
											self.parent.assertEqual(
											    result.logits.shape	,      (self.batch_size, self.num_channels, self.image_size, self.image_size)  )

											# test greyscale images
											__magic_name__					=      1
											__magic_name__					=      TFSwinForMaskedImageModeling(_lowerCAmelCase  )

											__magic_name__					=      floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
											__magic_name__					=      model(_lowerCAmelCase  )
											self.parent.assertEqual(result.logits.shape	,      (self.batch_size, 1, self.image_size, self.image_size)  )
					def 	a			(						self       :						List[str]	,      _lowerCAmelCase       :						int	,      _lowerCAmelCase       :						Optional[int]	,      _lowerCAmelCase       :						Tuple  )							->					int:



											'''simple docstring'''





											__magic_name__					=      self.type_sequence_label_size
											__magic_name__					=      TFSwinForImageClassification(_lowerCAmelCase  )
											__magic_name__					=      model(_lowerCAmelCase	,      labels=_lowerCAmelCase  )
											self.parent.assertEqual(result.logits.shape	,      (self.batch_size, self.type_sequence_label_size)  )

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







					def 	a			(						self       :						int  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      self.prepare_config_and_inputs()
											__magic_name__		,      __magic_name__		,      __magic_name__					=      config_and_inputs
											__magic_name__					=      {'pixel_values': pixel_values}
											return config, inputs_dict







@require_tf
class      __snake_case				(   _UpperCAmelCase	,      _UpperCAmelCase	,      unittest.TestCase):
					SCREAMING_SNAKE_CASE_		:       Any								=			(
					    (
					        TFSwinModel,
					        TFSwinForImageClassification,
					        TFSwinForMaskedImageModeling,
					    )
					    if is_tf_available()
					    else ()
					)
					SCREAMING_SNAKE_CASE_		:       List[str]								=			(
					    {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
					    if is_tf_available()
					    else {}
					)

					SCREAMING_SNAKE_CASE_		:       Dict								=			False
					SCREAMING_SNAKE_CASE_		:       int								=			False
					SCREAMING_SNAKE_CASE_		:       Optional[Any]								=			False
					SCREAMING_SNAKE_CASE_		:       Dict								=			False
					def 	a			(						self       :						Union[str, Any]  )							->					Optional[int]:



											'''simple docstring'''





											__magic_name__					=      TFSwinModelTester(self  )
											__magic_name__					=      ConfigTester(self	,      config_class=_lowerCAmelCase	,      embed_dim=3_7  )
					def 	a			(						self       :						Optional[Any]  )							->					Optional[int]:



											'''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 	a			(						self       :						int  )							->					int:



											'''simple docstring'''





											return
					def 	a			(						self       :						Tuple  )							->					int:



											'''simple docstring'''





											__magic_name__					=      self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*_lowerCAmelCase  )
					def 	a			(						self       :						str  )							->					Dict:



											'''simple docstring'''





											__magic_name__					=      self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*_lowerCAmelCase  )
					def 	a			(						self       :						int  )							->					int:



											'''simple docstring'''





											__magic_name__					=      self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*_lowerCAmelCase  )
					@unittest.skip(reason='Swin does not use inputs_embeds'  )
					def 	a			(						self       :						Union[str, Any]  )							->					int:



											'''simple docstring'''





											pass
					def 	a			(						self       :						List[Any]  )							->					List[Any]:



											'''simple docstring'''





											__magic_name__		,      __magic_name__					=      self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
																	__magic_name__					=      model_class(_lowerCAmelCase  )
																	self.assertIsInstance(model.get_input_embeddings()	,      tf.keras.layers.Layer  )
																	__magic_name__					=      model.get_output_embeddings()
																	self.assertTrue(x is None or isinstance(_lowerCAmelCase	,      tf.keras.layers.Dense  )  )
					def 	a			(						self       :						Union[str, Any]  )							->					Tuple:



											'''simple docstring'''





											__magic_name__		,      __magic_name__					=      self.model_tester.prepare_config_and_inputs_for_common()

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

																	__magic_name__					=      ['pixel_values']
																	self.assertListEqual(arg_names[:1]	,      _lowerCAmelCase  )
					def 	a			(						self       :						str  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__		,      __magic_name__					=      self.model_tester.prepare_config_and_inputs_for_common()
											__magic_name__					=      True

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

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

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

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

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

																	__magic_name__					=      outputs.attentions

																	self.assertEqual(len(_lowerCAmelCase  )	,      _lowerCAmelCase  )

																	self.assertListEqual(
																	    list(self_attentions[0].shape[-3:]  )	,      [self.model_tester.num_heads[0], window_size_squared, window_size_squared]	,      )
					def 	a			(						self       :						Union[str, Any]	,      _lowerCAmelCase       :						List[Any]	,      _lowerCAmelCase       :						Union[str, Any]	,      _lowerCAmelCase       :						Dict	,      _lowerCAmelCase       :						List[str]  )							->					List[str]:



											'''simple docstring'''





											__magic_name__					=      model_class(_lowerCAmelCase  )
											__magic_name__					=      model(**self._prepare_for_class(_lowerCAmelCase	,      _lowerCAmelCase  )  )
											__magic_name__					=      outputs.hidden_states

											__magic_name__					=      getattr(
											    self.model_tester	,      'expected_num_hidden_layers'	,      len(self.model_tester.depths  ) + 1  )
											self.assertEqual(len(_lowerCAmelCase  )	,      _lowerCAmelCase  )

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

											__magic_name__					=      (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]	,      )

											__magic_name__					=      outputs.reshaped_hidden_states
											self.assertEqual(len(_lowerCAmelCase  )	,      _lowerCAmelCase  )

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

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

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



											'''simple docstring'''





											__magic_name__		,      __magic_name__					=      self.model_tester.prepare_config_and_inputs_for_common()

											__magic_name__					=      to_atuple(self.model_tester.image_size  )

											for model_class in self.all_model_classes:
																	__magic_name__					=      True
																	self.check_hidden_states_output(_lowerCAmelCase	,      _lowerCAmelCase	,      _lowerCAmelCase	,      _lowerCAmelCase  )

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

																	self.check_hidden_states_output(_lowerCAmelCase	,      _lowerCAmelCase	,      _lowerCAmelCase	,      _lowerCAmelCase  )
					def 	a			(						self       :						Dict  )							->					Union[str, Any]:



											'''simple docstring'''





											__magic_name__		,      __magic_name__					=      self.model_tester.prepare_config_and_inputs_for_common()
											__magic_name__					=      3

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

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

											for model_class in self.all_model_classes:
																	__magic_name__					=      True
																	self.check_hidden_states_output(_lowerCAmelCase	,      _lowerCAmelCase	,      _lowerCAmelCase	,      (padded_height, padded_width)  )

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







					@slow
					def 	a			(						self       :						Any  )							->					Union[str, Any]:



											'''simple docstring'''





											for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																	__magic_name__					=      TFSwinModel.from_pretrained(_lowerCAmelCase  )
																	self.assertIsNotNone(_lowerCAmelCase  )







@require_vision
@require_tf
class      __snake_case				(   unittest.TestCase):
					@cached_property
					def 	a			(						self       :						Tuple  )							->					int:



											'''simple docstring'''





											return (
											    AutoImageProcessor.from_pretrained('microsoft/swin-tiny-patch4-window7-224'  )
											    if is_vision_available()
											    else None
											)







					@slow
					def 	a			(						self       :						Dict  )							->					Any:



											'''simple docstring'''





											__magic_name__					=      TFSwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'  )
											__magic_name__					=      self.default_image_processor

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

											# forward pass
											__magic_name__					=      model(_lowerCAmelCase  )

											# verify the logits
											__magic_name__					=      tf.TensorShape((1, 1_0_0_0)  )
											self.assertEqual(outputs.logits.shape	,      _lowerCAmelCase  )
											__magic_name__					=      tf.constant([-0.0948, -0.6454, -0.0921]  )
											self.assertTrue(np.allclose(outputs.logits[0, :3]	,      _lowerCAmelCase	,      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 				UpperCamelCase_	(					__snake_case      :    Dict  )->   str:




						'''simple docstring'''
						if is_torch_available():
												import torch

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

						return isinstance(__snake_case						,      np.ndarray  )




class      __snake_case				(   _UpperCAmelCase):
					def 	a			(						self       :						Optional[Any]  )							->					Optional[Any]:



											'''simple docstring'''





											__magic_name__					=      fields(self  )

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

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

											if other_fields_are_none and isinstance(_lowerCAmelCase	,      _lowerCAmelCase  ):
																	for key, value in first_field.items():
																							__magic_name__					=      value
											else:
																	for field in class_fields:
																							__magic_name__					=      getattr(self	,      field.name  )
																							if v is not None:
																													__magic_name__					=      v
					def __delitem__(						self       :						Dict	,      *_lowerCAmelCase       :						List[str]	,      **_lowerCAmelCase       :						List[str]  )							->					List[str]:



											'''simple docstring'''





											raise Exception(F'''You cannot use ``__delitem__`` on a {self.__class__.__name__} instance.'''  )
					def 	a			(						self       :						Optional[int]	,      *_lowerCAmelCase       :						Optional[Any]	,      **_lowerCAmelCase       :						Optional[Any]  )							->					str:



											'''simple docstring'''





											raise Exception(F'''You cannot use ``setdefault`` on a {self.__class__.__name__} instance.'''  )
					def 	a			(						self       :						Union[str, Any]	,      *_lowerCAmelCase       :						List[str]	,      **_lowerCAmelCase       :						Any  )							->					str:



											'''simple docstring'''





											raise Exception(F'''You cannot use ``pop`` on a {self.__class__.__name__} instance.'''  )
					def 	a			(						self       :						Any	,      *_lowerCAmelCase       :						str	,      **_lowerCAmelCase       :						Optional[int]  )							->					List[Any]:



											'''simple docstring'''





											raise Exception(F'''You cannot use ``update`` on a {self.__class__.__name__} instance.'''  )
					def __getitem__(						self       :						Optional[Any]	,      _lowerCAmelCase       :						Any  )							->					Tuple:



											'''simple docstring'''





											if isinstance(_lowerCAmelCase	,      _lowerCAmelCase  ):
																	__magic_name__					=      dict(self.items()  )
																	return inner_dict[k]
											else:
																	return self.to_tuple()[k]
					def __setattr__(						self       :						str	,      _lowerCAmelCase       :						Optional[Any]	,      _lowerCAmelCase       :						Optional[int]  )							->					int:



											'''simple docstring'''





											if name in self.keys() and value is not None:
																	# Don't call self.__setitem__ to avoid recursion errors
																	super().__setitem__(_lowerCAmelCase	,      _lowerCAmelCase  )
											super().__setattr__(_lowerCAmelCase	,      _lowerCAmelCase  )
					def __setitem__(						self       :						Optional[Any]	,      _lowerCAmelCase       :						Optional[Any]	,      _lowerCAmelCase       :						List[str]  )							->					Optional[int]:



											'''simple docstring'''





											super().__setitem__(_lowerCAmelCase	,      _lowerCAmelCase  )
											# Don't call self.__setattr__ to avoid recursion errors
											super().__setattr__(_lowerCAmelCase	,      _lowerCAmelCase  )







					def 	a			(						self       :						str  )							->					Tuple[Any]:



											'''simple docstring'''





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

