

'''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 lowerCamelCase   :

				def __init__(       self,						lowercase_,						lowercase_=13,						lowercase_=32,						lowercase_=2,						lowercase_=3,						lowercase_=16,						lowercase_=[1, 2, 1],						lowercase_=[2, 2, 4],						lowercase_=2,						lowercase_=2.0,						lowercase_=True,						lowercase_=0.0,						lowercase_=0.0,						lowercase_=0.1,						lowercase_="gelu",						lowercase_=False,						lowercase_=True,						lowercase_=0.02,						lowercase_=1E-5,						lowercase_=True,						lowercase_=None,						lowercase_=True,						lowercase_=10,						lowercase_=8,						lowercase_=["stage1", "stage2"],						lowercase_=[1, 2],						)    ->							Any:
					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
					snake_case							=					out_features
					snake_case							=					out_indices

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					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 					_lowerCamelCase    (       self )    ->							Union[str, 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,						out_features=self.out_features,						out_indices=self.out_indices,						)

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Any:
					snake_case							=					SwinModel(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_ )

					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 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Tuple:
					snake_case							=					SwinBackbone(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					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
					snake_case							=					None
					snake_case							=					SwinBackbone(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					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 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							Union[str, Any]:
					snake_case							=					SwinForMaskedImageModeling(config=lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_ )
					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							=					SwinForMaskedImageModeling(lowercase_ )
					model.to(lowercase_ )
					model.eval()

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

				def 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_ )    ->							List[str]:
					snake_case							=					self.type_sequence_label_size
					snake_case							=					SwinForImageClassification(lowercase_ )
					model.to(lowercase_ )
					model.eval()
					snake_case							=					model(lowercase_,						labels=lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.type_sequence_label_size) )

					# test greyscale images
					snake_case							=					1
					snake_case							=					SwinForImageClassification(lowercase_ )
					model.to(lowercase_ )
					model.eval()

					snake_case							=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size] )
					snake_case							=					model(lowercase_ )
					self.parent.assertEqual(result.logits.shape,						(self.batch_size, self.type_sequence_label_size) )






				def 					_lowerCamelCase    (       self )    ->							Any:
					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_torch
class lowerCamelCase   (    __lowerCAmelCase				,				__lowerCAmelCase				,				unittest.TestCase				):
				snake_case_							     = (
				    (
				        SwinModel,
				        SwinBackbone,
				        SwinForImageClassification,
				        SwinForMaskedImageModeling,
				    )
				    if is_torch_available()
				    else ()
				)
				snake_case_							     = (
				    {'''feature-extraction''': SwinModel, '''image-classification''': SwinForImageClassification}
				    if is_torch_available()
				    else {}
				)
				snake_case_							     = True

				snake_case_							     = False
				snake_case_							     = False
				snake_case_							     = False

				def 					_lowerCamelCase    (       self )    ->							List[str]:
					snake_case							=					SwinModelTester(self )
					snake_case							=					ConfigTester(self,						config_class=lowercase_,						embed_dim=37 )

				def 					_lowerCamelCase    (       self )    ->							List[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 )    ->							Dict:
					return

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					snake_case							=					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 					_lowerCamelCase    (       self )    ->							List[Any]:
					pass

				def 					_lowerCamelCase    (       self )    ->							Tuple:
					super().test_training_gradient_checkpointing()

				def 					_lowerCamelCase    (       self )    ->							str:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_backbone(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					snake_case							=					self.model_tester.prepare_config_and_inputs()
					self.model_tester.create_and_check_for_masked_image_modeling(*lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Dict:
					snake_case							=					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 					_lowerCamelCase    (       self )    ->							str:
					pass

				@unittest.skip(reason='Swin Transformer does not use feedforward chunking' )
				def 					_lowerCamelCase    (       self )    ->							Dict:
					pass

				def 					_lowerCamelCase    (       self )    ->							str:
					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(lowercase_ )
						self.assertIsInstance(model.get_input_embeddings(),						(nn.Module) )
						snake_case							=					model.get_output_embeddings()
						self.assertTrue(x is None or isinstance(lowercase_,						nn.Linear ) )

				def 					_lowerCamelCase    (       self )    ->							List[Any]:
					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(lowercase_ )
						snake_case							=					inspect.signature(model.forward )
						# 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],						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					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(lowercase_ )
						model.to(lowercase_ )
						model.eval()
						with torch.no_grad():
							snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )
						snake_case							=					outputs.attentions
						snake_case							=					len(self.model_tester.depths )
						self.assertEqual(len(lowercase_ ),						lowercase_ )

						# 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(lowercase_ )
						model.to(lowercase_ )
						model.eval()
						with torch.no_grad():
							snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )
						snake_case							=					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],						)
						snake_case							=					len(lowercase_ )

						# Check attention is always last and order is fine
						snake_case							=					True
						snake_case							=					True
						snake_case							=					model_class(lowercase_ )
						model.to(lowercase_ )
						model.eval()
						with torch.no_grad():
							snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )

						# also another +1 for reshaped_hidden_states
						snake_case							=					1 if model_class.__name__ == 'SwinBackbone' else 2
						self.assertEqual(out_len + added_hidden_states,						len(lowercase_ ) )

						snake_case							=					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 					_lowerCamelCase    (       self,						lowercase_,						lowercase_,						lowercase_,						lowercase_ )    ->							Union[str, Any]:
					snake_case							=					model_class(lowercase_ )
					model.to(lowercase_ )
					model.eval()

					with torch.no_grad():
						snake_case							=					model(**self._prepare_for_class(lowercase_,						lowercase_ ) )

					snake_case							=					outputs.hidden_states

					snake_case							=					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
					snake_case							=					(
					    config.patch_size
					    if isinstance(config.patch_size,						collections.abc.Iterable )
					    else (config.patch_size, 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],						)

					if not model_class.__name__ == "SwinBackbone":
						snake_case							=					outputs.reshaped_hidden_states
						self.assertEqual(len(lowercase_ ),						lowercase_ )

						snake_case			,			snake_case			,			snake_case			,			snake_case							=					reshaped_hidden_states[0].shape
						snake_case							=					(
						    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 					_lowerCamelCase    (       self )    ->							Any:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					snake_case							=					(
					    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:
						snake_case							=					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"]
						snake_case							=					True

						self.check_hidden_states_output(lowercase_,						lowercase_,						lowercase_,						lowercase_ )

				def 					_lowerCamelCase    (       self )    ->							Optional[int]:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()
					snake_case							=					3

					snake_case							=					(
					    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)
					)
					snake_case							=					(
					    config.patch_size
					    if isinstance(config.patch_size,						collections.abc.Iterable )
					    else (config.patch_size, 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(lowercase_,						lowercase_,						lowercase_,						(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(lowercase_,						lowercase_,						lowercase_,						(padded_height, padded_width) )

				@slow
				def 					_lowerCamelCase    (       self )    ->							Union[str, Any]:
					for model_name in SWIN_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
						snake_case							=					SwinModel.from_pretrained(lowercase_ )
						self.assertIsNotNone(lowercase_ )






				def 					_lowerCamelCase    (       self )    ->							Any:
					snake_case			,			snake_case							=					self.model_tester.prepare_config_and_inputs_for_common()

					snake_case							=					_config_zero_init(lowercase_ )
					for model_class in self.all_model_classes:
						snake_case							=					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 lowerCamelCase   (    unittest.TestCase				):

				@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 )    ->							Optional[int]:
					snake_case							=					SwinForImageClassification.from_pretrained('microsoft/swin-tiny-patch4-window7-224' ).to(lowercase_ )
					snake_case							=					self.default_image_processor

					snake_case							=					Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png' )
					snake_case							=					image_processor(images=lowercase_,						return_tensors='pt' ).to(lowercase_ )

					# forward pass
					with torch.no_grad():
						snake_case							=					model(**lowercase_ )

					# verify the logits
					snake_case							=					torch.Size((1, 1000) )
					self.assertEqual(outputs.logits.shape,						lowercase_ )
					snake_case							=					torch.tensor([-0.0_948, -0.6_454, -0.0_921] ).to(lowercase_ )
					self.assertTrue(torch.allclose(outputs.logits[0, :3],						lowercase_,						atol=1E-4 ) )







@require_torch
class lowerCamelCase   (    unittest.TestCase				,				__lowerCAmelCase				):
				snake_case_							     = (SwinBackbone,) if is_torch_available() else ()
				snake_case_							     = SwinConfig

				def 					_lowerCamelCase    (       self )    ->							int:
					snake_case							=					SwinModelTester(self )







import logging

# standard libraries
import sys

import numpy as np
import pytest  # type: ignore

# Custom/local libraries
from matrix import matrix_operation as matop

_A       =					[[12, 10], [3, 9]]
_A       =					[[3, 4], [7, 4]]
_A       =					[[3, 0, 2], [2, 0, -2], [0, 1, 1]]
_A       =					[[3, 0, -2], [2, 0, 2], [0, 1, 1]]
_A       =					[[3, 0, 2], [2, 0, -2], [0, 1, 1], [2, 0, -2]]
_A       =					[1]
_A       =					[2]

_A       =					logging.getLogger()
_A       =					logging.DEBUG
_A       =					logging.StreamHandler(sys.stdout)
logger.addHandler(stream_handler)



@pytest.mark.mat_ops
@pytest.mark.parametrize(
    ("mat1", "mat2")					,						[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]						)
def 		lowercase_     (  A__					,						A__						)				->				Dict:
    """simple docstring"""

    if (np.array(A__						)).shape < (2, 2) or (np.array(A__						)).shape < (2, 2):
        with pytest.raises(A__						):
            logger.info(F'\n\t{test_addition.__name__} returned integer'						)
            matop.add(A__					,						A__						)
    elif (np.array(A__						)).shape == (np.array(A__						)).shape:
        logger.info(F'\n\t{test_addition.__name__} with same matrix dims'						)
        snake_case						=   (np.array(A__						) + np.array(A__						)).tolist()
        snake_case						=   matop.add(A__					,						A__						)
        assert theo == act
    else:
        with pytest.raises(A__						):
            logger.info(F'\n\t{test_addition.__name__} with different matrix dims'						)
            matop.add(A__					,						A__						)



@pytest.mark.mat_ops
@pytest.mark.parametrize(
    ("mat1", "mat2")					,						[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]						)
def 		lowercase_     (  A__					,						A__						)				->				List[Any]:
    """simple docstring"""

    if (np.array(A__						)).shape < (2, 2) or (np.array(A__						)).shape < (2, 2):
        with pytest.raises(A__						):
            logger.info(F'\n\t{test_subtraction.__name__} returned integer'						)
            matop.subtract(A__					,						A__						)
    elif (np.array(A__						)).shape == (np.array(A__						)).shape:
        logger.info(F'\n\t{test_subtraction.__name__} with same matrix dims'						)
        snake_case						=   (np.array(A__						) - np.array(A__						)).tolist()
        snake_case						=   matop.subtract(A__					,						A__						)
        assert theo == act
    else:
        with pytest.raises(A__						):
            logger.info(F'\n\t{test_subtraction.__name__} with different matrix dims'						)
            assert matop.subtract(A__					,						A__						)



@pytest.mark.mat_ops
@pytest.mark.parametrize(
    ("mat1", "mat2")					,						[(mat_a, mat_b), (mat_c, mat_d), (mat_d, mat_e), (mat_f, mat_h)]						)
def 		lowercase_     (  A__					,						A__						)				->				Union[str, Any]:
    """simple docstring"""

    if (np.array(A__						)).shape < (2, 2) or (np.array(A__						)).shape < (2, 2):
        logger.info(F'\n\t{test_multiplication.__name__} returned integer'						)
        with pytest.raises(A__						):
            matop.add(A__					,						A__						)
    elif (np.array(A__						)).shape == (np.array(A__						)).shape:
        logger.info(F'\n\t{test_multiplication.__name__} meets dim requirements'						)
        snake_case						=   (np.matmul(A__					,						A__						)).tolist()
        snake_case						=   matop.multiply(A__					,						A__						)
        assert theo == act
    else:
        with pytest.raises(A__						):
            logger.info(
                F'\n\t{test_multiplication.__name__} does not meet dim requirements'						)
            assert matop.subtract(A__					,						A__						)



@pytest.mark.mat_ops
def 		lowercase_     (  )				->				int:
    """simple docstring"""

    snake_case						=   (3.5 * np.array(A__						)).tolist()
    snake_case						=   matop.scalar_multiply(A__					,						3.5						)
    assert theo == act



@pytest.mark.mat_ops
def 		lowercase_     (  )				->				Any:
    """simple docstring"""

    snake_case						=   (np.identity(5						)).tolist()
    snake_case						=   matop.identity(5						)
    assert theo == act





@pytest.mark.mat_ops
@pytest.mark.parametrize("mat"					,						[mat_a, mat_b, mat_c, mat_d, mat_e, mat_f]						)
def 		lowercase_     (  A__						)				->				List[str]:
    """simple docstring"""

    if (np.array(A__						)).shape < (2, 2):
        with pytest.raises(A__						):
            logger.info(F'\n\t{test_transpose.__name__} returned integer'						)
            matop.transpose(A__						)
    else:
        snake_case						=   (np.transpose(A__						)).tolist()
        snake_case						=   matop.transpose(A__					,						return_map=A__						)
        assert theo == act

