






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   __SCREAMING_SNAKE_CASE:

							'''simple docstring'''





							def __init__(     self:      List[Any]       ,	UpperCamelCase:      Any       ,	UpperCamelCase:      Union[str, Any]=13       ,	UpperCamelCase:      str=32       ,	UpperCamelCase:      Optional[int]=2       ,	UpperCamelCase:      Optional[Any]=3       ,	UpperCamelCase:      List[Any]=16       ,	UpperCamelCase:      Union[str, Any]=[1, 2, 1]       ,	UpperCamelCase:      List[Any]=[2, 2, 4]       ,	UpperCamelCase:      Union[str, Any]=2       ,	UpperCamelCase:      str=2.0       ,	UpperCamelCase:      Dict=True       ,	UpperCamelCase:      Optional[Any]=0.0       ,	UpperCamelCase:      Optional[int]=0.0       ,	UpperCamelCase:      str=0.1       ,	UpperCamelCase:      str="gelu"       ,	UpperCamelCase:      List[str]=False       ,	UpperCamelCase:      Union[str, Any]=True       ,	UpperCamelCase:      Dict=0.02       ,	UpperCamelCase:      List[str]=1e-5       ,	UpperCamelCase:      str=True       ,	UpperCamelCase:      Dict=None       ,	UpperCamelCase:      List[str]=True       ,	UpperCamelCase:      str=10       ,	UpperCamelCase:      Union[str, Any]=8       ,	)		->		Optional[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
							def lowerCAmelCase_ (     self:      Dict						)		->		Optional[int]:
											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:      List[Any]						)		->		List[str]:
											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:      List[Any]       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      str						)		->		List[Any]:
											snake_case__									=     SwinvaModel(config=UpperCamelCase						)
											model.to(UpperCamelCase						)
											model.eval()
											snake_case__									=     model(UpperCamelCase						)

											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:      Optional[int]       ,	UpperCamelCase:      str       ,	UpperCamelCase:      Dict       ,	UpperCamelCase:      Tuple						)		->		str:
											snake_case__									=     SwinvaForMaskedImageModeling(config=UpperCamelCase						)
											model.to(UpperCamelCase						)
											model.eval()
											snake_case__									=     model(UpperCamelCase						)
											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__									=     SwinvaForMaskedImageModeling(UpperCamelCase						)
											model.to(UpperCamelCase						)
											model.eval()

											snake_case__									=     floats_tensor([self.batch_size, 1, self.image_size, self.image_size]						)
											snake_case__									=     model(UpperCamelCase						)
											self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, 1, self.image_size, self.image_size)						)
							def lowerCAmelCase_ (     self:      Union[str, Any]       ,	UpperCamelCase:      Any       ,	UpperCamelCase:      Tuple       ,	UpperCamelCase:      Dict						)		->		List[Any]:
											snake_case__									=     self.type_sequence_label_size
											snake_case__									=     SwinvaForImageClassification(UpperCamelCase						)
											model.to(UpperCamelCase						)
											model.eval()
											snake_case__									=     model(UpperCamelCase       ,	labels=UpperCamelCase						)
											self.parent.assertEqual(result.logits.shape       ,	(self.batch_size, self.type_sequence_label_size)						)


							def lowerCAmelCase_ (     self:      Optional[int]						)		->		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   __SCREAMING_SNAKE_CASE(	a_    ,  a_    ,  unittest.TestCase	):

							'''simple docstring'''





							_UpperCAmelCase     =       (
							    (SwinvaModel, SwinvaForImageClassification, SwinvaForMaskedImageModeling) if is_torch_available() else ()
							)
							_UpperCAmelCase     =       (
							    {"feature-extraction": SwinvaModel, "image-classification": SwinvaForImageClassification}
							    if is_torch_available()
							    else {}
							)

							_UpperCAmelCase     =       False
							_UpperCAmelCase     =       False
							_UpperCAmelCase     =       False
							_UpperCAmelCase     =       False
							def lowerCAmelCase_ (     self:      Any						)		->		List[str]:
											snake_case__									=     SwinvaModelTester(self						)
											snake_case__									=     ConfigTester(self       ,	config_class=UpperCamelCase       ,	embed_dim=37						)
							def lowerCAmelCase_ (     self:      Any						)		->		List[str]:
											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:      Tuple						)		->		int:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*UpperCamelCase						)
							@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.'						)
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Optional[Any]:
											pass
							@unittest.skip(reason='Swinv2 does not use inputs_embeds'						)
							def lowerCAmelCase_ (     self:      Any						)		->		List[Any]:
											pass
							def lowerCAmelCase_ (     self:      int						)		->		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(UpperCamelCase						)
															self.assertIsInstance(model.get_input_embeddings()       ,	(nn.Module)						)
															snake_case__									=     model.get_output_embeddings()
															self.assertTrue(x is None or isinstance(UpperCamelCase       ,	nn.Linear						)						)
							def lowerCAmelCase_ (     self:      Tuple						)		->		int:
											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(UpperCamelCase						)
															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]       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		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(UpperCamelCase						)
															model.to(UpperCamelCase						)
															model.eval()
															with torch.no_grad():
																			snake_case__									=     model(**self._prepare_for_class(UpperCamelCase       ,	UpperCamelCase						)						)
															snake_case__									=     outputs.attentions
															snake_case__									=     len(self.model_tester.depths						)
															self.assertEqual(len(UpperCamelCase						)       ,	UpperCamelCase						)

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

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

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

															snake_case__									=     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:      int       ,	UpperCamelCase:      Optional[int]       ,	UpperCamelCase:      Union[str, Any]       ,	UpperCamelCase:      int       ,	UpperCamelCase:      Dict						)		->		str:
											snake_case__									=     model_class(UpperCamelCase						)
											model.to(UpperCamelCase						)
											model.eval()

											with torch.no_grad():
															snake_case__									=     model(**self._prepare_for_class(UpperCamelCase       ,	UpperCamelCase						)						)

											snake_case__									=     outputs.hidden_states

											snake_case__									=     getattr(
											    self.model_tester       ,	'expected_num_hidden_layers'       ,	len(self.model_tester.depths						) + 1						)
											self.assertEqual(len(UpperCamelCase						)       ,	UpperCamelCase						)

											# Swinv2 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]       ,	)

											snake_case__									=     outputs.reshaped_hidden_states
											self.assertEqual(len(UpperCamelCase						)       ,	UpperCamelCase						)

											snake_case__							,						snake_case__							,						snake_case__							,						snake_case__									=     reshaped_hidden_states[0].shape
											snake_case__									=     (
											    reshaped_hidden_states[0].view(UpperCamelCase       ,	UpperCamelCase       ,	height * width						).permute(0       ,	2       ,	1						)
											)
											self.assertListEqual(
											    list(reshaped_hidden_states.shape[-2:]						)       ,	[num_patches, self.model_tester.embed_dim]       ,	)
							def lowerCAmelCase_ (     self:      int						)		->		int:
											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(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase						)

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

															self.check_hidden_states_output(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase						)
							def lowerCAmelCase_ (     self:      Dict						)		->		List[str]:
											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(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	(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(UpperCamelCase       ,	UpperCamelCase       ,	UpperCamelCase       ,	(padded_height, padded_width)						)
							def lowerCAmelCase_ (     self:      Union[str, Any]						)		->		Union[str, Any]:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_masked_image_modeling(*UpperCamelCase						)
							def lowerCAmelCase_ (     self:      str						)		->		Optional[int]:
											snake_case__									=     self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_for_image_classification(*UpperCamelCase						)
							@slow
							def lowerCAmelCase_ (     self:      Any						)		->		Optional[Any]:
											for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
															snake_case__									=     SwinvaModel.from_pretrained(UpperCamelCase						)
															self.assertIsNotNone(UpperCamelCase						)


							def lowerCAmelCase_ (     self:      Any						)		->		Tuple:
											snake_case__							,						snake_case__									=     self.model_tester.prepare_config_and_inputs_for_common()

											snake_case__									=     _config_zero_init(UpperCamelCase						)
											for model_class in self.all_model_classes:
															snake_case__									=     model_class(config=UpperCamelCase						)
															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   __SCREAMING_SNAKE_CASE(	unittest.TestCase	):

							'''simple docstring'''





							@cached_property
							def lowerCAmelCase_ (     self:      Any						)		->		Any:
											return (
											    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'						)
											    if is_vision_available()
											    else None
											)


							@slow
							def lowerCAmelCase_ (     self:      Optional[Any]						)		->		Optional[int]:
											snake_case__									=     SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256'						).to(
											    UpperCamelCase						)
											snake_case__									=     self.default_image_processor

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

											# forward pass
											with torch.no_grad():
															snake_case__									=     model(**UpperCamelCase						)

											# verify the logits
											snake_case__									=     torch.Size((1, 10_00)						)
											self.assertEqual(outputs.logits.shape       ,	UpperCamelCase						)
											snake_case__									=     torch.tensor([-0.3_947, -0.4_306, 0.0_026]						).to(UpperCamelCase						)
											self.assertTrue(torch.allclose(outputs.logits[0, :3]       ,	UpperCamelCase       ,	atol=1e-4						)						)












def      a_ (      _A      ,   _A  )			->			str:







				"""simple docstring"""
				if number < 0 or shift_amount < 0:
								raise ValueError('both inputs must be positive integers'  )

				snake_case__									=     str(bin(_A  )  )
				binary_number += "0" * shift_amount
				return binary_number
def      a_ (      _A      ,   _A  )			->			str:







				"""simple docstring"""
				if number < 0 or shift_amount < 0:
								raise ValueError('both inputs must be positive integers'  )

				snake_case__									=     str(bin(_A  )  )[2:]
				if shift_amount >= len(_A  ):
								return "0b0"
				snake_case__									=     binary_number[: len(_A  ) - shift_amount]
				return "0b" + shifted_binary_number
def      a_ (      _A      ,   _A  )			->			str:







				"""simple docstring"""
				if number >= 0:  # Get binary representation of positive number
								snake_case__									=     '0' + str(bin(_A  )  ).strip('-'  )[2:]
				else:  # Get binary (2's complement) representation of negative number
								snake_case__									=     len(bin(_A  )[3:]  )  # Find 2's complement of number
								snake_case__									=     bin(abs(_A  ) - (1 << binary_number_length)  )[3:]
								snake_case__									=     (
								    '1' + '0' * (binary_number_length - len(_A  )) + binary_number
								)

				if shift_amount >= len(_A  ):
								return "0b" + binary_number[0] * len(_A  )
				return (
				    "0b"
				    + binary_number[0] * shift_amount
				    + binary_number[: len(_A  ) - shift_amount]
				)


if __name__ == "__main__":
							import doctest

							doctest.testmod()




