




'''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[str]       ,		__lowerCAmelCase     :  str       ,		__lowerCAmelCase     :  List[Any]=2       ,		__lowerCAmelCase     :  List[Any]=True       ,		__lowerCAmelCase     :  str=False       ,		__lowerCAmelCase     :  List[Any]=1_0       ,		__lowerCAmelCase     :  int=3       ,		__lowerCAmelCase     :  List[Any]=3_2 * 4       ,		__lowerCAmelCase     :  Union[str, Any]=3_2 * 6       ,		__lowerCAmelCase     :  int=4       ,		__lowerCAmelCase     :  Optional[int]=3_2       ,		):
							__snake_case						 =   parent
							__snake_case						 =   batch_size
							__snake_case						 =   is_training
							__snake_case						 =   use_auxiliary_loss
							__snake_case						 =   num_queries
							__snake_case						 =   num_channels
							__snake_case						 =   min_size
							__snake_case						 =   max_size
							__snake_case						 =   num_labels
							__snake_case						 =   mask_feature_size




	def   lowercase__   (       self     :  str      ):
							__snake_case						 =   floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]      ).to(
							    __lowerCAmelCase      )

							__snake_case						 =   torch.ones([self.batch_size, self.min_size, self.max_size]       ,		device=__lowerCAmelCase      )

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

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




	def   lowercase__   (       self     :  Dict      ):
							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   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case ,       __snake_case ,       __snake_case ,       __snake_case ,       __snake_case						 =   self.prepare_config_and_inputs()
							__snake_case						 =   {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
							return config, inputs_dict




	def   lowercase__   (       self     :  Tuple       ,		__lowerCAmelCase     :  Dict       ,		__lowerCAmelCase     :  Any      ):
							__snake_case						 =   output.encoder_hidden_states
							__snake_case						 =   output.pixel_decoder_hidden_states
							__snake_case						 =   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_config.decoder_layers      )




	def   lowercase__   (       self     :  Any       ,		__lowerCAmelCase     :  Union[str, Any]       ,		__lowerCAmelCase     :  List[str]       ,		__lowerCAmelCase     :  Any       ,		__lowerCAmelCase     :  Dict=False      ):
							with torch.no_grad():
													__snake_case						 =   MaskFormerModel(config=__lowerCAmelCase      )
													model.to(__lowerCAmelCase      )
													model.eval()

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




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

							def comm_check_on_output(__lowerCAmelCase     :  Tuple      ):
													# 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():
													__snake_case						 =   model(pixel_values=__lowerCAmelCase       ,		pixel_mask=__lowerCAmelCase      )
													__snake_case						 =   model(__lowerCAmelCase      )

													comm_check_on_output(__lowerCAmelCase      )

													__snake_case						 =   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 						a_				(			UpperCAmelCase__     ,						UpperCAmelCase__     ,						unittest.TestCase						):
	lowercase_       :     int			  =      (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
	lowercase_       :     Any			  =      (
	    {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
	    if is_torch_available()
	    else {}
	)

	lowercase_       :     List[str]			  =      False
	lowercase_       :     str			  =      False
	lowercase_       :     List[Any]			  =      False
	lowercase_       :     Union[str, Any]			  =      False




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case						 =   MaskFormerModelTester(self      )
							__snake_case						 =   ConfigTester(self       ,		config_class=__lowerCAmelCase       ,		has_text_modality=__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[Any]      ):
							self.config_tester.run_common_tests()




	def   lowercase__   (       self     :  Optional[Any]      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase       ,		**__lowerCAmelCase       ,		output_hidden_states=__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case						 =   self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*__lowerCAmelCase      )




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




	@unittest.skip(reason='MaskFormer does not have a get_input_embeddings method'      )
	def   lowercase__   (       self     :  Optional[int]      ):
							pass




	@unittest.skip(reason='MaskFormer is not a generative model'      )
	def   lowercase__   (       self     :  Dict      ):
							pass




	@unittest.skip(reason='MaskFormer does not use token embeddings'      )
	def   lowercase__   (       self     :  str      ):
							pass




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




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




	def   lowercase__   (       self     :  List[Any]      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

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

													__snake_case						 =   ['pixel_values']
													self.assertListEqual(arg_names[:1]       ,		__lowerCAmelCase      )




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




	def   lowercase__   (       self     :  Union[str, Any]      ):
							__snake_case						 =   (self.model_tester.min_size,) * 2
							__snake_case						 =   {
							    '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(),
							}

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




	def   lowercase__   (       self     :  Tuple      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskformer_model(__lowerCAmelCase       ,		**__lowerCAmelCase       ,		output_hidden_states=__lowerCAmelCase      )




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs_for_common()

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




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

							__snake_case						 =   model_class(__lowerCAmelCase      )
							model.to(__lowerCAmelCase      )
							model.train()

							__snake_case						 =   model(__lowerCAmelCase       ,		mask_labels=__lowerCAmelCase       ,		class_labels=__lowerCAmelCase      ).loss
							loss.backward()




	def   lowercase__   (       self     :  Optional[Any]      ):
							# only MaskFormerForInstanceSegmentation has the loss
							__snake_case						 =   self.all_model_classes[1]
							__snake_case ,       __snake_case ,       __snake_case ,       __snake_case ,       __snake_case						 =   self.model_tester.prepare_config_and_inputs()
							__snake_case						 =   True
							__snake_case						 =   True

							__snake_case						 =   model_class(__lowerCAmelCase      )
							model.to(__lowerCAmelCase      )
							model.train()

							__snake_case						 =   model(__lowerCAmelCase       ,		mask_labels=__lowerCAmelCase       ,		class_labels=__lowerCAmelCase      )

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

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

							__snake_case						 =   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      )





_lowercase  =			1e-4
def 						lowerCamelCase__   (				):
						__snake_case						 =   Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'							)
						return image






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




	@cached_property
	def   lowercase__   (       self     :  Dict      ):
							return (
							    MaskFormerImageProcessor.from_pretrained('facebook/maskformer-swin-small-coco'      )
							    if is_vision_available()
							    else None
							)




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

							with torch.no_grad():
													__snake_case						 =   model(**__lowerCAmelCase      )

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

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

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




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

							with torch.no_grad():
													__snake_case						 =   model(**__lowerCAmelCase      )
							# masks_queries_logits
							__snake_case						 =   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)       ,		)
							__snake_case						 =   [
							    [-1.3737124, -1.7724937, -1.9364233],
							    [-1.5977281, -1.9867939, -2.1523695],
							    [-1.5795398, -1.9269832, -2.093942],
							]
							__snake_case						 =   torch.tensor(__lowerCAmelCase      ).to(__lowerCAmelCase      )
							self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]       ,		__lowerCAmelCase       ,		atol=__lowerCAmelCase      )      )
							# class_queries_logits
							__snake_case						 =   outputs.class_queries_logits
							self.assertEqual(
							    class_queries_logits.shape       ,		(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)      )
							__snake_case						 =   torch.tensor(
							    [
							        [1.65_12E00, -5.25_72E00, -3.35_19E00],
							        [3.61_69E-02, -5.90_25E00, -2.93_13E00],
							        [1.07_66E-04, -7.76_30E00, -5.12_63E00],
							    ]      ).to(__lowerCAmelCase      )
							self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]       ,		__lowerCAmelCase       ,		atol=__lowerCAmelCase      )      )




	def   lowercase__   (       self     :  Optional[int]      ):
							__snake_case						 =   (
							    MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-resnet101-coco-stuff'      )
							    .to(__lowerCAmelCase      )
							    .eval()
							)
							__snake_case						 =   self.default_image_processor
							__snake_case						 =   prepare_img()
							__snake_case						 =   image_processor(__lowerCAmelCase       ,		return_tensors='pt'      ).to(__lowerCAmelCase      )
							__snake_case						 =   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, 8_0_0, 1_0_8_8)      )

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




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

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

							__snake_case						 =   inputs['pixel_values'].to(__lowerCAmelCase      )
							__snake_case						 =   [el.to(__lowerCAmelCase      ) for el in inputs['mask_labels']]
							__snake_case						 =   [el.to(__lowerCAmelCase      ) for el in inputs['class_labels']]

							with torch.no_grad():
													__snake_case						 =   model(**__lowerCAmelCase      )

							self.assertTrue(outputs.loss is not None      )







'''simple docstring'''


def 						lowerCamelCase__   (				a							):
						__snake_case						 =   int(a							)
						if n_element < 1:
												__snake_case						 =   ValueError('a should be a positive number'							)
												raise my_error

						__snake_case						 =   [1]
						__snake_case ,       __snake_case ,       __snake_case						 =   (0, 0, 0)
						__snake_case						 =   1
						while index < n_element:
												while hamming_list[i] * 2 <= hamming_list[-1]:
																		i += 1
												while hamming_list[j] * 3 <= hamming_list[-1]:
																		j += 1
												while hamming_list[k] * 5 <= hamming_list[-1]:
																		k += 1
												hamming_list.append(
												    min(hamming_list[i] * 2    ,	hamming_list[j] * 3    ,	hamming_list[k] * 5							)							)
												index += 1
						return hamming_list


if __name__ == "__main__":
	_lowercase  =			input("""Enter the last number (nth term) of the Hamming Number Series: """)
	print("""Formula of Hamming Number Series => 2^i * 3^j * 5^k""")
	_lowercase  =			hamming(int(n))
	print("""-----------------------------------------------------""")
	print(f'''The list with nth numbers is: {hamming_numbers}''')
	print("""-----------------------------------------------------""")

