


"""simple docstring"""
import collections
import inspect
import unittest
from typing import Dict, List, Tuple

from transformers import MaskFormerSwinConfig
from transformers.testing_utils import require_torch, require_torch_multi_gpu, torch_device
from transformers.utils import is_torch_available

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


if is_torch_available():
				import torch
				from torch import nn

				from transformers import MaskFormerSwinBackbone
				from transformers.models.maskformer import MaskFormerSwinModel





class      __A     :





							'''simple docstring'''

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



														"""simple docstring"""



														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							:      str       )					->List[str]:



														"""simple docstring"""



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



														"""simple docstring"""



														return MaskFormerSwinConfig(
														    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							:      str		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      List[Any]       )					->Dict:



														"""simple docstring"""



														snake_case_           =		MaskFormerSwinModel(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_							:      str		,       UpperCAmelCase_							:      Tuple       )					->Tuple:



														"""simple docstring"""



														snake_case_           =		MaskFormerSwinBackbone(config=UpperCAmelCase_       )
														model.to(UpperCAmelCase_       )
														model.eval()
														snake_case_           =		model(UpperCAmelCase_       )

														# verify feature maps
														self.parent.assertEqual(len(result.feature_maps       )		,       len(config.out_features       )       )
														self.parent.assertListEqual(list(result.feature_maps[0].shape       )		,       [13, 16, 16, 16]       )

														# verify channels
														self.parent.assertEqual(len(model.channels       )		,       len(config.out_features       )       )
														self.parent.assertListEqual(model.channels		,       [16, 32, 64]       )

														# verify ValueError
														with self.parent.assertRaises(UpperCAmelCase_       ):
																					snake_case_           =		["""stem"""]
																					snake_case_           =		MaskFormerSwinBackbone(config=UpperCAmelCase_       )



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



														"""simple docstring"""



														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      __A     (snake_case__						,		snake_case__						,		unittest.TestCase):





							'''simple docstring'''

							__lowercase:		Optional[Any]							      =    (
							    (
							        MaskFormerSwinModel,
							        MaskFormerSwinBackbone,
							    )
							    if is_torch_available()
							    else ()
							)
							__lowercase:		Tuple							      =    {"""feature-extraction""": MaskFormerSwinModel} if is_torch_available() else {}
							__lowercase:		Tuple							      =    False
							__lowercase:		Optional[int]							      =    False
							__lowercase:		Dict							      =    False
							__lowercase:		int							      =    False
							__lowercase:		List[str]							      =    False



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



														"""simple docstring"""



														snake_case_           =		MaskFormerSwinModelTester(self       )
														snake_case_           =		ConfigTester(self		,       config_class=UpperCAmelCase_		,       embed_dim=37       )



							@require_torch_multi_gpu
							@unittest.skip(
							    reason=(
							        """`MaskFormerSwinModel` outputs `hidden_states_spatial_dimensions` which doesn't work well with"""
							        """ `nn.DataParallel`"""
							    )       )
							def 		lowerCAmelCase       (				self							:      int       )					->Any:



														"""simple docstring"""



														pass



							def 		lowerCAmelCase       (				self							:      int       )					->Union[str, 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 		lowerCAmelCase       (				self							:      Any       )					->Tuple:



														"""simple docstring"""



														return



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



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_model(*UpperCAmelCase_       )



							def 		lowerCAmelCase       (				self							:      Dict       )					->int:



														"""simple docstring"""



														snake_case_           =		self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_backbone(*UpperCAmelCase_       )



							@unittest.skip("""Swin does not use inputs_embeds"""       )
							def 		lowerCAmelCase       (				self							:      Optional[Any]       )					->int:



														"""simple docstring"""



														pass



							@unittest.skip("""Swin does not support feedforward chunking"""       )
							def 		lowerCAmelCase       (				self							:      Any       )					->int:



														"""simple docstring"""



														pass



							def 		lowerCAmelCase       (				self							:      List[Any]       )					->int:



														"""simple docstring"""



														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							:      Optional[Any]       )					->List[str]:



														"""simple docstring"""



														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_       )



							@unittest.skip(reason="""MaskFormerSwin is only used as backbone and doesn't support output_attentions"""       )
							def 		lowerCAmelCase       (				self							:      List[str]       )					->Optional[Any]:



														"""simple docstring"""



														pass



							@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""       )
							def 		lowerCAmelCase       (				self							:      int       )					->Tuple:



														"""simple docstring"""



														pass



							def 		lowerCAmelCase       (				self							:      Dict		,       UpperCAmelCase_							:      Tuple		,       UpperCAmelCase_							:      Optional[int]		,       UpperCAmelCase_							:      Optional[Any]		,       UpperCAmelCase_							:      Optional[Any]       )					->Optional[int]:



														"""simple docstring"""



														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_       )

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



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



														"""simple docstring"""



														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							:      Optional[int]       )					->List[str]:



														"""simple docstring"""



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



							@unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""       )
							def 		lowerCAmelCase       (				self							:      str       )					->Optional[int]:



														"""simple docstring"""



														pass



							@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""       )
							def 		lowerCAmelCase       (				self							:      Optional[int]       )					->List[str]:



														"""simple docstring"""



														pass



							@unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""       )
							def 		lowerCAmelCase       (				self							:      int       )					->Optional[int]:



														"""simple docstring"""



														pass



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



														"""simple docstring"""



														snake_case_       ,						snake_case_           =		self.model_tester.prepare_config_and_inputs_for_common()

														def set_nan_tensor_to_zero(UpperCAmelCase_							:      List[Any]       ):
																					snake_case_           =		0
																					return t

														def check_equivalence(UpperCAmelCase_							:      str		,       UpperCAmelCase_							:      List[Any]		,       UpperCAmelCase_							:      int		,       UpperCAmelCase_							:      Optional[int]={}       ):
																					with torch.no_grad():
																												snake_case_           =		model(**UpperCAmelCase_		,       return_dict=UpperCAmelCase_		,       **UpperCAmelCase_       )
																												snake_case_           =		model(**UpperCAmelCase_		,       return_dict=UpperCAmelCase_		,       **UpperCAmelCase_       ).to_tuple()

																												def recursive_check(UpperCAmelCase_							:      Any		,       UpperCAmelCase_							:      Optional[int]       ):
																																			if isinstance(UpperCAmelCase_		,       (List, Tuple)       ):
																																										for tuple_iterable_value, dict_iterable_value in zip(UpperCAmelCase_		,       UpperCAmelCase_       ):
																																																	recursive_check(UpperCAmelCase_		,       UpperCAmelCase_       )
																																			elif isinstance(UpperCAmelCase_		,       UpperCAmelCase_       ):
																																										for tuple_iterable_value, dict_iterable_value in zip(
																																										    tuple_object.values()		,       dict_object.values()       ):
																																																	recursive_check(UpperCAmelCase_		,       UpperCAmelCase_       )
																																			elif tuple_object is None:
																																										return
																																			else:
																																										self.assertTrue(
																																										    torch.allclose(
																																										        set_nan_tensor_to_zero(UpperCAmelCase_       )		,       set_nan_tensor_to_zero(UpperCAmelCase_       )		,       atol=1E-5       )		,       msg=(
																																										        """Tuple and dict output are not equal. Difference:"""
																																										        F""" {torch.max(torch.abs(tuple_object - dict_object       )       )}. Tuple has `nan`:"""
																																										        F""" {torch.isnan(UpperCAmelCase_       ).any()} and `inf`: {torch.isinf(UpperCAmelCase_       )}. Dict has"""
																																										        F""" `nan`: {torch.isnan(UpperCAmelCase_       ).any()} and `inf`: {torch.isinf(UpperCAmelCase_       )}."""
																																										    )		,       )

																												recursive_check(UpperCAmelCase_		,       UpperCAmelCase_       )

														for model_class in self.all_model_classes:
																					snake_case_           =		model_class(UpperCAmelCase_       )
																					model.to(UpperCAmelCase_       )
																					model.eval()

																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_       )
																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_       )
																					check_equivalence(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )

																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																					check_equivalence(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_       )

																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_       )
																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_       )
																					check_equivalence(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       {"""output_hidden_states""": True}       )

																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																					snake_case_           =		self._prepare_for_class(UpperCAmelCase_		,       UpperCAmelCase_		,       return_labels=UpperCAmelCase_       )
																					check_equivalence(UpperCAmelCase_		,       UpperCAmelCase_		,       UpperCAmelCase_		,       {"""output_hidden_states""": True}       )





@require_torch
class      __A     (unittest.TestCase						,		snake_case__):





							'''simple docstring'''

							__lowercase:		Union[str, Any]							      =    (MaskFormerSwinBackbone,) if is_torch_available() else ()
							__lowercase:		Tuple							      =    MaskFormerSwinConfig



							def 		lowerCAmelCase       (				self							:      str       )					->Any:



														"""simple docstring"""



														snake_case_           =		MaskFormerSwinModelTester(self       )



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



														"""simple docstring"""



														snake_case_       ,						snake_case_           =		self.model_tester.prepare_config_and_inputs_for_common()
														snake_case_           =		inputs_dict["""pixel_values"""].shape[0]

														for backbone_class in self.all_model_classes:
																					snake_case_           =		backbone_class(UpperCAmelCase_       )
																					backbone.to(UpperCAmelCase_       )
																					backbone.eval()

																					snake_case_           =		backbone(**UpperCAmelCase_       )

																					# Test default outputs and verify feature maps
																					self.assertIsInstance(outputs.feature_maps		,       UpperCAmelCase_       )
																					self.assertTrue(len(outputs.feature_maps       ) == len(backbone.channels       )       )
																					for feature_map, n_channels in zip(outputs.feature_maps		,       backbone.channels       ):
																												self.assertTrue(feature_map.shape[:2]		,       (batch_size, n_channels)       )
																					self.assertIsNone(outputs.hidden_states       )
																					self.assertIsNone(outputs.attentions       )

																					# Test output_hidden_states=True
																					snake_case_           =		backbone(**UpperCAmelCase_		,       output_hidden_states=UpperCAmelCase_       )
																					self.assertIsNotNone(outputs.hidden_states       )
																					self.assertTrue(len(outputs.hidden_states       )		,       len(backbone.stage_names       )       )
																					# We skip the stem layer
																					for hidden_states, n_channels in zip(outputs.hidden_states[1:]		,       backbone.channels       ):
																												for hidden_state in hidden_states:
																																			# Hidden states are in the format (batch_size, (height * width), n_channels)
																																			snake_case_       ,						snake_case_       ,						snake_case_           =		hidden_state.shape
																																			self.assertTrue((h_batch_size, h_n_channels)		,       (batch_size, n_channels)       )

            # Test output_attentions=True
																					if self.has_attentions:
																												snake_case_           =		backbone(**UpperCAmelCase_		,       output_attentions=UpperCAmelCase_       )
																												self.assertIsNotNone(outputs.attentions       )







"""simple docstring"""
def 						_a				(      _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)    ->				int:
							if index == number_of_items:
														return 0
							snake_case_           =		0
							snake_case_           =		0
							snake_case_           =		knapsack(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, index + 1				)
							if weights[index] <= max_weight:
														snake_case_           =		values[index] + knapsack(
														    _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				, max_weight - weights[index]				, index + 1				)
							return max(_SCREAMING_SNAKE_CASE				, _SCREAMING_SNAKE_CASE				)


if __name__ == "__main__":
				import doctest

				doctest.testmod()



