



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

			'''simple docstring'''





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



						"""simple docstring"""






						_UpperCAmelCase	 =     parent
						_UpperCAmelCase	 =     batch_size
						_UpperCAmelCase	 =     image_size
						_UpperCAmelCase	 =     patch_size
						_UpperCAmelCase	 =     num_channels
						_UpperCAmelCase	 =     embed_dim
						_UpperCAmelCase	 =     depths
						_UpperCAmelCase	 =     num_heads
						_UpperCAmelCase	 =     window_size
						_UpperCAmelCase	 =     mlp_ratio
						_UpperCAmelCase	 =     qkv_bias
						_UpperCAmelCase	 =     hidden_dropout_prob
						_UpperCAmelCase	 =     attention_probs_dropout_prob
						_UpperCAmelCase	 =     drop_path_rate
						_UpperCAmelCase	 =     hidden_act
						_UpperCAmelCase	 =     use_absolute_embeddings
						_UpperCAmelCase	 =     patch_norm
						_UpperCAmelCase	 =     layer_norm_eps
						_UpperCAmelCase	 =     initializer_range
						_UpperCAmelCase	 =     is_training
						_UpperCAmelCase	 =     scope
						_UpperCAmelCase	 =     use_labels
						_UpperCAmelCase	 =     type_sequence_label_size
						_UpperCAmelCase	 =     encoder_stride



			def 					_lowerCamelCase (		self     :						int)     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size])

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

						_UpperCAmelCase	 =     self.get_config()

						return config, pixel_values, labels



			def 					_lowerCamelCase (		self     :						Tuple)     ->					List[Any]:



						"""simple docstring"""






						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]				,	A     :						List[Any]				,	A     :						int				,	A     :						List[str])     ->					int:



						"""simple docstring"""






						_UpperCAmelCase	 =     SwinvaModel(config=A)
						model.to(A)
						model.eval()
						_UpperCAmelCase	 =     model(A)

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



						"""simple docstring"""






						_UpperCAmelCase	 =     SwinvaForMaskedImageModeling(config=A)
						model.to(A)
						model.eval()
						_UpperCAmelCase	 =     model(A)
						self.parent.assertEqual(
						    result.logits.shape				,	(self.batch_size, self.num_channels, self.image_size, self.image_size))

						# test greyscale images
						_UpperCAmelCase	 =     1
						_UpperCAmelCase	 =     SwinvaForMaskedImageModeling(A)
						model.to(A)
						model.eval()

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



			def 					_lowerCamelCase (		self     :						Optional[int]				,	A     :						List[Any]				,	A     :						Optional[Any]				,	A     :						List[Any])     ->					Dict:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.type_sequence_label_size
						_UpperCAmelCase	 =     SwinvaForImageClassification(A)
						model.to(A)
						model.eval()
						_UpperCAmelCase	 =     model(A				,	labels=A)
						self.parent.assertEqual(result.logits.shape				,	(self.batch_size, self.type_sequence_label_size))



			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.prepare_config_and_inputs()
						_UpperCAmelCase ,  _UpperCAmelCase ,  _UpperCAmelCase	 =     config_and_inputs
						_UpperCAmelCase	 =     {'pixel_values': pixel_values}
						return config, inputs_dict







@require_torch
class     __lowerCAmelCase					(    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)     ->					int:



						"""simple docstring"""






						_UpperCAmelCase	 =     SwinvaModelTester(self)
						_UpperCAmelCase	 =     ConfigTester(self				,	config_class=A				,	embed_dim=37)



			def 					_lowerCamelCase (		self     :						Any)     ->					List[str]:



						"""simple docstring"""






						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     :						Any)     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_model(*A)



			@unittest.skip(reason='Got `CUDA error: misaligned address` with PyTorch 2.0.0.')
			def 					_lowerCamelCase (		self     :						Optional[int])     ->					List[Any]:



						"""simple docstring"""






						pass



			@unittest.skip(reason='Swinv2 does not use inputs_embeds')
			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Dict:



						"""simple docstring"""






						pass



			def 					_lowerCamelCase (		self     :						Optional[int])     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
									_UpperCAmelCase	 =     model_class(A)
									self.assertIsInstance(model.get_input_embeddings()				,	(nn.Module))
									_UpperCAmelCase	 =     model.get_output_embeddings()
									self.assertTrue(x is None or isinstance(A				,	nn.Linear))



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()

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

									_UpperCAmelCase	 =     ['pixel_values']
									self.assertListEqual(arg_names[:1]				,	A)



			def 					_lowerCamelCase (		self     :						List[Any])     ->					Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()
						_UpperCAmelCase	 =     True

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

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

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

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

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

									_UpperCAmelCase	 =     outputs.attentions

									self.assertEqual(len(A)				,	A)

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



			def 					_lowerCamelCase (		self     :						str				,	A     :						str				,	A     :						Union[str, Any]				,	A     :						Optional[Any]				,	A     :						Optional[Any])     ->					Union[str, Any]:



						"""simple docstring"""






						_UpperCAmelCase	 =     model_class(A)
						model.to(A)
						model.eval()

						with torch.no_grad():
									_UpperCAmelCase	 =     model(**self._prepare_for_class(A				,	A))

						_UpperCAmelCase	 =     outputs.hidden_states

						_UpperCAmelCase	 =     getattr(
						    self.model_tester				,	'expected_num_hidden_layers'				,	len(self.model_tester.depths) + 1)
						self.assertEqual(len(A)				,	A)

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

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

						_UpperCAmelCase	 =     outputs.reshaped_hidden_states
						self.assertEqual(len(A)				,	A)

						_UpperCAmelCase ,  _UpperCAmelCase ,  _UpperCAmelCase ,  _UpperCAmelCase	 =     reshaped_hidden_states[0].shape
						_UpperCAmelCase	 =     (
						    reshaped_hidden_states[0].view(A				,	A				,	height * width).permute(0				,	2				,	1)
						)
						self.assertListEqual(
						    list(reshaped_hidden_states.shape[-2:])				,	[num_patches, self.model_tester.embed_dim]				,	)



			def 					_lowerCamelCase (		self     :						Optional[int])     ->					str:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()

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

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

									self.check_hidden_states_output(A				,	A				,	A				,	A)



			def 					_lowerCamelCase (		self     :						Dict)     ->					Optional[Any]:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()
						_UpperCAmelCase	 =     3

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

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

						for model_class in self.all_model_classes:
									_UpperCAmelCase	 =     True
									self.check_hidden_states_output(A				,	A				,	A				,	(padded_height, padded_width))

									# check that output_hidden_states also work using config
									del inputs_dict["output_hidden_states"]
									_UpperCAmelCase	 =     True
									self.check_hidden_states_output(A				,	A				,	A				,	(padded_height, padded_width))



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_masked_image_modeling(*A)



			def 					_lowerCamelCase (		self     :						Optional[int])     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_for_image_classification(*A)



			@slow
			def 					_lowerCamelCase (		self     :						List[Any])     ->					List[str]:



						"""simple docstring"""






						for model_name in SWINV2_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
									_UpperCAmelCase	 =     SwinvaModel.from_pretrained(A)
									self.assertIsNotNone(A)



			def 					_lowerCamelCase (		self     :						str)     ->					int:



						"""simple docstring"""






						_UpperCAmelCase ,  _UpperCAmelCase	 =     self.model_tester.prepare_config_and_inputs_for_common()

						_UpperCAmelCase	 =     _config_zero_init(A)
						for model_class in self.all_model_classes:
									_UpperCAmelCase	 =     model_class(config=A)
									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     __lowerCAmelCase					(    unittest.TestCase		):

			'''simple docstring'''





			@cached_property
			def 					_lowerCamelCase (		self     :						Union[str, Any])     ->					Optional[Any]:



						"""simple docstring"""






						return (
						    AutoImageProcessor.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256')
						    if is_vision_available()
						    else None
						)



			@slow
			def 					_lowerCamelCase (		self     :						Any)     ->					str:



						"""simple docstring"""






						_UpperCAmelCase	 =     SwinvaForImageClassification.from_pretrained('microsoft/swinv2-tiny-patch4-window8-256').to(
						    A)
						_UpperCAmelCase	 =     self.default_image_processor

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

						# forward pass
						with torch.no_grad():
									_UpperCAmelCase	 =     model(**A)

						# verify the logits
						_UpperCAmelCase	 =     torch.Size((1, 10_00))
						self.assertEqual(outputs.logits.shape				,	A)
						_UpperCAmelCase	 =     torch.tensor([-0.3_9_4_7, -0.4_3_0_6, 0.0_0_2_6]).to(A)
						self.assertTrue(torch.allclose(outputs.logits[0, :3]				,	A				,	atol=1E-4))





import unittest

from knapsack import knapsack as k







class     __lowerCAmelCase					(    unittest.TestCase		):



			def 					_lowerCamelCase (		self     :						Optional[Any])     ->					Any:



						"""simple docstring"""






						_UpperCAmelCase	 =     0
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     [0]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)

						_UpperCAmelCase	 =     [60]
						_UpperCAmelCase	 =     [10]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	0)



			def 					_lowerCamelCase (		self     :						str)     ->					List[str]:



						"""simple docstring"""






						_UpperCAmelCase	 =     3
						_UpperCAmelCase	 =     [1, 2, 3]
						_UpperCAmelCase	 =     [3, 2, 1]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	5)



			def 					_lowerCamelCase (		self     :						Tuple)     ->					Tuple:



						"""simple docstring"""






						_UpperCAmelCase	 =     50
						_UpperCAmelCase	 =     [60, 1_00, 1_20]
						_UpperCAmelCase	 =     [10, 20, 30]
						_UpperCAmelCase	 =     len(A)
						self.assertEqual(k.knapsack(A				,	A				,	A				,	A)				,	2_20)


if __name__ == "__main__":
							unittest.main()
