


import collections
import inspect
import unittest

from transformers import SwinvaConfig
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_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 SwinvaForImageClassification, SwinvaForMaskedImageModeling, SwinvaModel
						from transformers.models.swinva.modeling_swinva import SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST

if is_vision_available():
						from PIL import Image

						from transformers import AutoImageProcessor







class 	snake_case_       :
					def __init__(				self       :int      ,__snake_case       :int      ,__snake_case       :str=13      ,__snake_case       :int=32      ,__snake_case       :Union[str, Any]=2      ,__snake_case       :int=3      ,__snake_case       :List[str]=16      ,__snake_case       :List[str]=[1, 2, 1]      ,__snake_case       :List[Any]=[2, 2, 4]      ,__snake_case       :List[str]=2      ,__snake_case       :Union[str, Any]=2.0      ,__snake_case       :List[Any]=True      ,__snake_case       :List[str]=0.0      ,__snake_case       :str=0.0      ,__snake_case       :Optional[Any]=0.1      ,__snake_case       :str="gelu"      ,__snake_case       :List[str]=False      ,__snake_case       :Tuple=True      ,__snake_case       :Tuple=0.02      ,__snake_case       :Optional[int]=1E-5      ,__snake_case       :Any=True      ,__snake_case       :Union[str, Any]=None      ,__snake_case       :Optional[int]=True      ,__snake_case       :Any=10      ,__snake_case       :Any=8      ,) ->   Dict:
												a__					=					parent
												a__					=					batch_size
												a__					=					image_size
												a__					=					patch_size
												a__					=					num_channels
												a__					=					embed_dim
												a__					=					depths
												a__					=					num_heads
												a__					=					window_size
												a__					=					mlp_ratio
												a__					=					qkv_bias
												a__					=					hidden_dropout_prob
												a__					=					attention_probs_dropout_prob
												a__					=					drop_path_rate
												a__					=					hidden_act
												a__					=					use_absolute_embeddings
												a__					=					patch_norm
												a__					=					layer_norm_eps
												a__					=					initializer_range
												a__					=					is_training
												a__					=					scope
												a__					=					use_labels
												a__					=					type_sequence_label_size
												a__					=					encoder_stride
					def 			lowerCamelCase__(				self       :Tuple				) ->   List[str]:
												a__					=					floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)

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

												a__					=					self.get_config()

												return config, pixel_values, labels
					def 			lowerCamelCase__(				self       :List[Any]				) ->   int:
												return SwinvaConfig(
												    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       :str      ,__snake_case       :Optional[Any]      ,__snake_case       :Optional[Any]      ,__snake_case       :List[str]				) ->   int:
												a__					=					SwinvaModel(config=__snake_case				)
												model.to(__snake_case				)
												model.eval()
												a__					=					model(__snake_case				)

												a__					=					((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths				) - 1))
												a__					=					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       :List[str]      ,__snake_case       :Optional[Any]      ,__snake_case       :List[Any]      ,__snake_case       :int				) ->   List[str]:
												a__					=					SwinvaForMaskedImageModeling(config=__snake_case				)
												model.to(__snake_case				)
												model.eval()
												a__					=					model(__snake_case				)
												self.parent.assertEqual(
												    result.logits.shape      ,(self.batch_size, self.num_channels, self.image_size, self.image_size)				)

												# test greyscale images
												a__					=					1
												a__					=					SwinvaForMaskedImageModeling(__snake_case				)
												model.to(__snake_case				)
												model.eval()

												a__					=					floats_tensor([self.batch_size, 1, self.image_size, self.image_size]				)
												a__					=					model(__snake_case				)
												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, 1, self.image_size, self.image_size)				)
					def 			lowerCamelCase__(				self       :Union[str, Any]      ,__snake_case       :List[str]      ,__snake_case       :Optional[int]      ,__snake_case       :Tuple				) ->   Optional[Any]:
												a__					=					self.type_sequence_label_size
												a__					=					SwinvaForImageClassification(__snake_case				)
												model.to(__snake_case				)
												model.eval()
												a__					=					model(__snake_case      ,labels=__snake_case				)
												self.parent.assertEqual(result.logits.shape      ,(self.batch_size, self.type_sequence_label_size)				)



					def 			lowerCamelCase__(				self       :Optional[Any]				) ->   List[Any]:
												a__					=					self.prepare_config_and_inputs()
												a__				, a__				, a__					=					config_and_inputs
												a__					=					{'pixel_values': pixel_values}
												return config, inputs_dict







@require_torch
class 	snake_case_       (lowerCamelCase_     ,						lowerCamelCase_     ,						unittest.TestCase				):
					UpperCAmelCase__ :   Any   				=      (
					    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
					)
					UpperCAmelCase__ :   List[str]   				=      (
					    {'''feature-extraction''': SwinvaModel, '''image-classification''': SwinvaForImageClassification}
					    if is_torch_available()
					    else {}
					)

					UpperCAmelCase__ :   Tuple   				=      False
					UpperCAmelCase__ :   str   				=      False
					UpperCAmelCase__ :   Dict   				=      False
					UpperCAmelCase__ :   Union[str, Any]   				=      False
					def 			lowerCamelCase__(				self       :int				) ->   Optional[Any]:
												a__					=					SwinvaModelTester(self				)
												a__					=					ConfigTester(self      ,config_class=__snake_case      ,embed_dim=37				)
					def 			lowerCamelCase__(				self       :List[str]				) ->   List[Any]:
												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       :List[str]				) ->   str:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_model(*__snake_case				)
					@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'				)
					def 			lowerCamelCase__(				self       :str				) ->   Optional[Any]:
												pass
					@unittest.skip(reason='Swinv2 does not use inputs_embeds'				)
					def 			lowerCamelCase__(				self       :int				) ->   Dict:
												pass
					def 			lowerCamelCase__(				self       :Optional[int]				) ->   Optional[int]:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()

												for model_class in self.all_model_classes:
																			a__					=					model_class(__snake_case				)
																			self.assertIsInstance(model.get_input_embeddings()      ,(nn.Module)				)
																			a__					=					model.get_output_embeddings()
																			self.assertTrue(x is None or isinstance(__snake_case      ,nn.Linear				)				)
					def 			lowerCamelCase__(				self       :Any				) ->   List[Any]:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()

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

																			a__					=					['pixel_values']
																			self.assertListEqual(arg_names[:1]      ,__snake_case				)
					def 			lowerCamelCase__(				self       :Tuple				) ->   Dict:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()
												a__					=					True

												for model_class in self.all_model_classes:
																			a__					=					True
																			a__					=					False
																			a__					=					True
																			a__					=					model_class(__snake_case				)
																			model.to(__snake_case				)
																			model.eval()
																			with torch.no_grad():
																										a__					=					model(**self._prepare_for_class(__snake_case      ,__snake_case				)				)
																			a__					=					outputs.attentions
																			a__					=					len(self.model_tester.depths				)
																			self.assertEqual(len(__snake_case				)      ,__snake_case				)

																			# check that output_attentions also work using config
																			del inputs_dict["output_attentions"]
																			a__					=					True
																			a__					=					config.window_size**2
																			a__					=					model_class(__snake_case				)
																			model.to(__snake_case				)
																			model.eval()
																			with torch.no_grad():
																										a__					=					model(**self._prepare_for_class(__snake_case      ,__snake_case				)				)
																			a__					=					outputs.attentions
																			self.assertEqual(len(__snake_case				)      ,__snake_case				)

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

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

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

																			a__					=					outputs.attentions

																			self.assertEqual(len(__snake_case				)      ,__snake_case				)

																			self.assertListEqual(
																			    list(self_attentions[0].shape[-3:]				)      ,[self.model_tester.num_heads[0], window_size_squared, window_size_squared]      ,)
					def 			lowerCamelCase__(				self       :Any      ,__snake_case       :Any      ,__snake_case       :List[str]      ,__snake_case       :List[Any]      ,__snake_case       :Any				) ->   List[str]:
												a__					=					model_class(__snake_case				)
												model.to(__snake_case				)
												model.eval()

												with torch.no_grad():
																			a__					=					model(**self._prepare_for_class(__snake_case      ,__snake_case				)				)

												a__					=					outputs.hidden_states

												a__					=					getattr(
												    self.model_tester      ,'expected_num_hidden_layers'      ,len(self.model_tester.depths				) + 1				)
												self.assertEqual(len(__snake_case				)      ,__snake_case				)

												# Swinv2 has a different seq_length
												a__					=					(
												    config.patch_size
												    if isinstance(config.patch_size      ,collections.abc.Iterable				)
												    else (config.patch_size, config.patch_size)
												)

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

												a__					=					outputs.reshaped_hidden_states
												self.assertEqual(len(__snake_case				)      ,__snake_case				)

												a__				, a__				, a__				, a__					=					reshaped_hidden_states[0].shape
												a__					=					(
												    reshaped_hidden_states[0].view(__snake_case      ,__snake_case      ,height * width				).permute(0      ,2      ,1				)
												)
												self.assertListEqual(
												    list(reshaped_hidden_states.shape[-2:]				)      ,[num_patches, self.model_tester.embed_dim]      ,)
					def 			lowerCamelCase__(				self       :Tuple				) ->   int:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()

												a__					=					(
												    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:
																			a__					=					True
																			self.check_hidden_states_output(__snake_case      ,__snake_case      ,__snake_case      ,__snake_case				)

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

																			self.check_hidden_states_output(__snake_case      ,__snake_case      ,__snake_case      ,__snake_case				)
					def 			lowerCamelCase__(				self       :Any				) ->   Union[str, Any]:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()
												a__					=					3

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

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

												for model_class in self.all_model_classes:
																			a__					=					True
																			self.check_hidden_states_output(__snake_case      ,__snake_case      ,__snake_case      ,(padded_height, padded_width)				)

																			# check that output_hidden_states also work using config
																			del inputs_dict["output_hidden_states"]
																			a__					=					True
																			self.check_hidden_states_output(__snake_case      ,__snake_case      ,__snake_case      ,(padded_height, padded_width)				)
					def 			lowerCamelCase__(				self       :Any				) ->   Any:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_masked_image_modeling(*__snake_case				)
					def 			lowerCamelCase__(				self       :Optional[int]				) ->   Union[str, Any]:
												a__					=					self.model_tester.prepare_config_and_inputs()
												self.model_tester.create_and_check_for_image_classification(*__snake_case				)
					@slow
					def 			lowerCamelCase__(				self       :Optional[int]				) ->   Tuple:
												for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																			a__					=					SwinvaModel.from_pretrained(__snake_case				)
																			self.assertIsNotNone(__snake_case				)



					def 			lowerCamelCase__(				self       :Optional[Any]				) ->   Any:
												a__				, a__					=					self.model_tester.prepare_config_and_inputs_for_common()

												a__					=					_config_zero_init(__snake_case				)
												for model_class in self.all_model_classes:
																			a__					=					model_class(config=__snake_case				)
																			for name, param in model.named_parameters():
																										if "embeddings" not in name and "logit_scale" 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 	snake_case_       (unittest.TestCase				):
					@cached_property
					def 			lowerCamelCase__(				self       :Any				) ->   str:
												return (
												    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'				)
												    if is_vision_available()
												    else None
												)



					@slow
					def 			lowerCamelCase__(				self       :int				) ->   Any:
												a__					=					SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'				).to(
												    __snake_case				)
												a__					=					self.default_image_processor

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

												# forward pass
												with torch.no_grad():
																			a__					=					model(**__snake_case				)

												# verify the logits
												a__					=					torch.Size((1, 10_00)				)
												self.assertEqual(outputs.logits.shape      ,__snake_case				)
												a__					=					torch.tensor([-0.39_47, -0.43_06, 0.00_26]				).to(__snake_case				)
												self.assertTrue(torch.allclose(outputs.logits[0, :3]      ,__snake_case      ,atol=1E-4				)				)








from __future__ import annotations






def 							__lowercase       (			__lowerCAmelCase							:    List[Any] ,   __lowerCAmelCase							:    Optional[Any] ,   __lowerCAmelCase							:    str ,   __lowerCAmelCase							:    List[str]       ):  # noqa: E741
							while r - l > 1:
														a__					=					(l + r) // 2
														if v[m] >= key:
																					a__					=					m
														else:
																					a__					=					m  # noqa: E741
							return r






def 							__lowercase       (			__lowerCAmelCase							:    list[int]       ):
							if len(__lowerCAmelCase       ) == 0:
														return 0

							a__					=					[0] * len(__lowerCAmelCase       )
							a__					=					1

							a__					=					v[0]

							for i in range(1 ,   len(__lowerCAmelCase       )       ):
														if v[i] < tail[0]:
																					a__					=					v[i]
														elif v[i] > tail[length - 1]:
																					a__					=					v[i]
																					length += 1
														else:
																					a__					=					v[i]

							return length


if __name__ == "__main__":
						import doctest

						doctest.testmod()




