






"""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   UpperCamelCase_ :



  def __init__(      self ,		snake_case__ ,		snake_case__=13 ,		snake_case__=32 ,		snake_case__=2 ,		snake_case__=3 ,		snake_case__=16 ,		snake_case__=[1, 2, 1] ,		snake_case__=[2, 2, 4] ,		snake_case__=2 ,		snake_case__=2.0 ,		snake_case__=True ,		snake_case__=0.0 ,		snake_case__=0.0 ,		snake_case__=0.1 ,		snake_case__="gelu" ,		snake_case__=False ,		snake_case__=True ,		snake_case__=0.02 ,		snake_case__=1e-5 ,		snake_case__=True ,		snake_case__=None ,		snake_case__=True ,		snake_case__=10 ,		snake_case__=8 ,		snake_case__=["stage1", "stage2", "stage3"] ,		snake_case__=[1, 2, 3] ,		)			->			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
         UpperCAmelCase	    =			out_features
         UpperCAmelCase	    =			out_indices



  def 		UpperCamelCase_				(      self				)			->			Any:



         """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 		UpperCamelCase_				(      self				)			->			Tuple:



         """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 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			str:



         """simple docstring"""





         UpperCAmelCase	    =			MaskFormerSwinModel(config=snake_case__				)
         model.to(snake_case__				)
         model.eval()
         UpperCAmelCase	    =			model(snake_case__				)

         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 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase	    =			MaskFormerSwinBackbone(config=snake_case__				)
         model.to(snake_case__				)
         model.eval()
         UpperCAmelCase	    =			model(snake_case__				)

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



  def 		UpperCamelCase_				(      self				)			->			int:



         """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   UpperCamelCase_ (       a_   ,					a_   ,					unittest.TestCase  ):
  _A       :					Optional[Any]				=	(
      (
          MaskFormerSwinModel,
          MaskFormerSwinBackbone,
      )
      if is_torch_available()
      else ()
  )
  _A       :					str				=	{'feature-extraction': MaskFormerSwinModel} if is_torch_available() else {}
  _A       :					int				=	False
  _A       :					Optional[int]				=	False
  _A       :					Optional[Any]				=	False
  _A       :					Optional[Any]				=	False
  _A       :					Tuple				=	False



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



         """simple docstring"""





         UpperCAmelCase	    =			MaskFormerSwinModelTester(self				)
         UpperCAmelCase	    =			ConfigTester(self ,		config_class=snake_case__ ,		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 		UpperCamelCase_				(      self				)			->			Optional[int]:



         """simple docstring"""





         pass



  def 		UpperCamelCase_				(      self				)			->			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 		UpperCamelCase_				(      self				)			->			str:



         """simple docstring"""





         return



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



         """simple docstring"""





         UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_backbone(*snake_case__				)



  @unittest.skip("""Swin does not use inputs_embeds"""				)
  def 		UpperCamelCase_				(      self				)			->			List[str]:



         """simple docstring"""





         pass



  @unittest.skip("""Swin does not support feedforward chunking"""				)
  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         pass



  def 		UpperCamelCase_				(      self				)			->			int:



         """simple docstring"""





         UpperCAmelCase    ,       UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs_for_common()

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



  def 		UpperCamelCase_				(      self				)			->			Optional[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(snake_case__				)
                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] ,		snake_case__				)



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



         """simple docstring"""





         pass



  @unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""				)
  def 		UpperCamelCase_				(      self				)			->			Optional[int]:



         """simple docstring"""





         pass



  def 		UpperCamelCase_				(      self ,		snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)			->			int:



         """simple docstring"""





         UpperCAmelCase	    =			model_class(snake_case__				)
         model.to(snake_case__				)
         model.eval()

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

         UpperCAmelCase	    =			outputs.hidden_states

         UpperCAmelCase	    =			getattr(
             self.model_tester ,		"""expected_num_hidden_layers""" ,		len(self.model_tester.depths				) + 1				)
         self.assertEqual(len(snake_case__				) ,		snake_case__				)

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



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



         """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(snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)

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

                self.check_hidden_states_output(snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__				)



  def 		UpperCamelCase_				(      self				)			->			List[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(snake_case__ ,		snake_case__ ,		snake_case__ ,		(padded_height, padded_width)				)

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



  @unittest.skip(reason="""MaskFormerSwin doesn't have pretrained checkpoints"""				)
  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





         pass



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



         """simple docstring"""





         pass



  @unittest.skip(reason="""This will be fixed once MaskFormerSwin is replaced by native Swin"""				)
  def 		UpperCamelCase_				(      self				)			->			Union[str, Any]:



         """simple docstring"""





         pass



  def 		UpperCamelCase_				(      self				)			->			Any:



         """simple docstring"""





         UpperCAmelCase    ,       UpperCAmelCase	    =			self.model_tester.prepare_config_and_inputs_for_common()

         def set_nan_tensor_to_zero(snake_case__				):
                UpperCAmelCase	    =			0
                return t

         def check_equivalence(snake_case__ ,		snake_case__ ,		snake_case__ ,		snake_case__={}				):
                with torch.no_grad():
                       UpperCAmelCase	    =			model(**snake_case__ ,		return_dict=snake_case__ ,		**snake_case__				)
                       UpperCAmelCase	    =			model(**snake_case__ ,		return_dict=snake_case__ ,		**snake_case__				).to_tuple()

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

                       recursive_check(snake_case__ ,		snake_case__				)

         for model_class in self.all_model_classes:
                UpperCAmelCase	    =			model_class(snake_case__				)
                model.to(snake_case__				)
                model.eval()

                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__				)
                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__				)
                check_equivalence(snake_case__ ,		snake_case__ ,		snake_case__				)

                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__ ,		return_labels=snake_case__				)
                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__ ,		return_labels=snake_case__				)
                check_equivalence(snake_case__ ,		snake_case__ ,		snake_case__				)

                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__				)
                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__				)
                check_equivalence(snake_case__ ,		snake_case__ ,		snake_case__ ,		{"""output_hidden_states""": True}				)

                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__ ,		return_labels=snake_case__				)
                UpperCAmelCase	    =			self._prepare_for_class(snake_case__ ,		snake_case__ ,		return_labels=snake_case__				)
                check_equivalence(snake_case__ ,		snake_case__ ,		snake_case__ ,		{"""output_hidden_states""": True}				)





@require_torch
class   UpperCamelCase_ (       unittest.TestCase   ,					a_  ):
  _A       :					Optional[int]				=	(MaskFormerSwinBackbone,) if is_torch_available() else ()
  _A       :					Any				=	MaskFormerSwinConfig



  def 		UpperCamelCase_				(      self				)			->			List[Any]:



         """simple docstring"""





         UpperCAmelCase	    =			MaskFormerSwinModelTester(self				)



  def 		UpperCamelCase_				(      self				)			->			Dict:



         """simple docstring"""





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

         for backbone_class in self.all_model_classes:
                UpperCAmelCase	    =			backbone_class(snake_case__				)
                backbone.to(snake_case__				)
                backbone.eval()

                UpperCAmelCase	    =			backbone(**snake_case__				)

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

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








"""simple docstring"""







import random
from typing import Any






def       _lowerCAmelCase       (      lowerCAmelCase		):







       '''simple docstring'''
       for _ in range(len(lowerCAmelCase		)		):
              UpperCAmelCase	    =			random.randint(0	,      len(lowerCAmelCase		) - 1		)
              UpperCAmelCase	    =			random.randint(0	,      len(lowerCAmelCase		) - 1		)
              UpperCAmelCase    ,       UpperCAmelCase	    =			data[b], data[a]
       return data


if __name__ == "__main__":
 lowerCAmelCase_	:    Tuple            =      [0, 1, 2, 3, 4, 5, 6, 7]
 lowerCAmelCase_	:    List[str]            =      ['''python''', '''says''', '''hello''', '''!''']
 print('''Fisher-Yates Shuffle:''')
 print('''List''', integers, strings)
 print('''FY Shuffle''', fisher_yates_shuffle(integers), fisher_yates_shuffle(strings))
