"""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       a_      :




					def __init__(	self						:     List[Any]  ,						snake_case__						:     List[Any]  ,						snake_case__						:     List[str]=2  ,						snake_case__						:     Tuple=True  ,						snake_case__						:     Optional[Any]=False  ,						snake_case__						:     List[Any]=10  ,						snake_case__						:     str=3  ,						snake_case__						:     Any=32 * 4  ,						snake_case__						:     int=32 * 6  ,						snake_case__						:     int=4  ,						snake_case__						:     List[Any]=32  ,						):
							lowerCAmelCase__        =   parent
							lowerCAmelCase__        =   batch_size
							lowerCAmelCase__        =   is_training
							lowerCAmelCase__        =   use_auxiliary_loss
							lowerCAmelCase__        =   num_queries
							lowerCAmelCase__        =   num_channels
							lowerCAmelCase__        =   min_size
							lowerCAmelCase__        =   max_size
							lowerCAmelCase__        =   num_labels
							lowerCAmelCase__        =   mask_feature_size




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__        =   floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]     ).to(
							    snake_case__     )

							lowerCAmelCase__        =   torch.ones([self.batch_size, self.min_size, self.max_size]  ,						device=snake_case__     )

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

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							return MaskFormerConfig.from_backbone_and_decoder_configs(
							    backbone_config=SwinConfig(
							        depths=[1, 1, 1, 1]  ,						)  ,						decoder_config=DetrConfig(
							        decoder_ffn_dim=128  ,						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						:     Optional[Any]     ):
							lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__        =   self.prepare_config_and_inputs()
							lowerCAmelCase__        =   {"""pixel_values""": pixel_values, """pixel_mask""": pixel_mask}
							return config, inputs_dict




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int  ,						snake_case__						:     int  ,						snake_case__						:     Any     ):
							lowerCAmelCase__        =   output.encoder_hidden_states
							lowerCAmelCase__        =   output.pixel_decoder_hidden_states
							lowerCAmelCase__        =   output.transformer_decoder_hidden_states

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]  ,						snake_case__						:     Optional[int]  ,						snake_case__						:     Union[str, Any]  ,						snake_case__						:     Any  ,						snake_case__						:     Dict=False     ):
							with torch.no_grad():
									lowerCAmelCase__        =   MaskFormerModel(config=snake_case__     )
									model.to(snake_case__     )
									model.eval()

									lowerCAmelCase__        =   model(pixel_values=snake_case__  ,						pixel_mask=snake_case__     )
									lowerCAmelCase__        =   model(snake_case__  ,						output_hidden_states=snake_case__     )
							# 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(snake_case__  ,						snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]  ,						snake_case__						:     List[str]  ,						snake_case__						:     Optional[Any]  ,						snake_case__						:     int  ,						snake_case__						:     int  ,						snake_case__						:     Union[str, Any]     ):
							lowerCAmelCase__        =   MaskFormerForInstanceSegmentation(config=snake_case__     )
							model.to(snake_case__     )
							model.eval()

							def comm_check_on_output(snake_case__						:     int     ):
									# 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():
									lowerCAmelCase__        =   model(pixel_values=snake_case__  ,						pixel_mask=snake_case__     )
									lowerCAmelCase__        =   model(snake_case__     )

									comm_check_on_output(snake_case__     )

									lowerCAmelCase__        =   model(
									    pixel_values=snake_case__  ,						pixel_mask=snake_case__  ,						mask_labels=snake_case__  ,						class_labels=snake_case__     )

							comm_check_on_output(snake_case__     )

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

@require_torch
class       a_      (     __UpperCamelCase ,		__UpperCamelCase ,		unittest.TestCase			):
					UpperCamelCase_ :	str			=    (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
					UpperCamelCase_ :	Optional[Any]			=    (
					    {"feature-extraction": MaskFormerModel, "image-segmentation": MaskFormerForInstanceSegmentation}
					    if is_torch_available()
					    else {}
					)

					UpperCamelCase_ :	Tuple			=    False
					UpperCamelCase_ :	List[str]			=    False
					UpperCamelCase_ :	List[str]			=    False
					UpperCamelCase_ :	Dict			=    False




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   MaskFormerModelTester(self     )
							lowerCAmelCase__        =   ConfigTester(self  ,						config_class=snake_case__  ,						has_text_modality=snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							self.config_tester.run_common_tests()




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskformer_model(snake_case__  ,						**snake_case__  ,						output_hidden_states=snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*snake_case__     )




					@unittest.skip(reason="""MaskFormer does not use inputs_embeds"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Dict     ):
							pass




					@unittest.skip(reason="""MaskFormer does not have a get_input_embeddings method"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							pass




					@unittest.skip(reason="""MaskFormer is not a generative model"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     Tuple     ):
							pass




					@unittest.skip(reason="""MaskFormer does not use token embeddings"""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[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						:     List[Any]     ):
							pass




					@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""     )
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							pass




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()

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

									lowerCAmelCase__        =   ["""pixel_values"""]
									self.assertListEqual(arg_names[:1]  ,						snake_case__     )




					@slow
					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[str]     ):
							for model_name in ["facebook/maskformer-swin-small-coco"]:
									lowerCAmelCase__        =   MaskFormerModel.from_pretrained(snake_case__     )
									self.assertIsNotNone(snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     str     ):
							lowerCAmelCase__        =   (self.model_tester.min_size,) * 2
							lowerCAmelCase__        =   {
							    """pixel_values""": torch.randn((2, 3, *size)  ,						device=snake_case__     ),
							    """mask_labels""": torch.randn((2, 10, *size)  ,						device=snake_case__     ),
							    """class_labels""": torch.zeros(2  ,						10  ,						device=snake_case__     ).long(),
							}

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




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[int]     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskformer_model(snake_case__  ,						**snake_case__  ,						output_hidden_states=snake_case__     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs_for_common()

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




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

							lowerCAmelCase__        =   model_class(snake_case__     )
							model.to(snake_case__     )
							model.train()

							lowerCAmelCase__        =   model(snake_case__  ,						mask_labels=snake_case__  ,						class_labels=snake_case__     ).loss
							loss.backward()




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							# only MaskFormerForInstanceSegmentation has the loss
							lowerCAmelCase__        =   self.all_model_classes[1]
							lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__   ,					lowerCAmelCase__        =   self.model_tester.prepare_config_and_inputs()
							lowerCAmelCase__        =   True
							lowerCAmelCase__        =   True

							lowerCAmelCase__        =   model_class(snake_case__     )
							model.to(snake_case__     )
							model.train()

							lowerCAmelCase__        =   model(snake_case__  ,						mask_labels=snake_case__  ,						class_labels=snake_case__     )

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

							lowerCAmelCase__        =   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
							lowerCAmelCase__        =   outputs.transformer_decoder_hidden_states[0]
							transformer_decoder_hidden_states.retain_grad()

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

							outputs.loss.backward(retain_graph=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     )
__lowerCAmelCase    :							List[str]													=						1e-4







def 							_UpperCAmelCase		(       ):





		"""simple docstring"""




		lowerCAmelCase__        =   Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""     )
		return image






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




					@cached_property
					def 						_SCREAMING_SNAKE_CASE						(	self						:     int     ):
							return (
							    MaskFormerImageProcessor.from_pretrained("""facebook/maskformer-swin-small-coco"""     )
							    if is_vision_available()
							    else None
							)




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Optional[Any]     ):
							lowerCAmelCase__        =   MaskFormerModel.from_pretrained("""facebook/maskformer-swin-small-coco"""     ).to(snake_case__     )
							lowerCAmelCase__        =   self.default_image_processor
							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(snake_case__  ,						return_tensors="""pt"""     ).to(snake_case__     )
							lowerCAmelCase__        =   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(snake_case__  ,						(1, 3, 800, 1088)     )

							with torch.no_grad():
									lowerCAmelCase__        =   model(**snake_case__     )

							lowerCAmelCase__        =   torch.tensor(
							    [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]     ).to(snake_case__     )
							self.assertTrue(
							    torch.allclose(
							        outputs.encoder_last_hidden_state[0, 0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )

							lowerCAmelCase__        =   torch.tensor(
							    [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]     ).to(snake_case__     )
							self.assertTrue(
							    torch.allclose(
							        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )

							lowerCAmelCase__        =   torch.tensor(
							    [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]     ).to(snake_case__     )
							self.assertTrue(
							    torch.allclose(
							        outputs.transformer_decoder_last_hidden_state[0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Union[str, Any]     ):
							lowerCAmelCase__        =   (
							    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-swin-small-coco"""     )
							    .to(snake_case__     )
							    .eval()
							)
							lowerCAmelCase__        =   self.default_image_processor
							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(snake_case__  ,						return_tensors="""pt"""     ).to(snake_case__     )
							lowerCAmelCase__        =   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(snake_case__  ,						(1, 3, 800, 1088)     )

							with torch.no_grad():
									lowerCAmelCase__        =   model(**snake_case__     )
							# masks_queries_logits
							lowerCAmelCase__        =   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)  ,						)
							lowerCAmelCase__        =   [
							    [-1.373_7124, -1.772_4937, -1.936_4233],
							    [-1.597_7281, -1.986_7939, -2.152_3695],
							    [-1.579_5398, -1.926_9832, -2.09_3942],
							]
							lowerCAmelCase__        =   torch.tensor(snake_case__     ).to(snake_case__     )
							self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )
							# class_queries_logits
							lowerCAmelCase__        =   outputs.class_queries_logits
							self.assertEqual(
							    class_queries_logits.shape  ,						(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)     )
							lowerCAmelCase__        =   torch.tensor(
							    [
							        [1.6_512E00, -5.2_572E00, -3.3_519E00],
							        [3.6_169E-02, -5.9_025E00, -2.9_313E00],
							        [1.0_766E-04, -7.7_630E00, -5.1_263E00],
							    ]     ).to(snake_case__     )
							self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     Any     ):
							lowerCAmelCase__        =   (
							    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-resnet101-coco-stuff"""     )
							    .to(snake_case__     )
							    .eval()
							)
							lowerCAmelCase__        =   self.default_image_processor
							lowerCAmelCase__        =   prepare_img()
							lowerCAmelCase__        =   image_processor(snake_case__  ,						return_tensors="""pt"""     ).to(snake_case__     )
							lowerCAmelCase__        =   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(snake_case__  ,						(1, 3, 800, 1088)     )

							with torch.no_grad():
									lowerCAmelCase__        =   model(**snake_case__     )
							# masks_queries_logits
							lowerCAmelCase__        =   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)  ,						)
							lowerCAmelCase__        =   [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
							lowerCAmelCase__        =   torch.tensor(snake_case__     ).to(snake_case__     )
							self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )
							# class_queries_logits
							lowerCAmelCase__        =   outputs.class_queries_logits
							self.assertEqual(
							    class_queries_logits.shape  ,						(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)     )
							lowerCAmelCase__        =   torch.tensor(
							    [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]     ).to(snake_case__     )
							self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]  ,						snake_case__  ,						atol=snake_case__     )     )




					def 						_SCREAMING_SNAKE_CASE						(	self						:     List[Any]     ):
							lowerCAmelCase__        =   (
							    MaskFormerForInstanceSegmentation.from_pretrained("""facebook/maskformer-swin-small-coco"""     )
							    .to(snake_case__     )
							    .eval()
							)
							lowerCAmelCase__        =   self.default_image_processor

							lowerCAmelCase__        =   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"""  ,						)

							lowerCAmelCase__        =   inputs["""pixel_values"""].to(snake_case__     )
							lowerCAmelCase__        =   [el.to(snake_case__     ) for el in inputs["""mask_labels"""]]
							lowerCAmelCase__        =   [el.to(snake_case__     ) for el in inputs["""class_labels"""]]

							with torch.no_grad():
									lowerCAmelCase__        =   model(**snake_case__     )

							self.assertTrue(outputs.loss is not None     )





"""simple docstring"""




def 							_UpperCAmelCase		(       lowerCamelCase__     ):





		"""simple docstring"""




		assert isinstance(lowerCamelCase__			,  lowerCamelCase__     ), f"""The input value of [n={number}] is not an integer"""

		if number == 1:
				return 2
		elif number < 1:
				lowerCAmelCase__        =   f"""The input value of [n={number}] has to be > 0"""
				raise ValueError(lowerCamelCase__     )
		else:
				lowerCAmelCase__        =   sylvester(number - 1     )
				lowerCAmelCase__        =   num - 1
				lowerCAmelCase__        =   num
				return lower * upper + 1


if __name__ == "__main__":
			print(F"The 8th number in Sylvester's sequence: {sylvester(8)}")




