

import gc
import random
import tempfile
import unittest

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

from diffusers import (
    AutoencoderKL,
    DDIMInverseScheduler,
    DDIMScheduler,
    DPMSolverMultistepInverseScheduler,
    DPMSolverMultistepScheduler,
    StableDiffusionDiffEditPipeline,
    UNetaDConditionModel,
)
from diffusers.utils import load_image, slow
from diffusers.utils.testing_utils import enable_full_determinism, floats_tensor, require_torch_gpu, torch_device

from ..pipeline_params import TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS, TEXT_GUIDED_IMAGE_INPAINTING_PARAMS
from ..test_pipelines_common import PipelineLatentTesterMixin, PipelineTesterMixin


enable_full_determinism()

class     a__  (    snake_case__							,		snake_case__							,		unittest.TestCase	):
			"""simple docstring"""







			__lowerCamelCase       				=				StableDiffusionDiffEditPipeline
			__lowerCamelCase       				=				TEXT_GUIDED_IMAGE_INPAINTING_PARAMS - {'height', 'width', 'image'} | {'image_latents'}
			__lowerCamelCase       				=				TEXT_GUIDED_IMAGE_INPAINTING_BATCH_PARAMS - {'image'} | {'image_latents'}
			__lowerCamelCase       				=				frozenset(
			    []	)  # TO-DO: update image_params once pipeline is refactored with VaeImageProcessor.preprocess
			__lowerCamelCase       				=				frozenset([]	)


			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							torch.manual_seed(0				)
							A__						=	UNetaDConditionModel(
							    block_out_channels=(32, 64)					,					layers_per_block=2					,					sample_size=32					,					in_channels=4					,					out_channels=4					,					down_block_types=("DownBlock2D", "CrossAttnDownBlock2D")					,					up_block_types=("CrossAttnUpBlock2D", "UpBlock2D")					,					cross_attention_dim=32					,					attention_head_dim=(2, 4)					,					use_linear_projection=lowercase					,					)
							A__						=	DDIMScheduler(
							    beta_start=0.0_0085					,					beta_end=0.012					,					beta_schedule="scaled_linear"					,					clip_sample=lowercase					,					set_alpha_to_one=lowercase					,					)
							A__						=	DDIMInverseScheduler(
							    beta_start=0.0_0085					,					beta_end=0.012					,					beta_schedule="scaled_linear"					,					clip_sample=lowercase					,					set_alpha_to_zero=lowercase					,					)
							torch.manual_seed(0				)
							A__						=	AutoencoderKL(
							    block_out_channels=[32, 64]					,					in_channels=3					,					out_channels=3					,					down_block_types=["DownEncoderBlock2D", "DownEncoderBlock2D"]					,					up_block_types=["UpDecoderBlock2D", "UpDecoderBlock2D"]					,					latent_channels=4					,					sample_size=128					,					)
							torch.manual_seed(0				)
							A__						=	CLIPTextConfig(
							    bos_token_id=0					,					eos_token_id=2					,					hidden_size=32					,					intermediate_size=37					,					layer_norm_eps=1e-05					,					num_attention_heads=4					,					num_hidden_layers=5					,					pad_token_id=1					,					vocab_size=1000					,					hidden_act="gelu"					,					projection_dim=512					,					)
							A__						=	CLIPTextModel(lowercase				)
							A__						=	CLIPTokenizer.from_pretrained("hf-internal-testing/tiny-random-clip"				)

							A__						=	{
							    "unet": unet,
							    "scheduler": scheduler,
							    "inverse_scheduler": inverse_scheduler,
							    "vae": vae,
							    "text_encoder": text_encoder,
							    "tokenizer": tokenizer,
							    "safety_checker": None,
							    "feature_extractor": None,
							}

							return components


			def    UpperCamelCase						(			self					,					lowercase					,					lowercase=0				)     ->  int:
							'''simple docstring'''






							A__						=	floats_tensor((1, 16, 16)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							A__						=	floats_tensor((1, 2, 4, 16, 16)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							if str(lowercase				).startswith("mps"				):
											A__						=	torch.manual_seed(lowercase				)
							else:
											A__						=	torch.Generator(device=lowercase				).manual_seed(lowercase				)
							A__						=	{
							    "prompt": "a dog and a newt",
							    "mask_image": mask,
							    "image_latents": latents,
							    "generator": generator,
							    "num_inference_steps": 2,
							    "inpaint_strength": 1.0,
							    "guidance_scale": 6.0,
							    "output_type": "numpy",
							}

							return inputs


			def    UpperCamelCase						(			self					,					lowercase					,					lowercase=0				)     ->  Dict:
							'''simple docstring'''






							A__						=	floats_tensor((1, 3, 32, 32)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							A__						=	image.cpu().permute(0					,					2					,					3					,					1				)[0]
							A__						=	Image.fromarray(np.uinta(lowercase				)				).convert("RGB"				)
							if str(lowercase				).startswith("mps"				):
											A__						=	torch.manual_seed(lowercase				)
							else:
											A__						=	torch.Generator(device=lowercase				).manual_seed(lowercase				)
							A__						=	{
							    "image": image,
							    "source_prompt": "a cat and a frog",
							    "target_prompt": "a dog and a newt",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "num_maps_per_mask": 2,
							    "mask_encode_strength": 1.0,
							    "guidance_scale": 6.0,
							    "output_type": "numpy",
							}

							return inputs


			def    UpperCamelCase						(			self					,					lowercase					,					lowercase=0				)     ->  Dict:
							'''simple docstring'''






							A__						=	floats_tensor((1, 3, 32, 32)					,					rng=random.Random(lowercase				)				).to(lowercase				)
							A__						=	image.cpu().permute(0					,					2					,					3					,					1				)[0]
							A__						=	Image.fromarray(np.uinta(lowercase				)				).convert("RGB"				)
							if str(lowercase				).startswith("mps"				):
											A__						=	torch.manual_seed(lowercase				)
							else:
											A__						=	torch.Generator(device=lowercase				).manual_seed(lowercase				)
							A__						=	{
							    "image": image,
							    "prompt": "a cat and a frog",
							    "generator": generator,
							    "num_inference_steps": 2,
							    "inpaint_strength": 1.0,
							    "guidance_scale": 6.0,
							    "decode_latents": True,
							    "output_type": "numpy",
							}
							return inputs


			def    UpperCamelCase						(			self				)     ->  int:
							'''simple docstring'''






							if not hasattr(self.pipeline_class					,					"_optional_components"				):
											return

							A__						=	self.get_dummy_components()
							A__						=	self.pipeline_class(**lowercase				)
							pipe.to(lowercase				)
							pipe.set_progress_bar_config(disable=lowercase				)

							# set all optional components to None and update pipeline config accordingly
							for optional_component in pipe._optional_components:
											setattr(lowercase					,					lowercase					,					lowercase				)
							pipe.register_modules(**{optional_component: None for optional_component in pipe._optional_components}				)

							A__						=	self.get_dummy_inputs(lowercase				)
							A__						=	pipe(**lowercase				)[0]

							with tempfile.TemporaryDirectory() as tmpdir:
											pipe.save_pretrained(lowercase				)
											A__						=	self.pipeline_class.from_pretrained(lowercase				)
											pipe_loaded.to(lowercase				)
											pipe_loaded.set_progress_bar_config(disable=lowercase				)

							for optional_component in pipe._optional_components:
											self.assertTrue(
											    getattr(lowercase					,					lowercase				) is None					,					F'`{optional_component}` did not stay set to None after loading.'					,					)

							A__						=	self.get_dummy_inputs(lowercase				)
							A__						=	pipe_loaded(**lowercase				)[0]

							A__						=	np.abs(output - output_loaded				).max()
							self.assertLess(lowercase					,					1e-4				)


			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							A__						=	"cpu"

							A__						=	self.get_dummy_components()
							A__						=	self.pipeline_class(**lowercase				)
							pipe.to(lowercase				)
							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	self.get_dummy_mask_inputs(lowercase				)
							A__						=	pipe.generate_mask(**lowercase				)
							A__						=	mask[0, -3:, -3:]

							self.assertEqual(mask.shape					,					(1, 16, 16)				)
							A__						=	np.array([0] * 9				)
							A__						=	np.abs(mask_slice.flatten() - expected_slice				).max()
							self.assertLessEqual(lowercase					,					1e-3				)
							self.assertEqual(mask[0, -3, -4]					,					0				)


			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							A__						=	"cpu"

							A__						=	self.get_dummy_components()
							A__						=	self.pipeline_class(**lowercase				)
							pipe.to(lowercase				)
							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	self.get_dummy_inversion_inputs(lowercase				)
							A__						=	pipe.invert(**lowercase				).images
							A__						=	image[0, -1, -3:, -3:]

							self.assertEqual(image.shape					,					(2, 32, 32, 3)				)
							A__						=	np.array(
							    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5_1050, 0.5015, 0.4407, 0.4799]					,					)
							A__						=	np.abs(image_slice.flatten() - expected_slice				).max()
							self.assertLessEqual(lowercase					,					1e-3				)


			def    UpperCamelCase						(			self				)     ->  Optional[Any]:
							'''simple docstring'''






							super().test_inference_batch_single_identical(expected_max_diff=5e-3				)


			def    UpperCamelCase						(			self				)     ->  int:
							'''simple docstring'''






							A__						=	"cpu"

							A__						=	self.get_dummy_components()

							A__						=	{"beta_start": 0.0_0085, "beta_end": 0.012, "beta_schedule": "scaled_linear"}
							A__						=	DPMSolverMultistepScheduler(**lowercase				)
							A__						=	DPMSolverMultistepInverseScheduler(**lowercase				)

							A__						=	self.pipeline_class(**lowercase				)
							pipe.to(lowercase				)
							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	self.get_dummy_inversion_inputs(lowercase				)
							A__						=	pipe.invert(**lowercase				).images
							A__						=	image[0, -1, -3:, -3:]

							self.assertEqual(image.shape					,					(2, 32, 32, 3)				)
							A__						=	np.array(
							    [0.5150, 0.5134, 0.5043, 0.5376, 0.4694, 0.5_1050, 0.5015, 0.4407, 0.4799]					,					)
							A__						=	np.abs(image_slice.flatten() - expected_slice				).max()
							self.assertLessEqual(lowercase					,					1e-3				)

@require_torch_gpu
@slow
class     a__  (    unittest.TestCase	):
			"""simple docstring"""







			def    UpperCamelCase						(			self				)     ->  Optional[int]:
							'''simple docstring'''






							super().tearDown()
							gc.collect()
							torch.cuda.empty_cache()


			@classmethod
			def    UpperCamelCase						(			cls				)     ->  List[str]:
							'''simple docstring'''






							A__						=	load_image(
							    "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main/diffedit/fruit.png"				)

							A__						=	raw_image.convert("RGB"				).resize((768, 768)				)

							A__						=	raw_image


			def    UpperCamelCase						(			self				)     ->  List[Any]:
							'''simple docstring'''






							A__						=	torch.manual_seed(0				)

							A__						=	StableDiffusionDiffEditPipeline.from_pretrained(
							    "stabilityai/stable-diffusion-2-1"					,					safety_checker=lowercase					,					torch_dtype=torch.floataa				)
							A__						=	DDIMScheduler.from_config(pipe.scheduler.config				)
							A__						=	DDIMInverseScheduler.from_config(pipe.scheduler.config				)
							pipe.enable_model_cpu_offload()
							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	"a bowl of fruit"
							A__						=	"a bowl of pears"

							A__						=	pipe.generate_mask(
							    image=self.raw_image					,					source_prompt=lowercase					,					target_prompt=lowercase					,					generator=lowercase					,					)

							A__						=	pipe.invert(
							    prompt=lowercase					,					image=self.raw_image					,					inpaint_strength=0.7					,					generator=lowercase				).latents

							A__						=	pipe(
							    prompt=lowercase					,					mask_image=lowercase					,					image_latents=lowercase					,					generator=lowercase					,					negative_prompt=lowercase					,					inpaint_strength=0.7					,					output_type="numpy"					,					).images[0]

							A__						=	(
							    np.array(
							        load_image(
							            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							            "/diffedit/pears.png"				).resize((768, 768)				)				)
							    / 255
							)
							assert np.abs((expected_image - image).max()				) < 5e-1


			def    UpperCamelCase						(			self				)     ->  List[Any]:
							'''simple docstring'''






							A__						=	torch.manual_seed(0				)

							A__						=	StableDiffusionDiffEditPipeline.from_pretrained(
							    "stabilityai/stable-diffusion-2-1"					,					safety_checker=lowercase					,					torch_dtype=torch.floataa				)
							A__						=	DPMSolverMultistepScheduler.from_config(pipe.scheduler.config				)
							A__						=	DPMSolverMultistepInverseScheduler.from_config(pipe.scheduler.config				)
							pipe.enable_model_cpu_offload()
							pipe.set_progress_bar_config(disable=lowercase				)

							A__						=	"a bowl of fruit"
							A__						=	"a bowl of pears"

							A__						=	pipe.generate_mask(
							    image=self.raw_image					,					source_prompt=lowercase					,					target_prompt=lowercase					,					generator=lowercase					,					)

							A__						=	pipe.invert(
							    prompt=lowercase					,					image=self.raw_image					,					inpaint_strength=0.7					,					generator=lowercase					,					num_inference_steps=25					,					).latents

							A__						=	pipe(
							    prompt=lowercase					,					mask_image=lowercase					,					image_latents=lowercase					,					generator=lowercase					,					negative_prompt=lowercase					,					inpaint_strength=0.7					,					num_inference_steps=25					,					output_type="numpy"					,					).images[0]

							A__						=	(
							    np.array(
							        load_image(
							            "https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main"
							            "/diffedit/pears.png"				).resize((768, 768)				)				)
							    / 255
							)
							assert np.abs((expected_image - image).max()				) < 5e-1









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





	"""simple docstring"""






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







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

							_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       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







							_UpperCAmelCase									=			MaskFormerSwinBackbone(config=UpperCAmelCase    )
							model.to(UpperCAmelCase    )
							model.eval()
							_UpperCAmelCase									=			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    ):
													_UpperCAmelCase									=			['stem']
													_UpperCAmelCase									=			MaskFormerSwinBackbone(config=UpperCAmelCase    )

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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





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





	"""simple docstring"""






	UpperCamelCase__								=      (
	    (
	        MaskFormerSwinModel,
	        MaskFormerSwinBackbone,
	    )
	    if is_torch_available()
	    else ()
	)
	UpperCamelCase__								=      {"feature-extraction": MaskFormerSwinModel} if is_torch_available() else {}
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False
	UpperCamelCase__								=      False

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			MaskFormerSwinModelTester(self    )
							_UpperCAmelCase									=			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        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	def        UpperCamelCase    (							self    ):
							"""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    ):
							"""simple docstring"""







							return

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







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

	@unittest.skip('Swin does not use inputs_embeds'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	@unittest.skip('Swin does not support feedforward chunking'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase					, _UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()

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

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase					, _UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
													_UpperCAmelCase									=			model_class(UpperCAmelCase    )
													_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]       ,    UpperCAmelCase    )

	@unittest.skip(reason='MaskFormerSwin is only used as backbone and doesn\'t support output_attentions'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	@unittest.skip(reason='MaskFormerSwin is only used as an internal backbone'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	def        UpperCamelCase    (							self       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    ):
							"""simple docstring"""







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

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

							_UpperCAmelCase									=			outputs.hidden_states

							_UpperCAmelCase									=			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
							_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    ):
							"""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(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    )

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

													self.check_hidden_states_output(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase    )

	def        UpperCamelCase    (							self    ):
							"""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(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    (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(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    (padded_height, padded_width)    )

	@unittest.skip(reason='MaskFormerSwin doesn\'t have pretrained checkpoints'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	@unittest.skip(reason='This will be fixed once MaskFormerSwin is replaced by native Swin'    )
	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							pass

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase					, _UpperCAmelCase									=			self.model_tester.prepare_config_and_inputs_for_common()

							def set_nan_tensor_to_zero(UpperCAmelCase    ):
													_UpperCAmelCase									=			0
													return t

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

																			def recursive_check(UpperCAmelCase       ,    UpperCAmelCase    ):
																									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:
													_UpperCAmelCase									=			model_class(UpperCAmelCase    )
													model.to(UpperCAmelCase    )
													model.eval()

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

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

													_UpperCAmelCase									=			self._prepare_for_class(UpperCAmelCase       ,    UpperCAmelCase    )
													_UpperCAmelCase									=			self._prepare_for_class(UpperCAmelCase       ,    UpperCAmelCase    )
													check_equivalence(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    {'output_hidden_states': True}    )

													_UpperCAmelCase									=			self._prepare_for_class(UpperCAmelCase       ,    UpperCAmelCase       ,    return_labels=UpperCAmelCase    )
													_UpperCAmelCase									=			self._prepare_for_class(UpperCAmelCase       ,    UpperCAmelCase       ,    return_labels=UpperCAmelCase    )
													check_equivalence(UpperCAmelCase       ,    UpperCAmelCase       ,    UpperCAmelCase       ,    {'output_hidden_states': True}    )





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





	"""simple docstring"""






	UpperCamelCase__								=      (MaskFormerSwinBackbone,) if is_torch_available() else ()
	UpperCamelCase__								=      MaskFormerSwinConfig

	def        UpperCamelCase    (							self    ):
							"""simple docstring"""







							_UpperCAmelCase									=			MaskFormerSwinModelTester(self    )

	def        UpperCamelCase    (							self    ):
							"""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(UpperCAmelCase    )
													backbone.to(UpperCAmelCase    )
													backbone.eval()

													_UpperCAmelCase									=			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
													_UpperCAmelCase									=			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)
																									_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(**UpperCAmelCase       ,    output_attentions=UpperCAmelCase    )
																			self.assertIsNotNone(outputs.attentions    )
