



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	:							Union[str, Any]							,      lowerCamelCase	:							List[Any]							,      lowerCamelCase	:							int=13							,      lowerCamelCase	:							Optional[int]=32							,      lowerCamelCase	:							Tuple=2							,      lowerCamelCase	:							Tuple=3							,      lowerCamelCase	:							Dict=16							,      lowerCamelCase	:							Union[str, Any]=[1, 2, 1]							,      lowerCamelCase	:							List[Any]=[2, 2, 4]							,      lowerCamelCase	:							Optional[Any]=2							,      lowerCamelCase	:							Any=2.0							,      lowerCamelCase	:							List[str]=True							,      lowerCamelCase	:							List[str]=0.0							,      lowerCamelCase	:							int=0.0							,      lowerCamelCase	:							str=0.1							,      lowerCamelCase	:							Union[str, Any]="gelu"							,      lowerCamelCase	:							List[Any]=False							,      lowerCamelCase	:							List[str]=True							,      lowerCamelCase	:							Optional[Any]=0.02							,      lowerCamelCase	:							List[str]=1e-5							,      lowerCamelCase	:							Any=True							,      lowerCamelCase	:							Union[str, Any]=None							,      lowerCamelCase	:							str=True							,      lowerCamelCase	:							str=10							,      lowerCamelCase	:							List[Any]=8							,      lowerCamelCase	:							str=["stage1", "stage2", "stage3"]							,      lowerCamelCase	:							Dict=[1, 2, 3]							,      ):






							'''simple docstring'''



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



						def     _snake_case	(	self	:							Any	):






							'''simple docstring'''



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

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

							__lowercase		       =			self.get_config()

							return config, pixel_values, labels



						def     _snake_case	(	self	:							Optional[int]	):






							'''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     _snake_case	(	self	:							Union[str, Any]							,      lowerCamelCase	:							List[str]							,      lowerCamelCase	:							Optional[int]							,      lowerCamelCase	:							Optional[int]	):






							'''simple docstring'''



							__lowercase		       =			MaskFormerSwinModel(config=lowerCamelCase	)
							model.to(lowerCamelCase	)
							model.eval()
							__lowercase		       =			model(lowerCamelCase	)

							__lowercase		       =			((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths	) - 1))
							__lowercase		       =			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     _snake_case	(	self	:							List[Any]							,      lowerCamelCase	:							Optional[Any]							,      lowerCamelCase	:							Optional[int]							,      lowerCamelCase	:							List[Any]	):






							'''simple docstring'''



							__lowercase		       =			MaskFormerSwinBackbone(config=lowerCamelCase	)
							model.to(lowerCamelCase	)
							model.eval()
							__lowercase		       =			model(lowerCamelCase	)

							# 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(lowerCamelCase	):
								__lowercase		       =			["stem"]
								__lowercase		       =			MaskFormerSwinBackbone(config=lowerCamelCase	)



						def     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase		       =			self.prepare_config_and_inputs()
							__lowercase       ,    __lowercase       ,    __lowercase		       =			config_and_inputs
							__lowercase		       =			{"pixel_values": pixel_values}
							return config, inputs_dict

@require_torch
class   _A   ( _lowercase  ,						_lowercase  ,						unittest.TestCase	):


						'''simple docstring'''





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



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							__lowercase		       =			MaskFormerSwinModelTester(self	)
							__lowercase		       =			ConfigTester(self							,      config_class=lowerCamelCase							,      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     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



							pass



						def     _snake_case	(	self	:							List[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     _snake_case	(	self	:							List[Any]	):






							'''simple docstring'''



							return



						def     _snake_case	(	self	:							Tuple	):






							'''simple docstring'''



							__lowercase		       =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_model(*lowerCamelCase	)



						def     _snake_case	(	self	:							Dict	):






							'''simple docstring'''



							__lowercase		       =			self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_backbone(*lowerCamelCase	)



						@unittest.skip("Swin does not use inputs_embeds"	)
						def     _snake_case	(	self	:							Union[str, Any]	):






							'''simple docstring'''



							pass



						@unittest.skip("Swin does not support feedforward chunking"	)
						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							pass



						def     _snake_case	(	self	:							Dict	):






							'''simple docstring'''



							__lowercase       ,    __lowercase		       =			self.model_tester.prepare_config_and_inputs_for_common()

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



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							__lowercase       ,    __lowercase		       =			self.model_tester.prepare_config_and_inputs_for_common()

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

								__lowercase		       =			["pixel_values"]
								self.assertListEqual(arg_names[:1]							,      lowerCamelCase	)



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






							'''simple docstring'''



							pass



						@unittest.skip(reason="MaskFormerSwin is only used as an internal backbone"	)
						def     _snake_case	(	self	:							Union[str, Any]	):






							'''simple docstring'''



							pass



						def     _snake_case	(	self	:							Any							,      lowerCamelCase	:							Optional[Any]							,      lowerCamelCase	:							Optional[int]							,      lowerCamelCase	:							Optional[int]							,      lowerCamelCase	:							List[Any]	):






							'''simple docstring'''



							__lowercase		       =			model_class(lowerCamelCase	)
							model.to(lowerCamelCase	)
							model.eval()

							with torch.no_grad():
								__lowercase		       =			model(**self._prepare_for_class(lowerCamelCase							,      lowerCamelCase	)	)

							__lowercase		       =			outputs.hidden_states

							__lowercase		       =			getattr(
							    self.model_tester							,      "expected_num_hidden_layers"							,      len(self.model_tester.depths	) + 1	)
							self.assertEqual(len(lowerCamelCase	)							,      lowerCamelCase	)

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

							__lowercase		       =			(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     _snake_case	(	self	:							str	):






							'''simple docstring'''



							__lowercase       ,    __lowercase		       =			self.model_tester.prepare_config_and_inputs_for_common()

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

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

								self.check_hidden_states_output(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)



						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



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

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

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

							for model_class in self.all_model_classes:
								__lowercase		       =			True
								self.check_hidden_states_output(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      (padded_height, padded_width)	)

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



						@unittest.skip(reason="MaskFormerSwin doesn't have pretrained checkpoints"	)
						def     _snake_case	(	self	:							int	):






							'''simple docstring'''



							pass



						@unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"	)
						def     _snake_case	(	self	:							List[Any]	):






							'''simple docstring'''



							pass



						@unittest.skip(reason="This will be fixed once MaskFormerSwin is replaced by native Swin"	)
						def     _snake_case	(	self	:							Dict	):






							'''simple docstring'''



							pass



						def     _snake_case	(	self	:							Optional[Any]	):






							'''simple docstring'''



							__lowercase       ,    __lowercase		       =			self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(lowerCamelCase	:							Optional[Any]	):
								__lowercase		       =			0
								return t

							def check_equivalence(lowerCamelCase	:							int							,      lowerCamelCase	:							Any							,      lowerCamelCase	:							Optional[int]							,      lowerCamelCase	:							int={}	):
								with torch.no_grad():
									__lowercase		       =			model(**lowerCamelCase							,      return_dict=lowerCamelCase							,      **lowerCamelCase	)
									__lowercase		       =			model(**lowerCamelCase							,      return_dict=lowerCamelCase							,      **lowerCamelCase	).to_tuple()

									def recursive_check(lowerCamelCase	:							Any							,      lowerCamelCase	:							int	):
										if isinstance(lowerCamelCase							,      (List, Tuple)	):
											for tuple_iterable_value, dict_iterable_value in zip(lowerCamelCase							,      lowerCamelCase	):
												recursive_check(lowerCamelCase							,      lowerCamelCase	)
										elif isinstance(lowerCamelCase							,      lowerCamelCase	):
											for tuple_iterable_value, dict_iterable_value in zip(
											    tuple_object.values()							,      dict_object.values()	):
												recursive_check(lowerCamelCase							,      lowerCamelCase	)
										elif tuple_object is None:
											return
										else:
											self.assertTrue(
											    torch.allclose(
											        set_nan_tensor_to_zero(lowerCamelCase	)							,      set_nan_tensor_to_zero(lowerCamelCase	)							,      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(lowerCamelCase	).any()} and `inf`: {torch.isinf(lowerCamelCase	)}. Dict has"""
											        f""" `nan`: {torch.isnan(lowerCamelCase	).any()} and `inf`: {torch.isinf(lowerCamelCase	)}."""
											    )							,      )

									recursive_check(lowerCamelCase							,      lowerCamelCase	)

							for model_class in self.all_model_classes:
								__lowercase		       =			model_class(lowerCamelCase	)
								model.to(lowerCamelCase	)
								model.eval()

								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase	)
								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase	)
								check_equivalence(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)

								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase							,      return_labels=lowerCamelCase	)
								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase							,      return_labels=lowerCamelCase	)
								check_equivalence(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase	)

								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase	)
								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase	)
								check_equivalence(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      {"output_hidden_states": True}	)

								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase							,      return_labels=lowerCamelCase	)
								__lowercase		       =			self._prepare_for_class(lowerCamelCase							,      lowerCamelCase							,      return_labels=lowerCamelCase	)
								check_equivalence(lowerCamelCase							,      lowerCamelCase							,      lowerCamelCase							,      {"output_hidden_states": True}	)

@require_torch
class   _A   ( unittest.TestCase  ,						_lowercase	):


						'''simple docstring'''





						_snake_case			:     Any      							=      (MaskFormerSwinBackbone,) if is_torch_available() else ()
						_snake_case			:     Tuple      							=      MaskFormerSwinConfig



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



							__lowercase		       =			MaskFormerSwinModelTester(self	)



						def     _snake_case	(	self	:							Optional[int]	):






							'''simple docstring'''



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

							for backbone_class in self.all_model_classes:
								__lowercase		       =			backbone_class(lowerCamelCase	)
								backbone.to(lowerCamelCase	)
								backbone.eval()

								__lowercase		       =			backbone(**lowerCamelCase	)

								# Test default outputs and verify feature maps
								self.assertIsInstance(outputs.feature_maps							,      lowerCamelCase	)
								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
								__lowercase		       =			backbone(**lowerCamelCase							,      output_hidden_states=lowerCamelCase	)
								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)
										__lowercase       ,    __lowercase       ,    __lowercase		       =			hidden_state.shape
										self.assertTrue((h_batch_size, h_n_channels)							,      (batch_size, n_channels)	)

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








from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ...utils.backbone_utils import BackboneConfigMixin, get_aligned_output_features_output_indices


snake_case__					:     Any    		=   logging.get_logger(__name__)

class   _A   ( _lowercase  ,						_lowercase	):


						'''simple docstring'''





						_snake_case			:     Dict      							=      """maskformer-swin"""

						_snake_case			:     List[str]      							=      {
						    """num_attention_heads""": """num_heads""",
						    """num_hidden_layers""": """num_layers""",
						}



						def __init__(	self	:							List[str]							,      lowerCamelCase	:							Any=224							,      lowerCamelCase	:							Optional[Any]=4							,      lowerCamelCase	:							Dict=3							,      lowerCamelCase	:							Tuple=96							,      lowerCamelCase	:							str=[2, 2, 6, 2]							,      lowerCamelCase	:							Dict=[3, 6, 12, 24]							,      lowerCamelCase	:							Optional[Any]=7							,      lowerCamelCase	:							Any=4.0							,      lowerCamelCase	:							Union[str, Any]=True							,      lowerCamelCase	:							List[str]=0.0							,      lowerCamelCase	:							Optional[int]=0.0							,      lowerCamelCase	:							List[str]=0.1							,      lowerCamelCase	:							int="gelu"							,      lowerCamelCase	:							Optional[int]=False							,      lowerCamelCase	:							List[Any]=0.02							,      lowerCamelCase	:							Tuple=1e-5							,      lowerCamelCase	:							Dict=None							,      lowerCamelCase	:							Dict=None							,      **lowerCamelCase	:							int							,      ):






							'''simple docstring'''



							super().__init__(**lowerCamelCase	)

							__lowercase		       =			image_size
							__lowercase		       =			patch_size
							__lowercase		       =			num_channels
							__lowercase		       =			embed_dim
							__lowercase		       =			depths
							__lowercase		       =			len(lowerCamelCase	)
							__lowercase		       =			num_heads
							__lowercase		       =			window_size
							__lowercase		       =			mlp_ratio
							__lowercase		       =			qkv_bias
							__lowercase		       =			hidden_dropout_prob
							__lowercase		       =			attention_probs_dropout_prob
							__lowercase		       =			drop_path_rate
							__lowercase		       =			hidden_act
							__lowercase		       =			use_absolute_embeddings
							__lowercase		       =			layer_norm_eps
							__lowercase		       =			initializer_range
							# we set the hidden_size attribute in order to make Swin work with VisionEncoderDecoderModel
							# this indicates the channel dimension after the last stage of the model
							__lowercase		       =			int(embed_dim * 2 ** (len(lowerCamelCase	) - 1)	)
							__lowercase		       =			["stem"] + [f"""stage{idx}""" for idx in range(1							,      len(lowerCamelCase	) + 1	)]
							__lowercase       ,    __lowercase		       =			get_aligned_output_features_output_indices(
							    out_features=lowerCamelCase							,      out_indices=lowerCamelCase							,      stage_names=self.stage_names	)



