





'''simple docstring'''


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







	def __init__(				self			:   int , lowerCamelCase			:   int , lowerCamelCase			:   Dict=2 , lowerCamelCase			:   Optional[int]=True , lowerCamelCase			:   Tuple=False , lowerCamelCase			:   Tuple=1_0 , lowerCamelCase			:   Any=3 , lowerCamelCase			:   Union[str, Any]=3_2 * 8 , lowerCamelCase			:   List[str]=3_2 * 8 , lowerCamelCase			:   Union[str, Any]=4 , lowerCamelCase			:   Dict=6_4 , ):




				'''simple docstring'''
				a__     = parent
				a__     = batch_size
				a__     = is_training
				a__     = use_auxiliary_loss
				a__     = num_queries
				a__     = num_channels
				a__     = min_size
				a__     = max_size
				a__     = num_labels
				a__     = hidden_dim
				a__     = hidden_dim







	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				a__     = floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]		).to(
				    lowerCamelCase		)

				a__     = torch.ones([self.batch_size, self.min_size, self.max_size] , device=lowerCamelCase		)

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

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







	def 						__a   (				self			:   str		):




				'''simple docstring'''
				a__     = MaskaFormerConfig(
				    hidden_size=self.hidden_dim , )
				a__     = self.num_queries
				a__     = self.num_labels

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

				a__     = 6_4
				a__     = 1_2_8
				a__     = self.hidden_dim
				a__     = self.hidden_dim
				a__     = self.hidden_dim
				return config







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__   ,				a__   ,				a__   ,				a__   ,				a__     = self.prepare_config_and_inputs()
				a__     = {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
				return config, inputs_dict







	def 						__a   (				self			:   Any , lowerCamelCase			:   Tuple , lowerCamelCase			:   Optional[Any]		):




				'''simple docstring'''
				a__     = output.encoder_hidden_states
				a__     = output.pixel_decoder_hidden_states
				a__     = output.transformer_decoder_hidden_states

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







	def 						__a   (				self			:   Tuple , lowerCamelCase			:   Any , lowerCamelCase			:   str , lowerCamelCase			:   str , lowerCamelCase			:   Union[str, Any]=False		):




				'''simple docstring'''
				with torch.no_grad():
							a__     = MaskaFormerModel(config=lowerCamelCase		)
							model.to(lowerCamelCase		)
							model.eval()

							a__     = model(pixel_values=lowerCamelCase , pixel_mask=lowerCamelCase		)
							a__     = model(lowerCamelCase , output_hidden_states=lowerCamelCase		)

				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(lowerCamelCase , lowerCamelCase		)







	def 						__a   (				self			:   List[str] , lowerCamelCase			:   Tuple , lowerCamelCase			:   List[Any] , lowerCamelCase			:   List[str] , lowerCamelCase			:   List[str] , lowerCamelCase			:   Union[str, Any]		):




				'''simple docstring'''
				a__     = MaskaFormerForUniversalSegmentation(config=lowerCamelCase		)
				model.to(lowerCamelCase		)
				model.eval()

				def comm_check_on_output(lowerCamelCase			:   Dict		):
							# 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():
							a__     = model(pixel_values=lowerCamelCase , pixel_mask=lowerCamelCase		)
							a__     = model(lowerCamelCase		)

							comm_check_on_output(lowerCamelCase		)

							a__     = model(
							    pixel_values=lowerCamelCase , pixel_mask=lowerCamelCase , mask_labels=lowerCamelCase , class_labels=lowerCamelCase		)

				comm_check_on_output(lowerCamelCase		)

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






@require_torch
class       UpperCamelCase__  (		__lowerCAmelCase	,__lowerCAmelCase	,unittest.TestCase     ):
	lowerCAmelCase__					:			Union[str, Any]								=						(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
	lowerCAmelCase__					:			int								=						{"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

	lowerCAmelCase__					:			str								=						False
	lowerCAmelCase__					:			Union[str, Any]								=						False
	lowerCAmelCase__					:			Optional[int]								=						False
	lowerCAmelCase__					:			str								=						False







	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				a__     = MaskaFormerModelTester(self		)
				a__     = ConfigTester(self , config_class=lowerCamelCase , has_text_modality=lowerCamelCase		)







	def 						__a   (				self			:   str		):




				'''simple docstring'''
				self.config_tester.run_common_tests()







	def 						__a   (				self			:   Union[str, Any]		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.create_and_check_maskaformer_model(lowerCamelCase , **lowerCamelCase , output_hidden_states=lowerCamelCase		)







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__     = self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowerCamelCase		)







	@unittest.skip(reason="Mask2Former does not use inputs_embeds"		)
	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"		)
	def 						__a   (				self			:   int		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former is not a generative model"		)
	def 						__a   (				self			:   List[Any]		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former does not use token embeddings"		)
	def 						__a   (				self			:   int		):




				'''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			:   str		):




				'''simple docstring'''
				pass







	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
	def 						__a   (				self			:   Tuple		):




				'''simple docstring'''
				pass







	def 						__a   (				self			:   int		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()

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

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







	@slow
	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
							a__     = MaskaFormerModel.from_pretrained(lowerCamelCase		)
							self.assertIsNotNone(lowerCamelCase		)







	def 						__a   (				self			:   str		):




				'''simple docstring'''
				a__     = (self.model_tester.min_size,) * 2
				a__     = {
				    "pixel_values": torch.randn((2, 3, *size) , device=lowerCamelCase		),
				    "mask_labels": torch.randn((2, 1_0, *size) , device=lowerCamelCase		),
				    "class_labels": torch.zeros(2 , 1_0 , device=lowerCamelCase		).long(),
				}
				a__     = self.model_tester.get_config()

				a__     = MaskaFormerForUniversalSegmentation(lowerCamelCase		).to(lowerCamelCase		)
				a__     = model(**lowerCamelCase		)
				self.assertTrue(outputs.loss is not None		)







	def 						__a   (				self			:   Optional[Any]		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.create_and_check_maskaformer_model(lowerCamelCase , **lowerCamelCase , output_hidden_states=lowerCamelCase		)







	def 						__a   (				self			:   str		):




				'''simple docstring'''
				a__   ,				a__     = self.model_tester.prepare_config_and_inputs_for_common()

				for model_class in self.all_model_classes:
							a__     = model_class(lowerCamelCase		).to(lowerCamelCase		)
							a__     = model(**lowerCamelCase , output_attentions=lowerCamelCase		)
							self.assertTrue(outputs.attentions is not None		)







	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				if not self.model_tester.is_training:
							return

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

				a__     = model_class(lowerCamelCase		)
				model.to(lowerCamelCase		)
				model.train()

				a__     = model(lowerCamelCase , mask_labels=lowerCamelCase , class_labels=lowerCamelCase		).loss
				loss.backward()







	def 						__a   (				self			:   Optional[int]		):




				'''simple docstring'''
				a__     = self.all_model_classes[1]
				a__   ,				a__   ,				a__   ,				a__   ,				a__     = self.model_tester.prepare_config_and_inputs()
				a__     = True
				a__     = True

				a__     = model_class(lowerCamelCase		).to(lowerCamelCase		)
				model.train()

				a__     = model(lowerCamelCase , mask_labels=lowerCamelCase , class_labels=lowerCamelCase		)

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

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

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

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

				outputs.loss.backward(retain_graph=lowerCamelCase		)

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





lowerCAmelCase_   :   int       =					1E-4







def    _lowerCamelCase  ()   ->    str:
			a__     = Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
			return image






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







	@cached_property
	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				return "facebook/mask2former-swin-small-coco-instance"







	@cached_property
	def 						__a   (				self			:   Union[str, Any]		):




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







	def 						__a   (				self			:   Any		):




				'''simple docstring'''
				a__     = MaskaFormerModel.from_pretrained(self.model_checkpoints		).to(lowerCamelCase		)
				a__     = self.default_image_processor
				a__     = prepare_img()
				a__     = image_processor(lowerCamelCase , return_tensors="pt"		).to(lowerCamelCase		)
				a__     = inputs["pixel_values"].shape
				# check size is divisible by 32
				self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0		)
				# check size
				self.assertEqual(lowerCamelCase , (1, 3, 3_8_4, 3_8_4)		)

				with torch.no_grad():
							a__     = model(**lowerCamelCase		)

				a__     = torch.tensor(
				    [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]]		).to(lowerCamelCase		)
				self.assertTrue(
				    torch.allclose(
				        outputs.encoder_last_hidden_state[0, 0, :3, :3] , lowerCamelCase , atol=lowerCamelCase		)		)

				a__     = torch.tensor(
				    [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]]		).to(lowerCamelCase		)
				self.assertTrue(
				    torch.allclose(
				        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3] , lowerCamelCase , atol=lowerCamelCase		)		)

				a__     = torch.tensor(
				    [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]]		).to(lowerCamelCase		)
				self.assertTrue(
				    torch.allclose(
				        outputs.transformer_decoder_last_hidden_state[0, :3, :3] , lowerCamelCase , atol=lowerCamelCase		)		)







	def 						__a   (				self			:   Union[str, Any]		):




				'''simple docstring'''
				a__     = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).to(lowerCamelCase		).eval()
				a__     = self.default_image_processor
				a__     = prepare_img()
				a__     = image_processor(lowerCamelCase , return_tensors="pt"		).to(lowerCamelCase		)
				a__     = inputs["pixel_values"].shape
				# check size is divisible by 32
				self.assertTrue((inputs_shape[-1] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0		)
				# check size
				self.assertEqual(lowerCamelCase , (1, 3, 3_8_4, 3_8_4)		)

				with torch.no_grad():
							a__     = model(**lowerCamelCase		)
				# masks_queries_logits
				a__     = outputs.masks_queries_logits
				self.assertEqual(
				    masks_queries_logits.shape , (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)		)
				a__     = [
				    [-8.7839, -9.0056, -8.8121],
				    [-7.4104, -7.0313, -6.5401],
				    [-6.6105, -6.3427, -6.4675],
				]
				a__     = torch.tensor(lowerCamelCase		).to(lowerCamelCase		)
				self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3] , lowerCamelCase , atol=lowerCamelCase		)		)
				# class_queries_logits
				a__     = outputs.class_queries_logits
				self.assertEqual(class_queries_logits.shape , (1, model.config.num_queries, model.config.num_labels + 1)		)
				a__     = torch.tensor(
				    [
				        [1.8324, -8.0835, -4.1922],
				        [0.8450, -9.0050, -3.6053],
				        [0.3045, -7.7293, -3.0275],
				    ]		).to(lowerCamelCase		)
				self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3] , lowerCamelCase , atol=lowerCamelCase		)		)







	def 						__a   (				self			:   List[str]		):




				'''simple docstring'''
				a__     = MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).to(lowerCamelCase		).eval()
				a__     = self.default_image_processor

				a__     = image_processor(
				    [np.zeros((3, 8_0_0, 1_3_3_3)		), np.zeros((3, 8_0_0, 1_3_3_3)		)] , segmentation_maps=[np.zeros((3_8_4, 3_8_4)		).astype(np.floataa		), np.zeros((3_8_4, 3_8_4)		).astype(np.floataa		)] , return_tensors="pt" , )

				a__     = inputs["pixel_values"].to(lowerCamelCase		)
				a__     = [el.to(lowerCamelCase		) for el in inputs["mask_labels"]]
				a__     = [el.to(lowerCamelCase		) for el in inputs["class_labels"]]

				with torch.no_grad():
							a__     = model(**lowerCamelCase		)

				self.assertTrue(outputs.loss is not None		)










'''simple docstring'''


def    _lowerCamelCase  (__lowerCamelCase  :     list[list[float]]     )   ->    list[list[float]]:
			a__     = []
			for data in source_data:
						for i, el in enumerate(__lowerCamelCase     ):
									if len(__lowerCamelCase     ) < i + 1:
												data_lists.append([]     )
									data_lists[i].append(float(__lowerCamelCase     )     )
			return data_lists







def    _lowerCamelCase  (__lowerCamelCase  :     list[list[float]]					,  __lowerCamelCase  :     list[int]     )   ->    list[list[float]]:
			a__     = []
			for dlist, weight in zip(__lowerCamelCase					,  __lowerCamelCase     ):
						a__     = min(__lowerCamelCase     )
						a__     = max(__lowerCamelCase     )

						a__     = []
						# for weight 0 score is 1 - actual score
						if weight == 0:
									for item in dlist:
												try:
															score.append(1 - ((item - mind) / (maxd - mind))     )
												except ZeroDivisionError:
															score.append(1     )

						elif weight == 1:
									for item in dlist:
												try:
															score.append((item - mind) / (maxd - mind)     )
												except ZeroDivisionError:
															score.append(0     )

        # weight not 0 or 1
						else:
									a__     = f'''Invalid weight of {weight:f} provided'''
									raise ValueError(__lowerCamelCase     )

						score_lists.append(__lowerCamelCase     )

			return score_lists







def    _lowerCamelCase  (__lowerCamelCase  :     list[list[float]]     )   ->    list[float]:
			a__     = [0 for i in range(len(score_lists[0]     )     )]

			for slist in score_lists:
						for j, ele in enumerate(__lowerCamelCase     ):
									a__     = final_scores[j] + ele

			return final_scores







def    _lowerCamelCase  (__lowerCamelCase  :     list[list[float]]					,  __lowerCamelCase  :     list[int]     )   ->    list[list[float]]:
			a__     = get_data(__lowerCamelCase     )
			a__     = calculate_each_score(__lowerCamelCase					,  __lowerCamelCase     )
			a__     = generate_final_scores(__lowerCamelCase     )

			# append scores to source data
			for i, ele in enumerate(__lowerCamelCase     ):
						source_data[i].append(__lowerCamelCase     )

			return source_data



