


"""simple docstring"""

import gc
import random
import unittest

import numpy as np
import torch
from transformers import CLIPTextConfig, CLIPTextModel, CLIPTokenizer

from diffusers import AutoencoderKL, CycleDiffusionPipeline, DDIMScheduler, UNetaDConditionModel
from diffusers.utils import floats_tensor, load_image, load_numpy, slow, torch_device
from diffusers.utils.testing_utils import enable_full_determinism, require_torch_gpu, skip_mps

from ..pipeline_params import (
    IMAGE_TO_IMAGE_IMAGE_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS,
    TEXT_GUIDED_IMAGE_VARIATION_PARAMS,
)
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()





class  lowerCamelCase__    (		_snake_case      , _snake_case      , unittest.TestCase     ):
      a			:  Optional[int]           =		CycleDiffusionPipeline
      a			:  Union[str, Any]           =		TEXT_GUIDED_IMAGE_VARIATION_PARAMS - {
          """negative_prompt""",
          """height""",
          """width""",
          """negative_prompt_embeds""",
      }
      a			:  Tuple           =		PipelineTesterMixin.required_optional_params - {"""latents"""}
      a			:  Optional[Any]           =		TEXT_GUIDED_IMAGE_VARIATION_BATCH_PARAMS.union({"""source_prompt"""}     )
      a			:  str           =		IMAGE_TO_IMAGE_IMAGE_PARAMS
      a			:  str           =		IMAGE_TO_IMAGE_IMAGE_PARAMS
      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       torch.manual_seed(0				)
       __lowercase						=						UNetaDConditionModel(
           block_out_channels=(3_2, 6_4)   ,							layers_per_block=2   ,							sample_size=3_2   ,							in_channels=4   ,							out_channels=4   ,							down_block_types=("""DownBlock2D""", """CrossAttnDownBlock2D""")   ,							up_block_types=("""CrossAttnUpBlock2D""", """UpBlock2D""")   ,							cross_attention_dim=3_2   ,							)
       __lowercase						=						DDIMScheduler(
           beta_start=0.0_00_85   ,							beta_end=0.0_12   ,							beta_schedule="""scaled_linear"""   ,							num_train_timesteps=1_0_0_0   ,							clip_sample=__snake_case   ,							set_alpha_to_one=__snake_case   ,							)
       torch.manual_seed(0				)
       __lowercase						=						AutoencoderKL(
           block_out_channels=[3_2, 6_4]   ,							in_channels=3   ,							out_channels=3   ,							down_block_types=["""DownEncoderBlock2D""", """DownEncoderBlock2D"""]   ,							up_block_types=["""UpDecoderBlock2D""", """UpDecoderBlock2D"""]   ,							latent_channels=4   ,							)
       torch.manual_seed(0				)
       __lowercase						=						CLIPTextConfig(
           bos_token_id=0   ,							eos_token_id=2   ,							hidden_size=3_2   ,							intermediate_size=3_7   ,							layer_norm_eps=1e-0_5   ,							num_attention_heads=4   ,							num_hidden_layers=5   ,							pad_token_id=1   ,							vocab_size=1_0_0_0   ,							)
       __lowercase						=						CLIPTextModel(__snake_case				)
       __lowercase						=						CLIPTokenizer.from_pretrained("""hf-internal-testing/tiny-random-clip"""				)

       __lowercase						=						{
           """unet""": unet,
           """scheduler""": scheduler,
           """vae""": vae,
           """text_encoder""": text_encoder,
           """tokenizer""": tokenizer,
           """safety_checker""": None,
           """feature_extractor""": None,
       }
       return components
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]   ,							A_						:						str   ,							A_						:						Any=0				):






       '''simple docstring'''


       __lowercase						=						floats_tensor((1, 3, 3_2, 3_2)   ,							rng=random.Random(__snake_case				)				).to(__snake_case				)
       __lowercase						=						image / 2 + 0.5
       if str(__snake_case				).startswith("""mps"""				):
        __lowercase						=						torch.manual_seed(__snake_case				)
       else:
        __lowercase						=						torch.Generator(device=__snake_case				).manual_seed(__snake_case				)
       __lowercase						=						{
           """prompt""": """An astronaut riding an elephant""",
           """source_prompt""": """An astronaut riding a horse""",
           """image""": image,
           """generator""": generator,
           """num_inference_steps""": 2,
           """eta""": 0.1,
           """strength""": 0.8,
           """guidance_scale""": 3,
           """source_guidance_scale""": 1,
           """output_type""": """numpy""",
       }
       return inputs
      def SCREAMING_SNAKE_CASE_						(		self						:						List[Any]				):






       '''simple docstring'''


       __lowercase						=						"""cpu"""  # ensure determinism for the device-dependent torch.Generator

       __lowercase						=						self.get_dummy_components()
       __lowercase						=						CycleDiffusionPipeline(**__snake_case				)
       __lowercase						=						pipe.to(__snake_case				)
       pipe.set_progress_bar_config(disable=__snake_case				)

       __lowercase						=						self.get_dummy_inputs(__snake_case				)
       __lowercase						=						pipe(**__snake_case				)
       __lowercase						=						output.images

       __lowercase						=						images[0, -3:, -3:, -1]

       assert images.shape == (1, 3_2, 3_2, 3)
       __lowercase						=						np.array([0.44_59, 0.49_43, 0.45_44, 0.66_43, 0.54_74, 0.43_27, 0.57_01, 0.59_59, 0.51_79]				)

       assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
      @unittest.skipIf(torch_device != """cuda"""   ,							"""This test requires a GPU"""				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[Any]				):






       '''simple docstring'''


       __lowercase						=						self.get_dummy_components()
       for name, module in components.items():
        if hasattr(__snake_case   ,							"""half"""				):
         __lowercase						=						module.half()
       __lowercase						=						CycleDiffusionPipeline(**__snake_case				)
       __lowercase						=						pipe.to(__snake_case				)
       pipe.set_progress_bar_config(disable=__snake_case				)

       __lowercase						=						self.get_dummy_inputs(__snake_case				)
       __lowercase						=						pipe(**__snake_case				)
       __lowercase						=						output.images

       __lowercase						=						images[0, -3:, -3:, -1]

       assert images.shape == (1, 3_2, 3_2, 3)
       __lowercase						=						np.array([0.35_06, 0.45_43, 0.4_46, 0.45_75, 0.51_95, 0.41_55, 0.52_73, 0.5_18, 0.41_16]				)

       assert np.abs(image_slice.flatten() - expected_slice				).max() < 1e-2
      @skip_mps
      def SCREAMING_SNAKE_CASE_						(		self						:						Dict				):






       '''simple docstring'''


       return super().test_save_load_local()
      @unittest.skip("""non-deterministic pipeline"""				)
      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       return super().test_inference_batch_single_identical()
      @skip_mps
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       return super().test_dict_tuple_outputs_equivalent()
      @skip_mps
      def SCREAMING_SNAKE_CASE_						(		self						:						Union[str, Any]				):






       '''simple docstring'''


       return super().test_save_load_optional_components()






      @skip_mps
      def SCREAMING_SNAKE_CASE_						(		self						:						int				):






       '''simple docstring'''


       return super().test_attention_slicing_forward_pass()






@slow
@require_torch_gpu
class  lowerCamelCase__    (		unittest.TestCase     ):
      def SCREAMING_SNAKE_CASE_						(		self						:						Optional[int]				):






       '''simple docstring'''


       super().tearDown()
       gc.collect()
       torch.cuda.empty_cache()
      def SCREAMING_SNAKE_CASE_						(		self						:						str				):






       '''simple docstring'''


       __lowercase						=						load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/cycle-diffusion/black_colored_car.png"""				)
       __lowercase						=						load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car_fp16.npy"""				)
       __lowercase						=						init_image.resize((5_1_2, 5_1_2)				)

       __lowercase						=						"""CompVis/stable-diffusion-v1-4"""
       __lowercase						=						DDIMScheduler.from_pretrained(__snake_case   ,							subfolder="""scheduler"""				)
       __lowercase						=						CycleDiffusionPipeline.from_pretrained(
           __snake_case   ,							scheduler=__snake_case   ,							safety_checker=__snake_case   ,							torch_dtype=torch.floataa   ,							revision="""fp16"""				)

       pipe.to(__snake_case				)
       pipe.set_progress_bar_config(disable=__snake_case				)
       pipe.enable_attention_slicing()

       __lowercase						=						"""A black colored car"""
       __lowercase						=						"""A blue colored car"""

       __lowercase						=						torch.manual_seed(0				)
       __lowercase						=						pipe(
           prompt=__snake_case   ,							source_prompt=__snake_case   ,							image=__snake_case   ,							num_inference_steps=1_0_0   ,							eta=0.1   ,							strength=0.85   ,							guidance_scale=3   ,							source_guidance_scale=1   ,							generator=__snake_case   ,							output_type="""np"""   ,							)
       __lowercase						=						output.images

       # the values aren't exactly equal, but the images look the same visually
       assert np.abs(image - expected_image				).max() < 5e-1






      def SCREAMING_SNAKE_CASE_						(		self						:						Tuple				):






       '''simple docstring'''


       __lowercase						=						load_image(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"""
           """/cycle-diffusion/black_colored_car.png"""				)
       __lowercase						=						load_numpy(
           """https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/cycle-diffusion/blue_colored_car.npy"""				)
       __lowercase						=						init_image.resize((5_1_2, 5_1_2)				)

       __lowercase						=						"""CompVis/stable-diffusion-v1-4"""
       __lowercase						=						DDIMScheduler.from_pretrained(__snake_case   ,							subfolder="""scheduler"""				)
       __lowercase						=						CycleDiffusionPipeline.from_pretrained(__snake_case   ,							scheduler=__snake_case   ,							safety_checker=__snake_case				)

       pipe.to(__snake_case				)
       pipe.set_progress_bar_config(disable=__snake_case				)
       pipe.enable_attention_slicing()

       __lowercase						=						"""A black colored car"""
       __lowercase						=						"""A blue colored car"""

       __lowercase						=						torch.manual_seed(0				)
       __lowercase						=						pipe(
           prompt=__snake_case   ,							source_prompt=__snake_case   ,							image=__snake_case   ,							num_inference_steps=1_0_0   ,							eta=0.1   ,							strength=0.85   ,							guidance_scale=3   ,							source_guidance_scale=1   ,							generator=__snake_case   ,							output_type="""np"""   ,							)
       __lowercase						=						output.images

       assert np.abs(image - expected_image				).max() < 2e-2




'''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        lowercase__    :





							'''simple docstring'''


							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]       ,   ):
											_SCREAMING_SNAKE_CASE					:			List[Any]							= parent
											_SCREAMING_SNAKE_CASE					:			List[str]							= batch_size
											_SCREAMING_SNAKE_CASE					:			str							= image_size
											_SCREAMING_SNAKE_CASE					:			Any							= patch_size
											_SCREAMING_SNAKE_CASE					:			int							= num_channels
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= embed_dim
											_SCREAMING_SNAKE_CASE					:			List[str]							= depths
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= num_heads
											_SCREAMING_SNAKE_CASE					:			Dict							= window_size
											_SCREAMING_SNAKE_CASE					:			int							= mlp_ratio
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= qkv_bias
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= hidden_dropout_prob
											_SCREAMING_SNAKE_CASE					:			int							= attention_probs_dropout_prob
											_SCREAMING_SNAKE_CASE					:			str							= drop_path_rate
											_SCREAMING_SNAKE_CASE					:			List[Any]							= hidden_act
											_SCREAMING_SNAKE_CASE					:			List[str]							= use_absolute_embeddings
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= patch_norm
											_SCREAMING_SNAKE_CASE					:			str							= layer_norm_eps
											_SCREAMING_SNAKE_CASE					:			List[Any]							= initializer_range
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= is_training
											_SCREAMING_SNAKE_CASE					:			Tuple							= scope
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= use_labels
											_SCREAMING_SNAKE_CASE					:			List[str]							= type_sequence_label_size
											_SCREAMING_SNAKE_CASE					:			Tuple							= encoder_stride
											_SCREAMING_SNAKE_CASE					:			Dict							= out_features
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= out_indices






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]    )

											_SCREAMING_SNAKE_CASE					:			Any							= None
											if self.use_labels:
															_SCREAMING_SNAKE_CASE					:			int							= ids_tensor([self.batch_size]       ,   self.type_sequence_label_size    )

											_SCREAMING_SNAKE_CASE					:			List[str]							= self.get_config()

											return config, pixel_values, labels






							def UpperCAmelCase_      (       self    ):
											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    ):
											_SCREAMING_SNAKE_CASE					:			Any							= MaskFormerSwinModel(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Any							= model(__snake_case    )

											_SCREAMING_SNAKE_CASE					:			List[str]							= ((config.image_size // config.patch_size) ** 2) // (4 ** (len(config.depths    ) - 1))
											_SCREAMING_SNAKE_CASE					:			List[Any]							= 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    ):
											_SCREAMING_SNAKE_CASE					:			str							= MaskFormerSwinBackbone(config=__snake_case    )
											model.to(__snake_case    )
											model.eval()
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= 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    ):
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= ["""stem"""]
															_SCREAMING_SNAKE_CASE					:			Any							= MaskFormerSwinBackbone(config=__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[str]							= config_and_inputs
											_SCREAMING_SNAKE_CASE					:			List[str]							= {"""pixel_values""": pixel_values}
											return config, inputs_dict





@require_torch
class        lowercase__    (		_snake_case	,	_snake_case	,	unittest.TestCase   ):





							'''simple docstring'''


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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			str							= MaskFormerSwinModelTester(self    )
											_SCREAMING_SNAKE_CASE					:			Tuple							= 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    ):
											pass






							def UpperCAmelCase_      (       self    ):
											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    ):
											return






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[Any]							= self.model_tester.prepare_config_and_inputs()
											self.model_tester.create_and_check_model(*__snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Tuple							= 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    ):
											pass






							@unittest.skip("""Swin does not support feedforward chunking"""    )
							def UpperCAmelCase_      (       self    ):
											pass






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_common()

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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			int							= self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= model_class(__snake_case    )
															_SCREAMING_SNAKE_CASE					:			List[Any]							= inspect.signature(model.forward    )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= [*signature.parameters.keys()]

															_SCREAMING_SNAKE_CASE					:			str							= ["""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    ):
											pass






							@unittest.skip(reason="""MaskFormerSwin is only used as an internal backbone"""    )
							def UpperCAmelCase_      (       self    ):
											pass






							def UpperCAmelCase_      (       self       ,   __snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    ):
											_SCREAMING_SNAKE_CASE					:			List[str]							= model_class(__snake_case    )
											model.to(__snake_case    )
											model.eval()

											with torch.no_grad():
															_SCREAMING_SNAKE_CASE					:			str							= model(**self._prepare_for_class(__snake_case       ,   __snake_case    )    )

											_SCREAMING_SNAKE_CASE					:			str							= outputs.hidden_states

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= 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
											_SCREAMING_SNAKE_CASE					:			Any							= (
											    config.patch_size
											    if isinstance(config.patch_size       ,   collections.abc.Iterable    )
											    else (config.patch_size, config.patch_size)
											)

											_SCREAMING_SNAKE_CASE					:			Optional[int]							= (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    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[Any]							= self.model_tester.prepare_config_and_inputs_for_common()

											_SCREAMING_SNAKE_CASE					:			str							= (
											    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:
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= 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"]
															_SCREAMING_SNAKE_CASE					:			List[str]							= True

															self.check_hidden_states_output(__snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE					:			str							= 3

											_SCREAMING_SNAKE_CASE					:			List[Any]							= (
											    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)
											)
											_SCREAMING_SNAKE_CASE					:			Dict							= (
											    config.patch_size
											    if isinstance(config.patch_size       ,   collections.abc.Iterable    )
											    else (config.patch_size, config.patch_size)
											)

											_SCREAMING_SNAKE_CASE					:			Tuple							= image_size[0] + patch_size[0] - (image_size[0] % patch_size[0])
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= image_size[1] + patch_size[1] - (image_size[1] % patch_size[1])

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			List[str]							= 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"]
															_SCREAMING_SNAKE_CASE					:			Dict							= 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    ):
											pass






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






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






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			List[Any]							= self.model_tester.prepare_config_and_inputs_for_common()

											def set_nan_tensor_to_zero(__snake_case    ):
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= 0
															return t

											def check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case       ,   __snake_case={}    ):
															with torch.no_grad():
																			_SCREAMING_SNAKE_CASE					:			Dict							= model(**__snake_case       ,   return_dict=__snake_case       ,   **__snake_case    )
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= 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:
															_SCREAMING_SNAKE_CASE					:			Union[str, Any]							= model_class(__snake_case    )
															model.to(__snake_case    )
															model.eval()

															_SCREAMING_SNAKE_CASE					:			str							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															_SCREAMING_SNAKE_CASE					:			str							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case    )

															_SCREAMING_SNAKE_CASE					:			Any							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															_SCREAMING_SNAKE_CASE					:			int							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case    )

															_SCREAMING_SNAKE_CASE					:			List[str]							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															_SCREAMING_SNAKE_CASE					:			Optional[int]							= self._prepare_for_class(__snake_case       ,   __snake_case    )
															check_equivalence(__snake_case       ,   __snake_case       ,   __snake_case       ,   {"""output_hidden_states""": True}    )

															_SCREAMING_SNAKE_CASE					:			List[Any]							= self._prepare_for_class(__snake_case       ,   __snake_case       ,   return_labels=__snake_case    )
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= 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        lowercase__    (		unittest.TestCase	,	_snake_case   ):





							'''simple docstring'''


							A_				: Any       =    (MaskFormerSwinBackbone,) if is_torch_available() else ()
							A_				: List[Any]       =    MaskFormerSwinConfig






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= MaskFormerSwinModelTester(self    )






							def UpperCAmelCase_      (       self    ):
											_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Optional[int]							= self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE					:			Optional[int]							= inputs_dict["""pixel_values"""].shape[0]

											for backbone_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE					:			List[Any]							= backbone_class(__snake_case    )
															backbone.to(__snake_case    )
															backbone.eval()

															_SCREAMING_SNAKE_CASE					:			List[str]							= 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
															_SCREAMING_SNAKE_CASE					:			Optional[Any]							= 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)
																							_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE						,			_SCREAMING_SNAKE_CASE					:			Dict							= hidden_state.shape
																							self.assertTrue((h_batch_size, h_n_channels)       ,   (batch_size, n_channels)    )

            # Test output_attentions=True
															if self.has_attentions:
																			_SCREAMING_SNAKE_CASE					:			Optional[int]							= backbone(**__snake_case       ,   output_attentions=__snake_case    )
																			self.assertIsNotNone(outputs.attentions    )




