




"""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 	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.0_2  ,  __UpperCAmelCase=1e-5  ,  __UpperCAmelCase=True  ,  __UpperCAmelCase=None  ,  __UpperCAmelCase=True  ,  __UpperCAmelCase=10  ,  __UpperCAmelCase=8  ,  )				->  None:
				_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       _lowerCAmelCase	(							self						)				->  Union[str, Any]:
				_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       _lowerCAmelCase	(							self						)				->  List[Any]:
				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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  Tuple:
				_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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  List[str]:
				_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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  str:
				_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       _lowerCAmelCase	(							self						)				->  Dict:
				_lowerCAmelCase			=self.prepare_config_and_inputs()
				_lowerCAmelCase		,							_lowerCAmelCase		,							_lowerCAmelCase			=config_and_inputs
				_lowerCAmelCase			={"""pixel_values""": pixel_values}
				return config, inputs_dict







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





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

			lowerCamelCase						      =	False
			lowerCamelCase						      =	False
			lowerCamelCase						      =	False
			lowerCamelCase						      =	False



			def       _lowerCAmelCase	(							self						)				->  Optional[int]:
				_lowerCAmelCase			=TFSwinModelTester(self						)
				_lowerCAmelCase			=ConfigTester(self  ,  config_class=__UpperCAmelCase  ,  embed_dim=37						)



			def       _lowerCAmelCase	(							self						)				->  Any:
				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       _lowerCAmelCase	(							self						)				->  str:
				return



			def       _lowerCAmelCase	(							self						)				->  Any:
				_lowerCAmelCase			=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*__UpperCAmelCase						)



			def       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_lowerCAmelCase			=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*__UpperCAmelCase						)



			def       _lowerCAmelCase	(							self						)				->  List[str]:
				_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       _lowerCAmelCase	(							self						)				->  Tuple:
				pass



			def       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self						)				->  Optional[Any]:
				_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase  ,  __UpperCAmelCase						)				->  Optional[int]:
				_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		,							_lowerCAmelCase		,							_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self						)				->  str:
				_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self						)				->  str:
				_lowerCAmelCase		,							_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       _lowerCAmelCase	(							self						)				->  int:
				for model_name in TF_SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
					_lowerCAmelCase			=TFSwinModel.from_pretrained(__UpperCAmelCase						)
					self.assertIsNotNone(__UpperCAmelCase						)







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





			'''simple docstring'''



			@cached_property
			def       _lowerCAmelCase	(							self						)				->  int:
				return (
				    AutoImageProcessor.from_pretrained("""microsoft/swin-tiny-patch4-window7-224"""						)
				    if is_vision_available()
				    else None
				)



			@slow
			def       _lowerCAmelCase	(							self						)				->  List[Any]:
				_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.0_9_4_8, -0.6_4_5_4, -0.0_9_2_1]						)
				self.assertTrue(np.allclose(outputs.logits[0, :3]  ,  __UpperCAmelCase  ,  atol=1e-4						)						)





"""simple docstring"""


def 					_lowerCamelCase(__UpperCamelCase					,				__UpperCamelCase					,				__UpperCamelCase )       ->				float:
	if mass < 0:
		raise ValueError("""The mass of the body cannot be negative""" )
	if radius <= 0:
		raise ValueError("""The radius is always a positive non zero integer""" )
	return (mass * (velocity) ** 2) / radius


if __name__ == "__main__":
			import doctest

			doctest.testmod(verbose=True)



