
from typing import List, Optional, Union

import torch

from ...models import UNetaDConditionModel, VQModel
from ...pipelines import DiffusionPipeline
from ...pipelines.pipeline_utils import ImagePipelineOutput
from ...schedulers import DDPMScheduler
from ...utils import (
    is_accelerate_available,
    is_accelerate_version,
    logging,
    randn_tensor,
    replace_example_docstring,
)


lowercase__							:							Optional[Any]									=			logging.get_logger(__name__)  # pylint: disable=invalid-name

lowercase__							:							Optional[Any]									=			"\n    Examples:\n        ```py\n        >>> import torch\n        >>> import numpy as np\n\n        >>> from diffusers import KandinskyV22PriorPipeline, KandinskyV22ControlnetPipeline\n        >>> from transformers import pipeline\n        >>> from diffusers.utils import load_image\n\n\n        >>> def make_hint(image, depth_estimator):\n        ...     image = depth_estimator(image)[\"depth\"]\n        ...     image = np.array(image)\n        ...     image = image[:, :, None]\n        ...     image = np.concatenate([image, image, image], axis=2)\n        ...     detected_map = torch.from_numpy(image).float() / 255.0\n        ...     hint = detected_map.permute(2, 0, 1)\n        ...     return hint\n\n\n        >>> depth_estimator = pipeline(\"depth-estimation\")\n\n        >>> pipe_prior = KandinskyV22PriorPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-prior\", torch_dtype=torch.float16\n        ... )\n        >>> pipe_prior = pipe_prior.to(\"cuda\")\n\n        >>> pipe = KandinskyV22ControlnetPipeline.from_pretrained(\n        ...     \"kandinsky-community/kandinsky-2-2-controlnet-depth\", torch_dtype=torch.float16\n        ... )\n        >>> pipe = pipe.to(\"cuda\")\n\n\n        >>> img = load_image(\n        ...     \"https://huggingface.co/datasets/hf-internal-testing/diffusers-images/resolve/main\"\n        ...     \"/kandinsky/cat.png\"\n        ... ).resize((768, 768))\n\n        >>> hint = make_hint(img, depth_estimator).unsqueeze(0).half().to(\"cuda\")\n\n        >>> prompt = \"A robot, 4k photo\"\n        >>> negative_prior_prompt = \"lowres, text, error, cropped, worst quality, low quality, jpeg artifacts, ugly, duplicate, morbid, mutilated, out of frame, extra fingers, mutated hands, poorly drawn hands, poorly drawn face, mutation, deformed, blurry, dehydrated, bad anatomy, bad proportions, extra limbs, cloned face, disfigured, gross proportions, malformed limbs, missing arms, missing legs, extra arms, extra legs, fused fingers, too many fingers, long neck, username, watermark, signature\"\n\n        >>> generator = torch.Generator(device=\"cuda\").manual_seed(43)\n\n        >>> image_emb, zero_image_emb = pipe_prior(\n        ...     prompt=prompt, negative_prompt=negative_prior_prompt, generator=generator\n        ... ).to_tuple()\n\n        >>> images = pipe(\n        ...     image_embeds=image_emb,\n        ...     negative_image_embeds=zero_image_emb,\n        ...     hint=hint,\n        ...     num_inference_steps=50,\n        ...     generator=generator,\n        ...     height=768,\n        ...     width=768,\n        ... ).images\n\n        >>> images[0].save(\"robot_cat.png\")\n        ```\n"




def 	A_ (							snake_case							:   Tuple ,      snake_case							:   Any ,      snake_case							:   Optional[int]=8 )      ->    Optional[int]:



						'''simple docstring'''

						__UpperCamelCase       =			height // scale_factor**2
						if height % scale_factor**2 != 0:
												new_height += 1
						__UpperCamelCase       =			width // scale_factor**2
						if width % scale_factor**2 != 0:
												new_width += 1
						return new_height * scale_factor, new_width * scale_factor






class        SCREAMING_SNAKE_CASE__    (							SCREAMING_SNAKE_CASE_    ):

							"""simple docstring"""






							def __init__(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	)->   Any:





													'''simple docstring'''






													super().__init__()

													self.register_modules(
													    unet=SCREAMING_SNAKE_CASE_     ,	scheduler=SCREAMING_SNAKE_CASE_     ,	movq=SCREAMING_SNAKE_CASE_     ,	)
													__UpperCamelCase       =			2 ** (len(self.movq.config.block_out_channels			) - 1)



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)->   Tuple:





													'''simple docstring'''






													if latents is None:
																			__UpperCamelCase       =			randn_tensor(SCREAMING_SNAKE_CASE_     ,	generator=SCREAMING_SNAKE_CASE_     ,	device=SCREAMING_SNAKE_CASE_     ,	dtype=SCREAMING_SNAKE_CASE_			)
													else:
																			if latents.shape != shape:
																									raise ValueError(F"Unexpected latents shape, got {latents.shape}, expected {shape}"			)
																			__UpperCamelCase       =			latents.to(SCREAMING_SNAKE_CASE_			)

													__UpperCamelCase       =			latents * scheduler.init_noise_sigma
													return latents



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_=0			)->   Tuple:





													'''simple docstring'''






													if is_accelerate_available():
																			from accelerate import cpu_offload
													else:
																			raise ImportError('''Please install accelerate via `pip install accelerate`'''			)

													__UpperCamelCase       =			torch.device(F"cuda:{gpu_id}"			)

													__UpperCamelCase       =			[
													    self.unet,
													    self.movq,
													]
													for cpu_offloaded_model in models:
																			if cpu_offloaded_model is not None:
																									cpu_offload(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_=0			)->   Dict:





													'''simple docstring'''






													if is_accelerate_available() and is_accelerate_version('''>='''     ,	'''0.17.0.dev0'''			):
																			from accelerate import cpu_offload_with_hook
													else:
																			raise ImportError('''`enable_model_cpu_offload` requires `accelerate v0.17.0` or higher.'''			)

													__UpperCamelCase       =			torch.device(F"cuda:{gpu_id}"			)

													if self.device.type != "cpu":
																			self.to('''cpu'''     ,	silence_dtype_warnings=SCREAMING_SNAKE_CASE_			)
																			torch.cuda.empty_cache()  # otherwise we don't see the memory savings (but they probably exist)

													__UpperCamelCase       =			None
													for cpu_offloaded_model in [self.unet, self.movq]:
																			__UpperCamelCase  ,							__UpperCamelCase       =			cpu_offload_with_hook(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	prev_module_hook=SCREAMING_SNAKE_CASE_			)

													# We'll offload the last model manually.
													__UpperCamelCase       =			hook



							@property
							# Copied from diffusers.pipelines.stable_diffusion.pipeline_stable_diffusion.StableDiffusionPipeline._execution_device
							def     A__		(  self			)->   str:





													'''simple docstring'''






													if not hasattr(self.unet     ,	'''_hf_hook'''			):
																			return self.device
													for module in self.unet.modules():
																			if (
																			    hasattr(SCREAMING_SNAKE_CASE_     ,	'''_hf_hook'''			)
																			    and hasattr(module._hf_hook     ,	'''execution_device'''			)
																			    and module._hf_hook.execution_device is not None
																			):
																									return torch.device(module._hf_hook.execution_device			)
													return self.device



							@torch.no_grad()
							@replace_example_docstring(SCREAMING_SNAKE_CASE_			)
							def __call__(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_ = 512     ,	SCREAMING_SNAKE_CASE_ = 512     ,	SCREAMING_SNAKE_CASE_ = 100     ,	SCREAMING_SNAKE_CASE_ = 4.0     ,	SCREAMING_SNAKE_CASE_ = 1     ,	SCREAMING_SNAKE_CASE_ = None     ,	SCREAMING_SNAKE_CASE_ = None     ,	SCREAMING_SNAKE_CASE_ = "pil"     ,	SCREAMING_SNAKE_CASE_ = True     ,	)->   Optional[int]:





													'''simple docstring'''






													__UpperCamelCase       =			self._execution_device

													__UpperCamelCase       =			guidance_scale > 1.0

													if isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			):
																			__UpperCamelCase       =			torch.cat(SCREAMING_SNAKE_CASE_     ,	dim=0			)
													if isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			):
																			__UpperCamelCase       =			torch.cat(SCREAMING_SNAKE_CASE_     ,	dim=0			)
													if isinstance(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			):
																			__UpperCamelCase       =			torch.cat(SCREAMING_SNAKE_CASE_     ,	dim=0			)

													__UpperCamelCase       =			image_embeds.shape[0] * num_images_per_prompt

													if do_classifier_free_guidance:
																			__UpperCamelCase       =			image_embeds.repeat_interleave(SCREAMING_SNAKE_CASE_     ,	dim=0			)
																			__UpperCamelCase       =			negative_image_embeds.repeat_interleave(SCREAMING_SNAKE_CASE_     ,	dim=0			)
																			__UpperCamelCase       =			hint.repeat_interleave(SCREAMING_SNAKE_CASE_     ,	dim=0			)

													__UpperCamelCase       =			torch.cat([negative_image_embeds, image_embeds]     ,	dim=0			).to(dtype=self.unet.dtype     ,	device=SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			torch.cat([hint, hint]     ,	dim=0			).to(dtype=self.unet.dtype     ,	device=SCREAMING_SNAKE_CASE_			)
													self.scheduler.set_timesteps(SCREAMING_SNAKE_CASE_     ,	device=SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			self.scheduler.timesteps

													__UpperCamelCase       =			self.movq.config.latent_channels

													__UpperCamelCase  ,							__UpperCamelCase       =			downscale_height_and_width(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	self.movq_scale_factor			)

													# create initial latent
													__UpperCamelCase       =			self.prepare_latents(
													    (batch_size, num_channels_latents, height, width)     ,	image_embeds.dtype     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	self.scheduler     ,	)

													for i, t in enumerate(self.progress_bar(SCREAMING_SNAKE_CASE_			)			):
																			# expand the latents if we are doing classifier free guidance
																			__UpperCamelCase       =			torch.cat([latents] * 2			) if do_classifier_free_guidance else latents

																			__UpperCamelCase       =			{'''image_embeds''': image_embeds, '''hint''': hint}
																			__UpperCamelCase       =			self.unet(
																			    sample=SCREAMING_SNAKE_CASE_     ,	timestep=SCREAMING_SNAKE_CASE_     ,	encoder_hidden_states=SCREAMING_SNAKE_CASE_     ,	added_cond_kwargs=SCREAMING_SNAKE_CASE_     ,	return_dict=SCREAMING_SNAKE_CASE_     ,	)[0]

																			if do_classifier_free_guidance:
																									__UpperCamelCase  ,							__UpperCamelCase       =			noise_pred.split(latents.shape[1]     ,	dim=1			)
																									__UpperCamelCase  ,							__UpperCamelCase       =			noise_pred.chunk(2			)
																									__UpperCamelCase  ,							__UpperCamelCase       =			variance_pred.chunk(2			)
																									__UpperCamelCase       =			noise_pred_uncond + guidance_scale * (noise_pred_text - noise_pred_uncond)
																									__UpperCamelCase       =			torch.cat([noise_pred, variance_pred_text]     ,	dim=1			)

																			if not (
																			    hasattr(self.scheduler.config     ,	'''variance_type'''			)
																			    and self.scheduler.config.variance_type in ["learned", "learned_range"]
																			):
																									__UpperCamelCase  ,							__UpperCamelCase       =			noise_pred.split(latents.shape[1]     ,	dim=1			)

																			# compute the previous noisy sample x_t -> x_t-1
																			__UpperCamelCase       =			self.scheduler.step(
																			    SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	generator=SCREAMING_SNAKE_CASE_     ,	)[0]
													# post-processing
													__UpperCamelCase       =			self.movq.decode(SCREAMING_SNAKE_CASE_     ,	force_not_quantize=SCREAMING_SNAKE_CASE_			)['''sample''']

													if output_type not in ["pt", "np", "pil"]:
																			raise ValueError(F"Only the output types `pt`, `pil` and `np` are supported not output_type={output_type}"			)

													if output_type in ["np", "pil"]:
																			__UpperCamelCase       =			image * 0.5 + 0.5
																			__UpperCamelCase       =			image.clamp(0     ,	1			)
																			__UpperCamelCase       =			image.cpu().permute(0     ,	2     ,	3     ,	1			).float().numpy()

													if output_type == "pil":
																			__UpperCamelCase       =			self.numpy_to_pil(SCREAMING_SNAKE_CASE_			)

													if not return_dict:
																			return (image,)

													return ImagePipelineOutput(images=SCREAMING_SNAKE_CASE_			)






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, is_torch_available, is_vision_available
from transformers.testing_utils import require_torch, require_torch_multi_gpu, require_vision, slow, torch_device
from transformers.utils import cached_property

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
				import torch

				from transformers import MaskaFormerForUniversalSegmentation, MaskaFormerModel

				if is_vision_available():
								from transformers import MaskaFormerImageProcessor

if is_vision_available():
				from PIL import Image






class        SCREAMING_SNAKE_CASE__    :

							"""simple docstring"""






							def __init__(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=2     ,	SCREAMING_SNAKE_CASE_=True     ,	SCREAMING_SNAKE_CASE_=False     ,	SCREAMING_SNAKE_CASE_=10     ,	SCREAMING_SNAKE_CASE_=3     ,	SCREAMING_SNAKE_CASE_=32 * 8     ,	SCREAMING_SNAKE_CASE_=32 * 8     ,	SCREAMING_SNAKE_CASE_=4     ,	SCREAMING_SNAKE_CASE_=64     ,	)->   Dict:





													'''simple docstring'''






													__UpperCamelCase       =			parent
													__UpperCamelCase       =			batch_size
													__UpperCamelCase       =			is_training
													__UpperCamelCase       =			use_auxiliary_loss
													__UpperCamelCase       =			num_queries
													__UpperCamelCase       =			num_channels
													__UpperCamelCase       =			min_size
													__UpperCamelCase       =			max_size
													__UpperCamelCase       =			num_labels
													__UpperCamelCase       =			hidden_dim
													__UpperCamelCase       =			hidden_dim



							def     A__		(  self			)->   Optional[int]:





													'''simple docstring'''






													__UpperCamelCase       =			floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]			).to(
													    SCREAMING_SNAKE_CASE_			)

													__UpperCamelCase       =			torch.ones([self.batch_size, self.min_size, self.max_size]     ,	device=SCREAMING_SNAKE_CASE_			)

													__UpperCamelCase       =			(
													    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]     ,	device=SCREAMING_SNAKE_CASE_			) > 0.5
													).float()
													__UpperCamelCase       =			(torch.rand((self.batch_size, self.num_labels)     ,	device=SCREAMING_SNAKE_CASE_			) > 0.5).long()

													__UpperCamelCase       =			self.get_config()
													return config, pixel_values, pixel_mask, mask_labels, class_labels



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





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerConfig(
													    hidden_size=self.hidden_dim     ,	)
													__UpperCamelCase       =			self.num_queries
													__UpperCamelCase       =			self.num_labels

													__UpperCamelCase       =			[1, 1, 1, 1]
													__UpperCamelCase       =			self.num_channels

													__UpperCamelCase       =			64
													__UpperCamelCase       =			128
													__UpperCamelCase       =			self.hidden_dim
													__UpperCamelCase       =			self.hidden_dim
													__UpperCamelCase       =			self.hidden_dim
													return config



							def     A__		(  self			)->   Any:





													'''simple docstring'''






													__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase       =			self.prepare_config_and_inputs()
													__UpperCamelCase       =			{'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
													return config, inputs_dict



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)->   Any:





													'''simple docstring'''






													__UpperCamelCase       =			output.encoder_hidden_states
													__UpperCamelCase       =			output.pixel_decoder_hidden_states
													__UpperCamelCase       =			output.transformer_decoder_hidden_states

													self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_			)     ,	len(config.backbone_config.depths			)			)
													self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_			)     ,	len(config.backbone_config.depths			)			)
													self.parent.assertTrue(len(SCREAMING_SNAKE_CASE_			)     ,	config.decoder_layers			)



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_=False			)->   Tuple:





													'''simple docstring'''






													with torch.no_grad():
																			__UpperCamelCase       =			MaskaFormerModel(config=SCREAMING_SNAKE_CASE_			)
																			model.to(SCREAMING_SNAKE_CASE_			)
																			model.eval()

																			__UpperCamelCase       =			model(pixel_values=SCREAMING_SNAKE_CASE_     ,	pixel_mask=SCREAMING_SNAKE_CASE_			)
																			__UpperCamelCase       =			model(SCREAMING_SNAKE_CASE_     ,	output_hidden_states=SCREAMING_SNAKE_CASE_			)

													self.parent.assertEqual(
													    output.transformer_decoder_last_hidden_state.shape     ,	(self.batch_size, self.num_queries, self.hidden_dim)     ,	)
													# let's ensure the other two hidden state exists
													self.parent.assertTrue(output.pixel_decoder_last_hidden_state is not None			)
													self.parent.assertTrue(output.encoder_last_hidden_state is not None			)

													if output_hidden_states:
																			self.check_output_hidden_state(SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)



							def     A__		(  self     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_     ,	SCREAMING_SNAKE_CASE_			)->   List[str]:





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerForUniversalSegmentation(config=SCREAMING_SNAKE_CASE_			)
													model.to(SCREAMING_SNAKE_CASE_			)
													model.eval()

													def comm_check_on_output(SCREAMING_SNAKE_CASE_			):
																			# let's still check that all the required stuff is there
																			self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None			)
																			self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None			)
																			self.parent.assertTrue(result.encoder_last_hidden_state is not None			)
																			# okay, now we need to check the logits shape
																			# due to the encoder compression, masks have a //4 spatial size
																			self.parent.assertEqual(
																			    result.masks_queries_logits.shape     ,	(self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)     ,	)
																			# + 1 for null class
																			self.parent.assertEqual(
																			    result.class_queries_logits.shape     ,	(self.batch_size, self.num_queries, self.num_labels + 1)			)

													with torch.no_grad():
																			__UpperCamelCase       =			model(pixel_values=SCREAMING_SNAKE_CASE_     ,	pixel_mask=SCREAMING_SNAKE_CASE_			)
																			__UpperCamelCase       =			model(SCREAMING_SNAKE_CASE_			)

																			comm_check_on_output(SCREAMING_SNAKE_CASE_			)

																			__UpperCamelCase       =			model(
																			    pixel_values=SCREAMING_SNAKE_CASE_     ,	pixel_mask=SCREAMING_SNAKE_CASE_     ,	mask_labels=SCREAMING_SNAKE_CASE_     ,	class_labels=SCREAMING_SNAKE_CASE_			)

													comm_check_on_output(SCREAMING_SNAKE_CASE_			)

													self.parent.assertTrue(result.loss is not None			)
													self.parent.assertEqual(result.loss.shape     ,	torch.Size([1]			)			)






@require_torch
class        SCREAMING_SNAKE_CASE__    (							SCREAMING_SNAKE_CASE_   ,		SCREAMING_SNAKE_CASE_   ,		unittest.TestCase    ):

							"""simple docstring"""






							_snake_case     		=  (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
							_snake_case     		=  {'feature-extraction': MaskaFormerModel} if is_torch_available() else {}

							_snake_case     		=  False
							_snake_case     		=  False
							_snake_case     		=  False
							_snake_case     		=  False



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





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerModelTester(self			)
													__UpperCamelCase       =			ConfigTester(self     ,	config_class=SCREAMING_SNAKE_CASE_     ,	has_text_modality=SCREAMING_SNAKE_CASE_			)



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





													'''simple docstring'''






													self.config_tester.run_common_tests()



							def     A__		(  self			)->   int:





													'''simple docstring'''






													__UpperCamelCase  ,							__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.create_and_check_maskaformer_model(SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_     ,	output_hidden_states=SCREAMING_SNAKE_CASE_			)



							def     A__		(  self			)->   Tuple:





													'''simple docstring'''






													__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs()
													self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*SCREAMING_SNAKE_CASE_			)



							@unittest.skip(reason='''Mask2Former does not use inputs_embeds'''			)
							def     A__		(  self			)->   Any:





													'''simple docstring'''






													pass



							@unittest.skip(reason='''Mask2Former does not have a get_input_embeddings method'''			)
							def     A__		(  self			)->   Union[str, Any]:





													'''simple docstring'''






													pass



							@unittest.skip(reason='''Mask2Former is not a generative model'''			)
							def     A__		(  self			)->   Optional[Any]:





													'''simple docstring'''






													pass



							@unittest.skip(reason='''Mask2Former does not use token embeddings'''			)
							def     A__		(  self			)->   List[str]:





													'''simple docstring'''






													pass



							@require_torch_multi_gpu
							@unittest.skip(
							    reason='''Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''			)
							def     A__		(  self			)->   Dict:





													'''simple docstring'''






													pass



							@unittest.skip('''Will be fixed soon by reducing the size of the model used for common tests.'''			)
							def     A__		(  self			)->   str:





													'''simple docstring'''






													pass



							def     A__		(  self			)->   str:





													'''simple docstring'''






													__UpperCamelCase  ,							__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs_for_common()

													for model_class in self.all_model_classes:
																			__UpperCamelCase       =			model_class(SCREAMING_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]     ,	SCREAMING_SNAKE_CASE_			)



							@slow
							def     A__		(  self			)->   Any:





													'''simple docstring'''






													for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
																			__UpperCamelCase       =			MaskaFormerModel.from_pretrained(SCREAMING_SNAKE_CASE_			)
																			self.assertIsNotNone(SCREAMING_SNAKE_CASE_			)



							def     A__		(  self			)->   Optional[int]:





													'''simple docstring'''






													__UpperCamelCase       =			(self.model_tester.min_size,) * 2
													__UpperCamelCase       =			{
													    '''pixel_values''': torch.randn((2, 3, *size)     ,	device=SCREAMING_SNAKE_CASE_			),
													    '''mask_labels''': torch.randn((2, 10, *size)     ,	device=SCREAMING_SNAKE_CASE_			),
													    '''class_labels''': torch.zeros(2     ,	10     ,	device=SCREAMING_SNAKE_CASE_			).long(),
													}
													__UpperCamelCase       =			self.model_tester.get_config()

													__UpperCamelCase       =			MaskaFormerForUniversalSegmentation(SCREAMING_SNAKE_CASE_			).to(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			model(**SCREAMING_SNAKE_CASE_			)
													self.assertTrue(outputs.loss is not None			)



							def     A__		(  self			)->   Tuple:





													'''simple docstring'''






													__UpperCamelCase  ,							__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs_for_common()
													self.model_tester.create_and_check_maskaformer_model(SCREAMING_SNAKE_CASE_     ,	**SCREAMING_SNAKE_CASE_     ,	output_hidden_states=SCREAMING_SNAKE_CASE_			)



							def     A__		(  self			)->   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(SCREAMING_SNAKE_CASE_			).to(SCREAMING_SNAKE_CASE_			)
																			__UpperCamelCase       =			model(**SCREAMING_SNAKE_CASE_     ,	output_attentions=SCREAMING_SNAKE_CASE_			)
																			self.assertTrue(outputs.attentions is not None			)



							def     A__		(  self			)->   Any:





													'''simple docstring'''






													if not self.model_tester.is_training:
																			return

													__UpperCamelCase       =			self.all_model_classes[1]
													__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs()

													__UpperCamelCase       =			model_class(SCREAMING_SNAKE_CASE_			)
													model.to(SCREAMING_SNAKE_CASE_			)
													model.train()

													__UpperCamelCase       =			model(SCREAMING_SNAKE_CASE_     ,	mask_labels=SCREAMING_SNAKE_CASE_     ,	class_labels=SCREAMING_SNAKE_CASE_			).loss
													loss.backward()



							def     A__		(  self			)->   Tuple:





													'''simple docstring'''






													__UpperCamelCase       =			self.all_model_classes[1]
													__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase  ,							__UpperCamelCase       =			self.model_tester.prepare_config_and_inputs()
													__UpperCamelCase       =			True
													__UpperCamelCase       =			True

													__UpperCamelCase       =			model_class(SCREAMING_SNAKE_CASE_			).to(SCREAMING_SNAKE_CASE_			)
													model.train()

													__UpperCamelCase       =			model(SCREAMING_SNAKE_CASE_     ,	mask_labels=SCREAMING_SNAKE_CASE_     ,	class_labels=SCREAMING_SNAKE_CASE_			)

													__UpperCamelCase       =			outputs.encoder_hidden_states[0]
													encoder_hidden_states.retain_grad()

													__UpperCamelCase       =			outputs.pixel_decoder_hidden_states[0]
													pixel_decoder_hidden_states.retain_grad()

													__UpperCamelCase       =			outputs.transformer_decoder_hidden_states[0]
													transformer_decoder_hidden_states.retain_grad()

													__UpperCamelCase       =			outputs.attentions[0]
													attentions.retain_grad()

													outputs.loss.backward(retain_graph=SCREAMING_SNAKE_CASE_			)

													self.assertIsNotNone(encoder_hidden_states.grad			)
													self.assertIsNotNone(pixel_decoder_hidden_states.grad			)
													self.assertIsNotNone(transformer_decoder_hidden_states.grad			)
													self.assertIsNotNone(attentions.grad			)





lowercase__							:							Any									=			1e-4




def 	A_ (							)      ->    List[Any]:



						'''simple docstring'''

						__UpperCamelCase       =			Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png''' )
						return image






@require_vision
@slow
class        SCREAMING_SNAKE_CASE__    (							unittest.TestCase    ):

							"""simple docstring"""






							@cached_property
							def     A__		(  self			)->   List[Any]:





													'''simple docstring'''






													return "facebook/mask2former-swin-small-coco-instance"



							@cached_property
							def     A__		(  self			)->   Any:





													'''simple docstring'''






													return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints			) if is_vision_available() else None



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





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerModel.from_pretrained(self.model_checkpoints			).to(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			self.default_image_processor
													__UpperCamelCase       =			prepare_img()
													__UpperCamelCase       =			image_processor(SCREAMING_SNAKE_CASE_     ,	return_tensors='''pt'''			).to(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			inputs['''pixel_values'''].shape
													# check size is divisible by 32
													self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0			)
													# check size
													self.assertEqual(SCREAMING_SNAKE_CASE_     ,	(1, 3, 384, 384)			)

													with torch.no_grad():
																			__UpperCamelCase       =			model(**SCREAMING_SNAKE_CASE_			)

													__UpperCamelCase       =			torch.tensor(
													    [[-0.2_7_9_0, -1.0_7_1_7, -1.1_6_6_8], [-0.5_1_2_8, -0.3_1_2_8, -0.4_9_8_7], [-0.5_8_3_2, 0.1_9_7_1, -0.0_1_9_7]]			).to(SCREAMING_SNAKE_CASE_			)
													self.assertTrue(
													    torch.allclose(
													        outputs.encoder_last_hidden_state[0, 0, :3, :3]     ,	SCREAMING_SNAKE_CASE_     ,	atol=SCREAMING_SNAKE_CASE_			)			)

													__UpperCamelCase       =			torch.tensor(
													    [[0.8_9_7_3, 1.1_8_4_7, 1.1_7_7_6], [1.1_9_3_4, 1.5_0_4_0, 1.5_1_2_8], [1.1_1_5_3, 1.4_4_8_6, 1.4_9_5_1]]			).to(SCREAMING_SNAKE_CASE_			)
													self.assertTrue(
													    torch.allclose(
													        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]     ,	SCREAMING_SNAKE_CASE_     ,	atol=SCREAMING_SNAKE_CASE_			)			)

													__UpperCamelCase       =			torch.tensor(
													    [[2.1_1_5_2, 1.7_0_0_0, -0.8_6_0_3], [1.5_8_0_8, 1.8_0_0_4, -0.9_3_5_3], [1.6_0_4_3, 1.7_4_9_5, -0.5_9_9_9]]			).to(SCREAMING_SNAKE_CASE_			)
													self.assertTrue(
													    torch.allclose(
													        outputs.transformer_decoder_last_hidden_state[0, :3, :3]     ,	SCREAMING_SNAKE_CASE_     ,	atol=SCREAMING_SNAKE_CASE_			)			)



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





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints			).to(SCREAMING_SNAKE_CASE_			).eval()
													__UpperCamelCase       =			self.default_image_processor
													__UpperCamelCase       =			prepare_img()
													__UpperCamelCase       =			image_processor(SCREAMING_SNAKE_CASE_     ,	return_tensors='''pt'''			).to(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			inputs['''pixel_values'''].shape
													# check size is divisible by 32
													self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0			)
													# check size
													self.assertEqual(SCREAMING_SNAKE_CASE_     ,	(1, 3, 384, 384)			)

													with torch.no_grad():
																			__UpperCamelCase       =			model(**SCREAMING_SNAKE_CASE_			)
													# masks_queries_logits
													__UpperCamelCase       =			outputs.masks_queries_logits
													self.assertEqual(
													    masks_queries_logits.shape     ,	(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)			)
													__UpperCamelCase       =			[
													    [-8.7_8_3_9, -9.0_0_5_6, -8.8_1_2_1],
													    [-7.4_1_0_4, -7.0_3_1_3, -6.5_4_0_1],
													    [-6.6_1_0_5, -6.3_4_2_7, -6.4_6_7_5],
													]
													__UpperCamelCase       =			torch.tensor(SCREAMING_SNAKE_CASE_			).to(SCREAMING_SNAKE_CASE_			)
													self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]     ,	SCREAMING_SNAKE_CASE_     ,	atol=SCREAMING_SNAKE_CASE_			)			)
													# class_queries_logits
													__UpperCamelCase       =			outputs.class_queries_logits
													self.assertEqual(class_queries_logits.shape     ,	(1, model.config.num_queries, model.config.num_labels + 1)			)
													__UpperCamelCase       =			torch.tensor(
													    [
													        [1.8_3_2_4, -8.0_8_3_5, -4.1_9_2_2],
													        [0.8_4_5_0, -9.0_0_5_0, -3.6_0_5_3],
													        [0.3_0_4_5, -7.7_2_9_3, -3.0_2_7_5],
													    ]			).to(SCREAMING_SNAKE_CASE_			)
													self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,	SCREAMING_SNAKE_CASE_     ,	atol=SCREAMING_SNAKE_CASE_			)			)



							def     A__		(  self			)->   str:





													'''simple docstring'''






													__UpperCamelCase       =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints			).to(SCREAMING_SNAKE_CASE_			).eval()
													__UpperCamelCase       =			self.default_image_processor

													__UpperCamelCase       =			image_processor(
													    [np.zeros((3, 800, 1333)			), np.zeros((3, 800, 1333)			)]     ,	segmentation_maps=[np.zeros((384, 384)			).astype(np.floataa			), np.zeros((384, 384)			).astype(np.floataa			)]     ,	return_tensors='''pt'''     ,	)

													__UpperCamelCase       =			inputs['''pixel_values'''].to(SCREAMING_SNAKE_CASE_			)
													__UpperCamelCase       =			[el.to(SCREAMING_SNAKE_CASE_			) for el in inputs['''mask_labels''']]
													__UpperCamelCase       =			[el.to(SCREAMING_SNAKE_CASE_			) for el in inputs['''class_labels''']]

													with torch.no_grad():
																			__UpperCamelCase       =			model(**SCREAMING_SNAKE_CASE_			)

													self.assertTrue(outputs.loss is not None			)




