
"""simple docstring"""


import collections
import inspect
import unittest

from transformers import SwinConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import SwinBackbone, SwinForImageClassification, SwinForMaskedImageModeling, SwinModel
							from transformers.models.swin.modeling_swin import SWIN_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import AutoImageProcessor

class    A_     :



	"""simple docstring"""






	def __init__(  self  :int					,							lowerCamelCase_  :Dict					,							lowerCamelCase_  :Optional[Any]=13					,							lowerCamelCase_  :Optional[Any]=32					,							lowerCamelCase_  :Dict=2					,							lowerCamelCase_  :Union[str, Any]=3					,							lowerCamelCase_  :str=16					,							lowerCamelCase_  :Union[str, Any]=[1, 2, 1]					,							lowerCamelCase_  :int=[2, 2, 4]					,							lowerCamelCase_  :Optional[int]=2					,							lowerCamelCase_  :int=2.0					,							lowerCamelCase_  :str=True					,							lowerCamelCase_  :Dict=0.0					,							lowerCamelCase_  :Any=0.0					,							lowerCamelCase_  :int=0.1					,							lowerCamelCase_  :List[Any]="gelu"					,							lowerCamelCase_  :int=False					,							lowerCamelCase_  :Optional[int]=True					,							lowerCamelCase_  :Union[str, Any]=0.02					,							lowerCamelCase_  :Tuple=1e-5					,							lowerCamelCase_  :str=True					,							lowerCamelCase_  :Any=None					,							lowerCamelCase_  :List[str]=True					,							lowerCamelCase_  :List[Any]=10					,							lowerCamelCase_  :int=8					,							lowerCamelCase_  :List[Any]=["stage1", "stage2"]					,							lowerCamelCase_  :Optional[Any]=[1, 2]					,							):





				"""simple docstring"""

				lowerCamelCase__     :					Dict		=parent
				lowerCamelCase__     :					Tuple		=batch_size
				lowerCamelCase__     :					Optional[Any]		=image_size
				lowerCamelCase__     :					Tuple		=patch_size
				lowerCamelCase__     :					Tuple		=num_channels
				lowerCamelCase__     :					int		=embed_dim
				lowerCamelCase__     :					Tuple		=depths
				lowerCamelCase__     :					Any		=num_heads
				lowerCamelCase__     :					str		=window_size
				lowerCamelCase__     :					Union[str, Any]		=mlp_ratio
				lowerCamelCase__     :					Dict		=qkv_bias
				lowerCamelCase__     :					Tuple		=hidden_dropout_prob
				lowerCamelCase__     :					List[Any]		=attention_probs_dropout_prob
				lowerCamelCase__     :					Optional[int]		=drop_path_rate
				lowerCamelCase__     :					Optional[int]		=hidden_act
				lowerCamelCase__     :					Optional[int]		=use_absolute_embeddings
				lowerCamelCase__     :					Optional[int]		=patch_norm
				lowerCamelCase__     :					Tuple		=layer_norm_eps
				lowerCamelCase__     :					Any		=initializer_range
				lowerCamelCase__     :					Optional[Any]		=is_training
				lowerCamelCase__     :					Optional[Any]		=scope
				lowerCamelCase__     :					str		=use_labels
				lowerCamelCase__     :					Tuple		=type_sequence_label_size
				lowerCamelCase__     :					str		=encoder_stride
				lowerCamelCase__     :					Optional[Any]		=out_features
				lowerCamelCase__     :					Optional[Any]		=out_indices





	def 				UpperCAmelCase__							(  self  :Union[str, Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					List[str]		=floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]	)

				lowerCamelCase__     :					Dict		=None
				if self.use_labels:
							lowerCamelCase__     :					Any		=ids_tensor([self.batch_size]					,							self.type_sequence_label_size	)

				lowerCamelCase__     :					Union[str, Any]		=self.get_config()

				return config, pixel_values, labels





	def 				UpperCAmelCase__							(  self  :Optional[int]	):





				"""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					,							out_features=self.out_features					,							out_indices=self.out_indices					,							)





	def 				UpperCAmelCase__							(  self  :List[str]					,							lowerCamelCase_  :Dict					,							lowerCamelCase_  :int					,							lowerCamelCase_  :str	):





				"""simple docstring"""

				lowerCamelCase__     :					Dict		=SwinModel(config=lowercase__	)
				model.to(lowercase__	)
				model.eval()
				lowerCamelCase__     :					int		=model(lowercase__	)

				lowerCamelCase__     :					str		=((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
				lowerCamelCase__     :					Any		=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  :Union[str, Any]					,							lowerCamelCase_  :Union[str, Any]					,							lowerCamelCase_  :Tuple					,							lowerCamelCase_  :Union[str, Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					Tuple		=SwinBackbone(config=lowercase__	)
				model.to(lowercase__	)
				model.eval()
				lowerCamelCase__     :					Optional[int]		=model(lowercase__	)

				# verify hidden states
				self.parent.assertEqual(len(result.feature_maps	)					,							len(config.out_features	)	)
				self.parent.assertListEqual(list(result.feature_maps[0].shape	)					,							[self.batch_size, model.channels[0], 16, 16]	)

				# verify channels
				self.parent.assertEqual(len(model.channels	)					,							len(config.out_features	)	)

				# verify backbone works with out_features=None
				lowerCamelCase__     :					Optional[Any]		=None
				lowerCamelCase__     :					Optional[int]		=SwinBackbone(config=lowercase__	)
				model.to(lowercase__	)
				model.eval()
				lowerCamelCase__     :					int		=model(lowercase__	)

				# verify feature maps
				self.parent.assertEqual(len(result.feature_maps	)					,							1	)
				self.parent.assertListEqual(list(result.feature_maps[0].shape	)					,							[self.batch_size, model.channels[-1], 4, 4]	)

				# verify channels
				self.parent.assertEqual(len(model.channels	)					,							1	)





	def 				UpperCAmelCase__							(  self  :Any					,							lowerCamelCase_  :int					,							lowerCamelCase_  :Optional[Any]					,							lowerCamelCase_  :Dict	):





				"""simple docstring"""

				lowerCamelCase__     :					str		=SwinForMaskedImageModeling(config=lowercase__	)
				model.to(lowercase__	)
				model.eval()
				lowerCamelCase__     :					Union[str, Any]		=model(lowercase__	)
				self.parent.assertEqual(
				    result.logits.shape					,							(self.batch_size, self.num_channels, self.image_size, self.image_size)	)

				# test greyscale images
				lowerCamelCase__     :					str		=1
				lowerCamelCase__     :					Any		=SwinForMaskedImageModeling(lowercase__	)
				model.to(lowercase__	)
				model.eval()

				lowerCamelCase__     :					Union[str, Any]		=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
				lowerCamelCase__     :					List[Any]		=model(lowercase__	)
				self.parent.assertEqual(result.logits.shape					,							(self.batch_size, 1, self.image_size, self.image_size)	)





	def 				UpperCAmelCase__							(  self  :int					,							lowerCamelCase_  :Tuple					,							lowerCamelCase_  :List[str]					,							lowerCamelCase_  :List[Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					Optional[Any]		=self.type_sequence_label_size
				lowerCamelCase__     :					int		=SwinForImageClassification(lowercase__	)
				model.to(lowercase__	)
				model.eval()
				lowerCamelCase__     :					Optional[Any]		=model(lowercase__					,							labels=lowercase__	)
				self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.type_sequence_label_size)	)

				# test greyscale images
				lowerCamelCase__     :					int		=1
				lowerCamelCase__     :					List[Any]		=SwinForImageClassification(lowercase__	)
				model.to(lowercase__	)
				model.eval()

				lowerCamelCase__     :					Optional[int]		=floats_tensor([self.batch_size, 1, self.image_size, self.image_size]	)
				lowerCamelCase__     :					int		=model(lowercase__	)
				self.parent.assertEqual(result.logits.shape					,							(self.batch_size, self.type_sequence_label_size)	)





	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

				lowerCamelCase__     :					List[str]		=self.prepare_config_and_inputs()
				(
				    lowerCamelCase__						
				)     :					List[str]		=config_and_inputs
				lowerCamelCase__     :					Tuple		={"pixel_values": pixel_values}
				return config, inputs_dict






@require_torch
class    A_     (					_UpperCAmelCase				, _UpperCAmelCase				, unittest.TestCase       ):



	"""simple docstring"""






	SCREAMING_SNAKE_CASE_     				=       (
	    (
	        SwinModel,
	        SwinBackbone,
	        SwinForImageClassification,
	        SwinForMaskedImageModeling,
	    )
	    if is_torch_available()
	    else ()
	)
	SCREAMING_SNAKE_CASE_     				=       (
	    {"""feature-extraction""": SwinModel, """image-classification""": SwinForImageClassification}
	    if is_torch_available()
	    else {}
	)
	SCREAMING_SNAKE_CASE_     				=       True

	SCREAMING_SNAKE_CASE_     				=       False
	SCREAMING_SNAKE_CASE_     				=       False
	SCREAMING_SNAKE_CASE_     				=       False





	def 				UpperCAmelCase__							(  self  :Union[str, Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					Dict		=SwinModelTester(self	)
				lowerCamelCase__     :					Optional[int]		=ConfigTester(self					,							config_class=lowercase__					,							embed_dim=37	)





	def 				UpperCAmelCase__							(  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 				UpperCAmelCase__							(  self  :Union[str, Any]	):





				"""simple docstring"""

				return





	def 				UpperCAmelCase__							(  self  :Any	):





				"""simple docstring"""

				lowerCamelCase__     :					Dict		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_model(*lowercase__	)





	@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'	)
	def 				UpperCAmelCase__							(  self  :int	):





				"""simple docstring"""

				pass





	def 				UpperCAmelCase__							(  self  :int	):





				"""simple docstring"""

				super().test_training_gradient_checkpointing()





	def 				UpperCAmelCase__							(  self  :Tuple	):





				"""simple docstring"""

				lowerCamelCase__     :					List[Any]		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_backbone(*lowercase__	)





	def 				UpperCAmelCase__							(  self  :Dict	):





				"""simple docstring"""

				lowerCamelCase__     :					Union[str, Any]		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_masked_image_modeling(*lowercase__	)





	def 				UpperCAmelCase__							(  self  :Optional[Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					int		=self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_for_image_classification(*lowercase__	)





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





				"""simple docstring"""

				pass





	@unittest.skip(reason='Swin Transformer does not use feedforward chunking'	)
	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

				pass





	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

				lowerCamelCase__     :					Dict		=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							lowerCamelCase__     :					Optional[Any]		=model_class(lowercase__	)
							self.assertIsInstance(model.get_input_embeddings()					,							(nn.Module)	)
							lowerCamelCase__     :					List[str]		=model.get_output_embeddings()
							self.assertTrue(x is None or isinstance(lowercase__					,							nn.Linear	)	)





	def 				UpperCAmelCase__							(  self  :Optional[int]	):





				"""simple docstring"""

				lowerCamelCase__     :					Optional[int]		=self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							lowerCamelCase__     :					List[str]		=model_class(lowercase__	)
							lowerCamelCase__     :					Tuple		=inspect.signature(model.forward	)
							# signature.parameters is an OrderedDict => so arg_names order is deterministic
							lowerCamelCase__     :					str		=[*signature.parameters.keys()]

							lowerCamelCase__     :					Tuple		=["pixel_values"]
							self.assertListEqual(arg_names[:1]					,							lowercase__	)





	def 				UpperCAmelCase__							(  self  :Optional[Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					List[str]		=self.model_tester.prepare_config_and_inputs_for_common()
				lowerCamelCase__     :					Any		=True

				for model_class in self.all_model_classes:
							lowerCamelCase__     :					Optional[Any]		=True
							lowerCamelCase__     :					Dict		=False
							lowerCamelCase__     :					str		=True
							lowerCamelCase__     :					int		=model_class(lowercase__	)
							model.to(lowercase__	)
							model.eval()
							with torch.no_grad():
										lowerCamelCase__     :					str		=model(**self._prepare_for_class(lowercase__					,							lowercase__	)	)
							lowerCamelCase__     :					Tuple		=outputs.attentions
							lowerCamelCase__     :					Optional[Any]		=len(self.model_tester.depths	)
							self.assertEqual(len(lowercase__	)					,							lowercase__	)

							# check that output_attentions also work using config
							del inputs_dict["output_attentions"]
							lowerCamelCase__     :					Optional[Any]		=True
							lowerCamelCase__     :					Dict		=config.window_size**2
							lowerCamelCase__     :					List[str]		=model_class(lowercase__	)
							model.to(lowercase__	)
							model.eval()
							with torch.no_grad():
										lowerCamelCase__     :					Union[str, Any]		=model(**self._prepare_for_class(lowercase__					,							lowercase__	)	)
							lowerCamelCase__     :					Tuple		=outputs.attentions
							self.assertEqual(len(lowercase__	)					,							lowercase__	)

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

							# Check attention is always last and order is fine
							lowerCamelCase__     :					Tuple		=True
							lowerCamelCase__     :					Union[str, Any]		=True
							lowerCamelCase__     :					Optional[int]		=model_class(lowercase__	)
							model.to(lowercase__	)
							model.eval()
							with torch.no_grad():
										lowerCamelCase__     :					List[str]		=model(**self._prepare_for_class(lowercase__					,							lowercase__	)	)

							# also another +1 for reshaped_hidden_states
							lowerCamelCase__     :					List[str]		=1 if model_class.__name__ == "SwinBackbone" else 2
							self.assertEqual(out_len + added_hidden_states					,							len(lowercase__	)	)

							lowerCamelCase__     :					Optional[Any]		=outputs.attentions

							self.assertEqual(len(lowercase__	)					,							lowercase__	)

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





	def 				UpperCAmelCase__							(  self  :str					,							lowerCamelCase_  :str					,							lowerCamelCase_  :Dict					,							lowerCamelCase_  :List[Any]					,							lowerCamelCase_  :Optional[Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					List[str]		=model_class(lowercase__	)
				model.to(lowercase__	)
				model.eval()

				with torch.no_grad():
							lowerCamelCase__     :					int		=model(**self._prepare_for_class(lowercase__					,							lowercase__	)	)

				lowerCamelCase__     :					List[Any]		=outputs.hidden_states

				lowerCamelCase__     :					Union[str, Any]		=getattr(
				    self.model_tester					,							'expected_num_hidden_layers'					,							len(self.model_tester.depths	) + 1	)
				self.assertEqual(len(lowercase__	)					,							lowercase__	)

				# Swin has a different seq_length
				lowerCamelCase__     :					List[str]		=(
				    config.patch_size
				    if isinstance(config.patch_size					,							collections.abc.Iterable	)
				    else (config.patch_size, config.patch_size)
				)

				lowerCamelCase__     :					Optional[int]		=(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]					,							)

				if not model_class.__name__ == "SwinBackbone":
							lowerCamelCase__     :					Any		=outputs.reshaped_hidden_states
							self.assertEqual(len(lowercase__	)					,							lowercase__	)

							lowerCamelCase__     :					Union[str, Any]		=reshaped_hidden_states[0].shape
							lowerCamelCase__     :					List[Any]		=(
							    reshaped_hidden_states[0].view(lowercase__					,							lowercase__					,							height * width	).permute(0					,							2					,							1	)
							)
							self.assertListEqual(
							    list(reshaped_hidden_states.shape[-2:]	)					,							[num_patches, self.model_tester.embed_dim]					,							)





	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

				lowerCamelCase__     :					Optional[int]		=self.model_tester.prepare_config_and_inputs_for_common()

				lowerCamelCase__     :					Optional[Any]		=(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size					,							collections.abc.Iterable	)
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)

				for model_class in self.all_model_classes:
							lowerCamelCase__     :					List[Any]		=True
							self.check_hidden_states_output(lowercase__					,							lowercase__					,							lowercase__					,							lowercase__	)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							lowerCamelCase__     :					Union[str, Any]		=True

							self.check_hidden_states_output(lowercase__					,							lowercase__					,							lowercase__					,							lowercase__	)





	def 				UpperCAmelCase__							(  self  :Union[str, Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					Union[str, Any]		=self.model_tester.prepare_config_and_inputs_for_common()
				lowerCamelCase__     :					List[str]		=3

				lowerCamelCase__     :					int		=(
				    self.model_tester.image_size
				    if isinstance(self.model_tester.image_size					,							collections.abc.Iterable	)
				    else (self.model_tester.image_size, self.model_tester.image_size)
				)
				lowerCamelCase__     :					Union[str, Any]		=(
				    config.patch_size
				    if isinstance(config.patch_size					,							collections.abc.Iterable	)
				    else (config.patch_size, config.patch_size)
				)

				lowerCamelCase__     :					int		=image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
				lowerCamelCase__     :					Any		=image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

				for model_class in self.all_model_classes:
							lowerCamelCase__     :					Union[str, Any]		=True
							self.check_hidden_states_output(lowercase__					,							lowercase__					,							lowercase__					,							(padded_height, padded_width)	)

							# check that output_hidden_states also work using config
							del inputs_dict["output_hidden_states"]
							lowerCamelCase__     :					Optional[int]		=True
							self.check_hidden_states_output(lowercase__					,							lowercase__					,							lowercase__					,							(padded_height, padded_width)	)





	@slow
	def 				UpperCAmelCase__							(  self  :List[Any]	):





				"""simple docstring"""

				for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
							lowerCamelCase__     :					Any		=SwinModel.from_pretrained(lowercase__	)
							self.assertIsNotNone(lowercase__	)





	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

				lowerCamelCase__     :					str		=self.model_tester.prepare_config_and_inputs_for_common()

				lowerCamelCase__     :					Dict		=_config_zero_init(lowercase__	)
				for model_class in self.all_model_classes:
							lowerCamelCase__     :					Optional[int]		=model_class(config=lowercase__	)
							for name, param in model.named_parameters():
										if "embeddings" not in name and param.requires_grad:
													self.assertIn(
													    ((param.data.mean() * 1e9).round() / 1e9).item()					,							[0.0, 1.0]					,							msg=f"""Parameter {name} of model {model_class} seems not properly initialized"""					,							)






@require_vision
@require_torch
class    A_     (					unittest.TestCase       ):



	"""simple docstring"""






	@cached_property
	def 				UpperCAmelCase__							(  self  :str	):





				"""simple docstring"""

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





	@slow
	def 				UpperCAmelCase__							(  self  :Optional[int]	):





				"""simple docstring"""

				lowerCamelCase__     :					Optional[int]		=SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224'	).to(lowercase__	)
				lowerCamelCase__     :					Optional[Any]		=self.default_image_processor

				lowerCamelCase__     :					List[Any]		=Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'	)
				lowerCamelCase__     :					str		=image_processor(images=lowercase__					,							return_tensors='pt'	).to(lowercase__	)

				# forward pass
				with torch.no_grad():
							lowerCamelCase__     :					str		=model(**lowercase__	)

				# verify the logits
				lowerCamelCase__     :					Any		=torch.Size((1, 1_000)	)
				self.assertEqual(outputs.logits.shape					,							lowercase__	)
				lowerCamelCase__     :					Tuple		=torch.tensor([-0.09_48, -0.64_54, -0.09_21]	).to(lowercase__	)
				self.assertTrue(torch.allclose(outputs.logits[0, :3]					,							lowercase__					,							atol=1e-4	)	)






@require_torch
class    A_     (					unittest.TestCase				, _UpperCAmelCase       ):



	"""simple docstring"""






	SCREAMING_SNAKE_CASE_     				=       (SwinBackbone,) if is_torch_available() else ()
	SCREAMING_SNAKE_CASE_     				=       SwinConfig





	def 				UpperCAmelCase__							(  self  :List[Any]	):





				"""simple docstring"""

				lowerCamelCase__     :					Tuple		=SwinModelTester(self	)

"""simple docstring"""


from math import cos, sin






def        lowerCAmelCase_       (		snake_case_		:      float      )       ->list[list[float]]:
			lowerCamelCase__     :					List[Any]		=float(snake_case_      )
			return [[scaling_factor * int(x == y      ) for x in range(2      )] for y in range(2      )]






def        lowerCAmelCase_       (		snake_case_		:      float      )       ->list[list[float]]:
			lowerCamelCase__	,    lowerCamelCase__     :					Union[str, Any]		=cos(snake_case_      ), sin(snake_case_      )
			return [[c, -s], [s, c]]






def        lowerCAmelCase_       (		snake_case_		:      float      )       ->list[list[float]]:
			lowerCamelCase__	,    lowerCamelCase__     :					Optional[Any]		=cos(snake_case_      ), sin(snake_case_      )
			lowerCamelCase__     :					Dict		=c * s
			return [[c * c, cs], [cs, s * s]]






def        lowerCAmelCase_       (		snake_case_		:      float      )       ->list[list[float]]:
			lowerCamelCase__	,    lowerCamelCase__     :					str		=cos(snake_case_      ), sin(snake_case_      )
			lowerCamelCase__     :					Dict		=c * s
			return [[2 * c - 1, 2 * cs], [2 * cs, 2 * s - 1]]


print(f"""    {scaling(5) = }""")
print(f"""  {rotation(45) = }""")
print(f"""{projection(45) = }""")

print(f"""{reflection(45) = }""")