



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







					'''simple docstring'''







					def __init__(			self    ,	lowerCAmelCase    ,	lowerCAmelCase=2    ,	lowerCAmelCase=True    ,	lowerCAmelCase=False    ,	lowerCAmelCase=10    ,	lowerCAmelCase=3    ,	lowerCAmelCase=32 * 8    ,	lowerCAmelCase=32 * 8    ,	lowerCAmelCase=4    ,	lowerCAmelCase=64    ,	):
							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     ):
							UpperCAmelCase_						=				floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]     ).to(
							    lowerCAmelCase     )

							UpperCAmelCase_						=				torch.ones([self.batch_size, self.min_size, self.max_size]    ,	device=lowerCAmelCase     )

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

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



					def    A__		(			self     ):
							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     ):
							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    ,	lowerCAmelCase    ,	lowerCAmelCase     ):
							UpperCAmelCase_						=				output.encoder_hidden_states
							UpperCAmelCase_						=				output.pixel_decoder_hidden_states
							UpperCAmelCase_						=				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    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase=False     ):
							with torch.no_grad():
									UpperCAmelCase_						=				MaskaFormerModel(config=lowerCAmelCase     )
									model.to(lowerCAmelCase     )
									model.eval()

									UpperCAmelCase_						=				model(pixel_values=lowerCAmelCase    ,	pixel_mask=lowerCAmelCase     )
									UpperCAmelCase_						=				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    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase    ,	lowerCAmelCase     ):
							UpperCAmelCase_						=				MaskaFormerForUniversalSegmentation(config=lowerCAmelCase     )
							model.to(lowerCAmelCase     )
							model.eval()

							def comm_check_on_output(lowerCAmelCase     ):
									# 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=lowerCAmelCase    ,	pixel_mask=lowerCAmelCase     )
									UpperCAmelCase_						=				model(lowerCAmelCase     )

									comm_check_on_output(lowerCAmelCase     )

									UpperCAmelCase_						=				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 	lowerCamelCase      (						lowercase__,     lowercase__,     unittest.TestCase  ):







					'''simple docstring'''







					lowerCAmelCase_				:    Union[str, Any]									=  (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
					lowerCAmelCase_				:    str									=  {'feature-extraction': MaskaFormerModel} if is_torch_available() else {}

					lowerCAmelCase_				:    Optional[Any]									=  False
					lowerCAmelCase_				:    Dict									=  False
					lowerCAmelCase_				:    int									=  False
					lowerCAmelCase_				:    Optional[int]									=  False



					def    A__		(			self     ):
							UpperCAmelCase_						=				MaskaFormerModelTester(self     )
							UpperCAmelCase_						=				ConfigTester(self    ,	config_class=lowerCAmelCase    ,	has_text_modality=lowerCAmelCase     )



					def    A__		(			self     ):
							self.config_tester.run_common_tests()



					def    A__		(			self     ):
							UpperCAmelCase_					,						UpperCAmelCase_						=				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     ):
							UpperCAmelCase_						=				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     ):
							pass



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



					@unittest.skip(reason="Mask2Former is not a generative model"     )
					def    A__		(			self     ):
							pass



					@unittest.skip(reason="Mask2Former does not use token embeddings"     )
					def    A__		(			self     ):
							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     ):
							pass



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



					def    A__		(			self     ):
							UpperCAmelCase_					,						UpperCAmelCase_						=				self.model_tester.prepare_config_and_inputs_for_common()

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



					@slow
					def    A__		(			self     ):
							for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
									UpperCAmelCase_						=				MaskaFormerModel.from_pretrained(lowerCAmelCase     )
									self.assertIsNotNone(lowerCAmelCase     )



					def    A__		(			self     ):
							UpperCAmelCase_						=				(self.model_tester.min_size,) * 2
							UpperCAmelCase_						=				{
							    "pixel_values": torch.randn((2, 3, *size)    ,	device=lowerCAmelCase     ),
							    "mask_labels": torch.randn((2, 10, *size)    ,	device=lowerCAmelCase     ),
							    "class_labels": torch.zeros(2    ,	10    ,	device=lowerCAmelCase     ).long(),
							}
							UpperCAmelCase_						=				self.model_tester.get_config()

							UpperCAmelCase_						=				MaskaFormerForUniversalSegmentation(lowerCAmelCase     ).to(lowerCAmelCase     )
							UpperCAmelCase_						=				model(**lowerCAmelCase     )
							self.assertTrue(outputs.loss is not None     )



					def    A__		(			self     ):
							UpperCAmelCase_					,						UpperCAmelCase_						=				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     ):
							UpperCAmelCase_					,						UpperCAmelCase_						=				self.model_tester.prepare_config_and_inputs_for_common()

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



					def    A__		(			self     ):
							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(lowerCAmelCase     )
							model.to(lowerCAmelCase     )
							model.train()

							UpperCAmelCase_						=				model(lowerCAmelCase    ,	mask_labels=lowerCAmelCase    ,	class_labels=lowerCAmelCase     ).loss
							loss.backward()



					def    A__		(			self     ):
							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(lowerCAmelCase     ).to(lowerCAmelCase     )
							model.train()

							UpperCAmelCase_						=				model(lowerCAmelCase    ,	mask_labels=lowerCAmelCase    ,	class_labels=lowerCAmelCase     )

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





SCREAMING_SNAKE_CASE     				=						1e-4







def snake_case__  (			)		->							Union[str, Any]:
		UpperCAmelCase_						=				Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png" )
		return image



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







					'''simple docstring'''







					@cached_property
					def    A__		(			self     ):
							return "facebook/mask2former-swin-small-coco-instance"



					@cached_property
					def    A__		(			self     ):
							return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints     ) if is_vision_available() else None



					def    A__		(			self     ):
							UpperCAmelCase_						=				MaskaFormerModel.from_pretrained(self.model_checkpoints     ).to(lowerCAmelCase     )
							UpperCAmelCase_						=				self.default_image_processor
							UpperCAmelCase_						=				prepare_img()
							UpperCAmelCase_						=				image_processor(lowerCAmelCase    ,	return_tensors="pt"     ).to(lowerCAmelCase     )
							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(lowerCAmelCase    ,	(1, 3, 384, 384)     )

							with torch.no_grad():
									UpperCAmelCase_						=				model(**lowerCAmelCase     )

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

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

							UpperCAmelCase_						=				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     ):
							UpperCAmelCase_						=				MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints     ).to(lowerCAmelCase     ).eval()
							UpperCAmelCase_						=				self.default_image_processor
							UpperCAmelCase_						=				prepare_img()
							UpperCAmelCase_						=				image_processor(lowerCAmelCase    ,	return_tensors="pt"     ).to(lowerCAmelCase     )
							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(lowerCAmelCase    ,	(1, 3, 384, 384)     )

							with torch.no_grad():
									UpperCAmelCase_						=				model(**lowerCAmelCase     )
							# 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.7839, -9.0056, -8.8121],
							    [-7.4104, -7.0313, -6.5401],
							    [-6.6105, -6.3427, -6.4675],
							]
							UpperCAmelCase_						=				torch.tensor(lowerCAmelCase     ).to(lowerCAmelCase     )
							self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]    ,	lowerCAmelCase    ,	atol=lowerCAmelCase     )     )
							# 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.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     ):
							UpperCAmelCase_						=				MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints     ).to(lowerCAmelCase     ).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(lowerCAmelCase     )
							UpperCAmelCase_						=				[el.to(lowerCAmelCase     ) for el in inputs["mask_labels"]]
							UpperCAmelCase_						=				[el.to(lowerCAmelCase     ) for el in inputs["class_labels"]]

							with torch.no_grad():
									UpperCAmelCase_						=				model(**lowerCAmelCase     )

							self.assertTrue(outputs.loss is not None     )






def snake_case__  (			__SCREAMING_SNAKE_CASE )		->							int:
		UpperCAmelCase_						=				1
		for i in range(1			,     num + 1 ):
				fact *= i
		return fact







def snake_case__  (			__SCREAMING_SNAKE_CASE )		->							int:
		UpperCAmelCase_						=				0
		while number > 0:
				UpperCAmelCase_						=				number % 10
				sum_of_digits += last_digit
				UpperCAmelCase_						=				number // 10  # Removing the last_digit from the given number
		return sum_of_digits







def snake_case__  (			__SCREAMING_SNAKE_CASE = 100 )		->							int:
		UpperCAmelCase_						=				factorial(__SCREAMING_SNAKE_CASE )
		UpperCAmelCase_						=				split_and_add(__SCREAMING_SNAKE_CASE )
		return result


if __name__ == "__main__":
			print(solution(int(input("Enter the Number: ").strip())))

