

'''simple docstring'''






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, 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 MaskFormerForInstanceSegmentation, MaskFormerModel

	if is_vision_available():
		from transformers import MaskFormerImageProcessor

if is_vision_available():
	from PIL import Image






class     lowercase_			:




		"""simple docstring"""




		def __init__(   self     :  List[Any]      ,lowercase__     :  Any      ,lowercase__     :  Tuple=2      ,lowercase__     :  Union[str, Any]=True      ,lowercase__     :  Any=False      ,lowercase__     :  List[str]=1_0      ,lowercase__     :  Dict=3      ,lowercase__     :  Optional[Any]=3_2 * 4      ,lowercase__     :  Union[str, Any]=3_2 * 6      ,lowercase__     :  Union[str, Any]=4      ,lowercase__     :  List[Any]=3_2      ,):
			__lowercase													=				parent
			__lowercase													=				batch_size
			__lowercase													=				is_training
			__lowercase													=				use_auxiliary_loss
			__lowercase													=				num_queries
			__lowercase													=				num_channels
			__lowercase													=				min_size
			__lowercase													=				max_size
			__lowercase													=				num_labels
			__lowercase													=				mask_feature_size






		def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
			__lowercase													=				floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]    ).to(
			    lowercase__    )

			__lowercase													=				torch.ones([self.batch_size, self.min_size, self.max_size]      ,device=lowercase__    )

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

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






		def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
			return MaskFormerConfig.from_backbone_and_decoder_configs(
			    backbone_config=SwinConfig(
			        depths=[1, 1, 1, 1]      ,)      ,decoder_config=DetrConfig(
			        decoder_ffn_dim=1_2_8      ,num_queries=self.num_queries      ,decoder_attention_heads=2      ,d_model=self.mask_feature_size      ,)      ,mask_feature_size=self.mask_feature_size      ,fpn_feature_size=self.mask_feature_size      ,num_channels=self.num_channels      ,num_labels=self.num_labels      ,)






		def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase													=				self.prepare_config_and_inputs()
			__lowercase													=				{'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
			return config, inputs_dict






		def       SCREAMING_SNAKE_CASE   (   self     :  Tuple      ,lowercase__     :  List[Any]      ,lowercase__     :  Any    ):
			__lowercase													=				output.encoder_hidden_states
			__lowercase													=				output.pixel_decoder_hidden_states
			__lowercase													=				output.transformer_decoder_hidden_states

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






		def       SCREAMING_SNAKE_CASE   (   self     :  str      ,lowercase__     :  Tuple      ,lowercase__     :  List[str]      ,lowercase__     :  Any      ,lowercase__     :  Tuple=False    ):
			with torch.no_grad():
				__lowercase													=				MaskFormerModel(config=lowercase__    )
				model.to(lowercase__    )
				model.eval()

				__lowercase													=				model(pixel_values=lowercase__      ,pixel_mask=lowercase__    )
				__lowercase													=				model(lowercase__      ,output_hidden_states=lowercase__    )
			# the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
			# encoder and pixel decoder
			self.parent.assertEqual(
			    output.transformer_decoder_last_hidden_state.shape      ,(self.batch_size, self.num_queries, self.mask_feature_size)      ,)
			# 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(lowercase__      ,lowercase__    )






		def       SCREAMING_SNAKE_CASE   (   self     :  int      ,lowercase__     :  List[str]      ,lowercase__     :  Optional[Any]      ,lowercase__     :  Dict      ,lowercase__     :  Optional[Any]      ,lowercase__     :  List[str]    ):
			__lowercase													=				MaskFormerForInstanceSegmentation(config=lowercase__    )
			model.to(lowercase__    )
			model.eval()

			def comm_check_on_output(lowercase__     :  str    ):
				# 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():
				__lowercase													=				model(pixel_values=lowercase__      ,pixel_mask=lowercase__    )
				__lowercase													=				model(lowercase__    )

				comm_check_on_output(lowercase__    )

				__lowercase													=				model(
				    pixel_values=lowercase__      ,pixel_mask=lowercase__      ,mask_labels=lowercase__      ,class_labels=lowercase__    )

			comm_check_on_output(lowercase__    )

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






@require_torch
class     lowercase_			(lowerCamelCase__       , lowerCamelCase__       , unittest.TestCase   ):




		"""simple docstring"""




		SCREAMING_SNAKE_CASE					:						Any           =    (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
		SCREAMING_SNAKE_CASE					:						Optional[int]           =    (
		    {'feature-extraction': MaskFormerModel, 'image-segmentation': MaskFormerForInstanceSegmentation}
		    if is_torch_available()
		    else {}
		)

		SCREAMING_SNAKE_CASE					:						str           =    False
		SCREAMING_SNAKE_CASE					:						Dict           =    False
		SCREAMING_SNAKE_CASE					:						Optional[Any]           =    False
		SCREAMING_SNAKE_CASE					:						List[str]           =    False






		def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
			__lowercase													=				MaskFormerModelTester(self    )
			__lowercase													=				ConfigTester(self      ,config_class=lowercase__      ,has_text_modality=lowercase__    )






		def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
			self.config_tester.run_common_tests()






		def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs_for_common()
			self.model_tester.create_and_check_maskformer_model(lowercase__      ,**lowercase__      ,output_hidden_states=lowercase__    )






		def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
			__lowercase													=				self.model_tester.prepare_config_and_inputs()
			self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*lowercase__    )






		@unittest.skip(reason='''MaskFormer does not use inputs_embeds'''    )
		def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
			pass






		@unittest.skip(reason='''MaskFormer does not have a get_input_embeddings method'''    )
		def       SCREAMING_SNAKE_CASE   (   self     :  Tuple    ):
			pass






		@unittest.skip(reason='''MaskFormer is not a generative model'''    )
		def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
			pass






		@unittest.skip(reason='''MaskFormer does not use token embeddings'''    )
		def       SCREAMING_SNAKE_CASE   (   self     :  Union[str, Any]    ):
			pass






		@require_torch_multi_gpu
		@unittest.skip(
		    reason='''MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'''    )
		def       SCREAMING_SNAKE_CASE   (   self     :  Optional[int]    ):
			pass






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






		def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs_for_common()

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

				__lowercase													=				['''pixel_values''']
				self.assertListEqual(arg_names[:1]      ,lowercase__    )






		@slow
		def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
			for model_name in ["facebook/maskformer-swin-small-coco"]:
				__lowercase													=				MaskFormerModel.from_pretrained(lowercase__    )
				self.assertIsNotNone(lowercase__    )






		def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
			__lowercase													=				(self.model_tester.min_size,) * 2
			__lowercase													=				{
			    '''pixel_values''': torch.randn((2, 3, *size)      ,device=lowercase__    ),
			    '''mask_labels''': torch.randn((2, 1_0, *size)      ,device=lowercase__    ),
			    '''class_labels''': torch.zeros(2      ,1_0      ,device=lowercase__    ).long(),
			}

			__lowercase													=				MaskFormerForInstanceSegmentation(MaskFormerConfig()    ).to(lowercase__    )
			__lowercase													=				model(**lowercase__    )
			self.assertTrue(outputs.loss is not None    )






		def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs_for_common()
			self.model_tester.create_and_check_maskformer_model(lowercase__      ,**lowercase__      ,output_hidden_states=lowercase__    )






		def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs_for_common()

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






		def       SCREAMING_SNAKE_CASE   (   self     :  int    ):
			if not self.model_tester.is_training:
				return
			# only MaskFormerForInstanceSegmentation has the loss
			__lowercase													=				self.all_model_classes[1]
			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs()

			__lowercase													=				model_class(lowercase__    )
			model.to(lowercase__    )
			model.train()

			__lowercase													=				model(lowercase__      ,mask_labels=lowercase__      ,class_labels=lowercase__    ).loss
			loss.backward()






		def       SCREAMING_SNAKE_CASE   (   self     :  str    ):
			# only MaskFormerForInstanceSegmentation has the loss
			__lowercase													=				self.all_model_classes[1]
			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase						,			__lowercase													=				self.model_tester.prepare_config_and_inputs()
			__lowercase													=				True
			__lowercase													=				True

			__lowercase													=				model_class(lowercase__    )
			model.to(lowercase__    )
			model.train()

			__lowercase													=				model(lowercase__      ,mask_labels=lowercase__      ,class_labels=lowercase__    )

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

			__lowercase													=				outputs.pixel_decoder_hidden_states[0]
			pixel_decoder_hidden_states.retain_grad()
			# we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
			__lowercase													=				outputs.transformer_decoder_hidden_states[0]
			transformer_decoder_hidden_states.retain_grad()

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

			outputs.loss.backward(retain_graph=lowercase__    )

			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__      		=			1e-4


def 	_A  (					):






	"""simple docstring"""



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






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




		"""simple docstring"""




		@cached_property
		def       SCREAMING_SNAKE_CASE   (   self     :  List[Any]    ):
			return (
			    MaskFormerImageProcessor.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
			    if is_vision_available()
			    else None
			)






		def       SCREAMING_SNAKE_CASE   (   self     :  List[str]    ):
			__lowercase													=				MaskFormerModel.from_pretrained('''facebook/maskformer-swin-small-coco'''    ).to(lowercase__    )
			__lowercase													=				self.default_image_processor
			__lowercase													=				prepare_img()
			__lowercase													=				image_processor(lowercase__      ,return_tensors='''pt'''    ).to(lowercase__    )
			__lowercase													=				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(lowercase__      ,(1, 3, 8_0_0, 1_0_8_8)    )

			with torch.no_grad():
				__lowercase													=				model(**lowercase__    )

			__lowercase													=				torch.tensor(
			    [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]]    ).to(lowercase__    )
			self.assertTrue(
			    torch.allclose(
			        outputs.encoder_last_hidden_state[0, 0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )

			__lowercase													=				torch.tensor(
			    [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]]    ).to(lowercase__    )
			self.assertTrue(
			    torch.allclose(
			        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )

			__lowercase													=				torch.tensor(
			    [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]]    ).to(lowercase__    )
			self.assertTrue(
			    torch.allclose(
			        outputs.transformer_decoder_last_hidden_state[0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )






		def       SCREAMING_SNAKE_CASE   (   self     :  Any    ):
			__lowercase													=				(
			    MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
			    .to(lowercase__    )
			    .eval()
			)
			__lowercase													=				self.default_image_processor
			__lowercase													=				prepare_img()
			__lowercase													=				image_processor(lowercase__      ,return_tensors='''pt'''    ).to(lowercase__    )
			__lowercase													=				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(lowercase__      ,(1, 3, 8_0_0, 1_0_8_8)    )

			with torch.no_grad():
				__lowercase													=				model(**lowercase__    )
			# masks_queries_logits
			__lowercase													=				outputs.masks_queries_logits
			self.assertEqual(
			    masks_queries_logits.shape      ,(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)      ,)
			__lowercase													=				[
			    [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3],
			    [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5],
			    [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2],
			]
			__lowercase													=				torch.tensor(lowercase__    ).to(lowercase__    )
			self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )
			# class_queries_logits
			__lowercase													=				outputs.class_queries_logits
			self.assertEqual(
			    class_queries_logits.shape      ,(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
			__lowercase													=				torch.tensor(
			    [
			        [1.6_5_1_2e0_0, -5.2_5_7_2e0_0, -3.3_5_1_9e0_0],
			        [3.6_1_6_9e-0_2, -5.9_0_2_5e0_0, -2.9_3_1_3e0_0],
			        [1.0_7_6_6e-0_4, -7.7_6_3_0e0_0, -5.1_2_6_3e0_0],
			    ]    ).to(lowercase__    )
			self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )






		def       SCREAMING_SNAKE_CASE   (   self     :  Dict    ):
			__lowercase													=				(
			    MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-resnet101-coco-stuff'''    )
			    .to(lowercase__    )
			    .eval()
			)
			__lowercase													=				self.default_image_processor
			__lowercase													=				prepare_img()
			__lowercase													=				image_processor(lowercase__      ,return_tensors='''pt'''    ).to(lowercase__    )
			__lowercase													=				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(lowercase__      ,(1, 3, 8_0_0, 1_0_8_8)    )

			with torch.no_grad():
				__lowercase													=				model(**lowercase__    )
			# masks_queries_logits
			__lowercase													=				outputs.masks_queries_logits
			self.assertEqual(
			    masks_queries_logits.shape      ,(1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4)      ,)
			__lowercase													=				[[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]]
			__lowercase													=				torch.tensor(lowercase__    ).to(lowercase__    )
			self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )
			# class_queries_logits
			__lowercase													=				outputs.class_queries_logits
			self.assertEqual(
			    class_queries_logits.shape      ,(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)    )
			__lowercase													=				torch.tensor(
			    [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]]    ).to(lowercase__    )
			self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]      ,lowercase__      ,atol=lowercase__    )    )






		def       SCREAMING_SNAKE_CASE   (   self     :  Tuple    ):
			__lowercase													=				(
			    MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco'''    )
			    .to(lowercase__    )
			    .eval()
			)
			__lowercase													=				self.default_image_processor

			__lowercase													=				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'''      ,)

			__lowercase													=				inputs['''pixel_values'''].to(lowercase__    )
			__lowercase													=				[el.to(lowercase__    ) for el in inputs['''mask_labels''']]
			__lowercase													=				[el.to(lowercase__    ) for el in inputs['''class_labels''']]

			with torch.no_grad():
				__lowercase													=				model(**lowercase__    )

			self.assertTrue(outputs.loss is not None    )




'''simple docstring'''






def 	_A  (					A__   ):






 """simple docstring"""



 if not nums:  # Makes sure that the list is not empty
  raise ValueError('''List is empty'''   )

 __lowercase													=				sum(A__   ) / len(A__   )  # Calculate the average
 return sum(abs(x - average   ) for x in nums   ) / len(A__   )


if __name__ == "__main__":
 import doctest

 doctest.testmod()

