code: 
  
  
  '''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 					__lowercase					:
  
  
  
  		"""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		,			)     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     parent
  					lowerCamelCase								=     batch_size
  					lowerCamelCase								=     image_size
  					lowerCamelCase								=     patch_size
  					lowerCamelCase								=     num_channels
  					lowerCamelCase								=     embed_dim
  					lowerCamelCase								=     depths
  					lowerCamelCase								=     num_heads
  					lowerCamelCase								=     window_size
  					lowerCamelCase								=     mlp_ratio
  					lowerCamelCase								=     qkv_bias
  					lowerCamelCase								=     hidden_dropout_prob
  					lowerCamelCase								=     attention_probs_dropout_prob
  					lowerCamelCase								=     drop_path_rate
  					lowerCamelCase								=     hidden_act
  					lowerCamelCase								=     use_absolute_embeddings
  					lowerCamelCase								=     patch_norm
  					lowerCamelCase								=     layer_norm_eps
  					lowerCamelCase								=     initializer_range
  					lowerCamelCase								=     is_training
  					lowerCamelCase								=     scope
  					lowerCamelCase								=     use_labels
  					lowerCamelCase								=     type_sequence_label_size
  					lowerCamelCase								=     encoder_stride
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
  
  					lowerCamelCase								=     None
  					if self.use_labels:
  								lowerCamelCase								=     ids_tensor([self.batch_size]		,			self.type_sequence_label_size  )
  
  					lowerCamelCase								=     self.get_config()
  
  					return config, pixel_values, labels
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   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		,			A		,			A		,			A  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFSwinModel(config=UpperCAmelCase_  )
  					lowerCamelCase								=     model(UpperCAmelCase_  )
  
  					lowerCamelCase								=     ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths  ) - 1))
  					lowerCamelCase								=     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		,			A		,			A		,			A  )     ->   Optional[int]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFSwinForMaskedImageModeling(config=UpperCAmelCase_  )
  					lowerCamelCase								=     model(UpperCAmelCase_  )
  					self.parent.assertEqual(
  					    result.logits.shape		,			(self.batch_size, self.num_channels, self.image_size, self.image_size)  )
  
  					# test greyscale images
  					lowerCamelCase								=     1
  					lowerCamelCase								=     TFSwinForMaskedImageModeling(UpperCAmelCase_  )
  
  					lowerCamelCase								=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
  					lowerCamelCase								=     model(UpperCAmelCase_  )
  					self.parent.assertEqual(result.logits.shape		,			(self.batch_size, 1, self.image_size, self.image_size)  )
  
  
  
  
  
  
  
  		def 				__A      (   self		,			A		,			A		,			A  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.type_sequence_label_size
  					lowerCamelCase								=     TFSwinForImageClassification(UpperCAmelCase_  )
  					lowerCamelCase								=     model(UpperCAmelCase_		,			labels=UpperCAmelCase_  )
  					self.parent.assertEqual(result.logits.shape		,			(self.batch_size, self.type_sequence_label_size)  )
  
  					# test greyscale images
  					lowerCamelCase								=     1
  					lowerCamelCase								=     TFSwinForImageClassification(UpperCAmelCase_  )
  					lowerCamelCase								=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]  )
  					lowerCamelCase								=     model(UpperCAmelCase_  )
  					self.parent.assertEqual(result.logits.shape		,			(self.batch_size, self.type_sequence_label_size)  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.prepare_config_and_inputs()
  					lowerCamelCase								=     config_and_inputs
  					lowerCamelCase								=     {'pixel_values': pixel_values}
  					return config, inputs_dict
  
  
  
  
  
  
  
  @require_tf
  class 					__lowercase					(       a_ ,       a_ ,       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		UpperCamelCase    :				Dict 					=		(
  		    (
  		        TFSwinModel,
  		        TFSwinForImageClassification,
  		        TFSwinForMaskedImageModeling,
  		    )
  		    if is_tf_available()
  		    else ()
  		)
  		UpperCamelCase    :				Any 					=		(
  		    {"feature-extraction": TFSwinModel, "image-classification": TFSwinForImageClassification}
  		    if is_tf_available()
  		    else {}
  		)
  
  		UpperCamelCase    :				List[str] 					=		False
  		UpperCamelCase    :				Tuple 					=		False
  		UpperCamelCase    :				Dict 					=		False
  		UpperCamelCase    :				int 					=		False
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFSwinModelTester(self  )
  					lowerCamelCase								=     ConfigTester(self		,			config_class=UpperCAmelCase_		,			embed_dim=37  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''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  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_model(*UpperCAmelCase_  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs()
  					self.model_tester.create_and_check_for_masked_image_modeling(*UpperCAmelCase_  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     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 				__A      (   self  )     ->   Any:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					pass
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  
  					for model_class in self.all_model_classes:
  								lowerCamelCase								=     model_class(UpperCAmelCase_  )
  								self.assertIsInstance(model.get_input_embeddings()		,			tf.keras.layers.Layer  )
  								lowerCamelCase								=     model.get_output_embeddings()
  								self.assertTrue(x is None or isinstance(UpperCAmelCase_		,			tf.keras.layers.Dense  )  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  
  					for model_class in self.all_model_classes:
  								lowerCamelCase								=     model_class(UpperCAmelCase_  )
  								lowerCamelCase								=     inspect.signature(model.call  )
  								# signature.parameters is an OrderedDict => so arg_names order is deterministic
  								lowerCamelCase								=     [*signature.parameters.keys()]
  
  								lowerCamelCase								=     ['pixel_values']
  								self.assertListEqual(arg_names[:1]		,			UpperCAmelCase_  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  					lowerCamelCase								=     True
  
  					for model_class in self.all_model_classes:
  								lowerCamelCase								=     True
  								lowerCamelCase								=     False
  								lowerCamelCase								=     True
  								lowerCamelCase								=     model_class(UpperCAmelCase_  )
  								lowerCamelCase								=     model(**self._prepare_for_class(UpperCAmelCase_		,			UpperCAmelCase_  )  )
  								lowerCamelCase								=     outputs.attentions
  								lowerCamelCase								=     len(self.model_tester.depths  )
  								self.assertEqual(len(UpperCAmelCase_  )		,			UpperCAmelCase_  )
  
  								# check that output_attentions also work using config
  								del inputs_dict["output_attentions"]
  								lowerCamelCase								=     True
  								lowerCamelCase								=     config.window_size**2
  								lowerCamelCase								=     model_class(UpperCAmelCase_  )
  								lowerCamelCase								=     model(**self._prepare_for_class(UpperCAmelCase_		,			UpperCAmelCase_  )  )
  								lowerCamelCase								=     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]		,			)
  								lowerCamelCase								=     len(UpperCAmelCase_  )
  
  								# Check attention is always last and order is fine
  								lowerCamelCase								=     True
  								lowerCamelCase								=     True
  								lowerCamelCase								=     model_class(UpperCAmelCase_  )
  								lowerCamelCase								=     model(**self._prepare_for_class(UpperCAmelCase_		,			UpperCAmelCase_  )  )
  
  								if hasattr(self.model_tester		,			"""num_hidden_states_types"""  ):
  											lowerCamelCase								=     self.model_tester.num_hidden_states_types
  								else:
  											# also another +1 for reshaped_hidden_states
  											lowerCamelCase								=     2
  								self.assertEqual(out_len + added_hidden_states		,			len(UpperCAmelCase_  )  )
  
  								lowerCamelCase								=     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 				__A      (   self		,			A		,			A		,			A		,			A  )     ->   List[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     model_class(UpperCAmelCase_  )
  					lowerCamelCase								=     model(**self._prepare_for_class(UpperCAmelCase_		,			UpperCAmelCase_  )  )
  					lowerCamelCase								=     outputs.hidden_states
  
  					lowerCamelCase								=     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
  					lowerCamelCase								=     to_atuple(config.patch_size  )
  
  					lowerCamelCase								=     (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]		,			)
  
  					lowerCamelCase								=     outputs.reshaped_hidden_states
  					self.assertEqual(len(UpperCAmelCase_  )		,			UpperCAmelCase_  )
  
  					lowerCamelCase								=     reshaped_hidden_states[0].shape
  
  					lowerCamelCase								=     tf.reshape(reshaped_hidden_states[0]		,			(batch_size, num_channels, height * width)  )
  					lowerCamelCase								=     tf.transpose(UpperCAmelCase_		,			(0, 2, 1)  )
  
  					self.assertListEqual(
  					    list(reshaped_hidden_states.shape[-2:]  )		,			[num_patches, self.model_tester.embed_dim]		,			)
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   int:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  
  					lowerCamelCase								=     to_atuple(self.model_tester.image_size  )
  
  					for model_class in self.all_model_classes:
  								lowerCamelCase								=     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"]
  								lowerCamelCase								=     True
  
  								self.check_hidden_states_output(UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_  )
  
  
  
  
  
  
  
  		def 				__A      (   self  )     ->   List[str]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     self.model_tester.prepare_config_and_inputs_for_common()
  					lowerCamelCase								=     3
  
  					lowerCamelCase								=     to_atuple(self.model_tester.image_size  )
  					lowerCamelCase								=     to_atuple(config.patch_size  )
  
  					lowerCamelCase								=     image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
  					lowerCamelCase								=     image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])
  
  					for model_class in self.all_model_classes:
  								lowerCamelCase								=     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"]
  								lowerCamelCase								=     True
  								self.check_hidden_states_output(UpperCAmelCase_		,			UpperCAmelCase_		,			UpperCAmelCase_		,			(padded_height, padded_width)  )
  
  
  
  
  
  
  
  		@slow
  		def 				__A      (   self  )     ->   Union[str, Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
  								lowerCamelCase								=     TFSwinModel.from_pretrained(UpperCAmelCase_  )
  								self.assertIsNotNone(UpperCAmelCase_  )
  
  
  
  
  
  
  
  @require_vision
  @require_tf
  class 					__lowercase					(       unittest.TestCase     ):
  
  
  
  		"""simple docstring"""
  
  		@cached_property
  		def 				__A      (   self  )     ->   Optional[Any]:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					return (
  					    AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""  )
  					    if is_vision_available()
  					    else None
  					)
  
  
  
  
  
  
  
  		@slow
  		def 				__A      (   self  )     ->   Dict:
  
  
  
  
  
  
  
  					'''simple docstring'''
  
  
  
  
  
  
  
  					lowerCamelCase								=     TFSwinForImageClassification.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""  )
  					lowerCamelCase								=     self.default_image_processor
  
  					lowerCamelCase								=     Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""  )
  					lowerCamelCase								=     image_processor(images=UpperCAmelCase_		,			return_tensors="""tf"""  )
  
  					# forward pass
  					lowerCamelCase								=     model(UpperCAmelCase_  )
  
  					# verify the logits
  					lowerCamelCase								=     tf.TensorShape((1, 10_00)  )
  					self.assertEqual(outputs.logits.shape		,			UpperCAmelCase_  )
  					lowerCamelCase								=     tf.constant([-0.0948, -0.6454, -0.0921]  )
  					self.assertTrue(np.allclose(outputs.logits[0, :3]		,			UpperCAmelCase_		,			atol=1e-4  )  )
  
  
style_context: 
  
  
  import warnings
  
  from .generation import FlaxGenerationMixin
  
  
  
  
  
  
  
  class 					__lowercase					(       a_     ):
  
  
  
  		"""simple docstring"""
  
  		warnings.warn(
  		    "Importing `FlaxGenerationMixin` from `src/transformers/generation_flax_utils.py` is deprecated and will "
  		    "be removed in Transformers v5. Import as `from transformers import FlaxGenerationMixin` instead." ,       a_ ,       )
  
  