


'''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						,				__a						,				__a=2						,				__a=True						,				__a=False						,				__a=10						,				__a=3						,				__a=32 * 8						,				__a=32 * 8						,				__a=4						,				__a=64						,				):

						'''simple docstring'''





						__a			:       Any					    =  parent
						__a			:       Any					    =  batch_size
						__a			:       Tuple					    =  is_training
						__a			:       Optional[int]					    =  use_auxiliary_loss
						__a			:       List[Any]					    =  num_queries
						__a			:       Any					    =  num_channels
						__a			:       str					    =  min_size
						__a			:       str					    =  max_size
						__a			:       Any					    =  num_labels
						__a			:       Union[str, Any]					    =  hidden_dim
						__a			:       Optional[Any]					    =  hidden_dim




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Tuple					    =  floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]							).to(
						    __a							)

						__a			:       str					    =  torch.ones([self.batch_size, self.min_size, self.max_size]						,				device=__a							)

						__a			:       Optional[int]					    =  (
						    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]						,				device=__a							) > 0.5
						).float()
						__a			:       Tuple					    =  (torch.rand((self.batch_size, self.num_labels)						,				device=__a							) > 0.5).long()

						__a			:       Union[str, Any]					    =  self.get_config()
						return config, pixel_values, pixel_mask, mask_labels, class_labels




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Optional[Any]					    =  MaskaFormerConfig(
						    hidden_size=self.hidden_dim						,				)
						__a			:       Dict					    =  self.num_queries
						__a			:       List[str]					    =  self.num_labels

						__a			:       List[str]					    =  [1, 1, 1, 1]
						__a			:       Any					    =  self.num_channels

						__a			:       int					    =  64
						__a			:       Optional[int]					    =  128
						__a			:       str					    =  self.hidden_dim
						__a			:       int					    =  self.hidden_dim
						__a			:       List[Any]					    =  self.hidden_dim
						return config




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a    ,				__a    ,				__a    ,				__a			:       int					    =  self.prepare_config_and_inputs()
						__a			:       List[Any]					    =  {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
						return config, inputs_dict




	def       __UpperCAmelCase							(   self						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Tuple					    =  output.encoder_hidden_states
						__a			:       Dict					    =  output.pixel_decoder_hidden_states
						__a			:       str					    =  output.transformer_decoder_hidden_states

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




	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a=False							):

						'''simple docstring'''





						with torch.no_grad():
											__a			:       List[str]					    =  MaskaFormerModel(config=__a							)
											model.to(__a							)
											model.eval()

											__a			:       List[str]					    =  model(pixel_values=__a						,				pixel_mask=__a							)
											__a			:       Optional[int]					    =  model(__a						,				output_hidden_states=__a							)

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





	def       __UpperCAmelCase							(   self						,				__a						,				__a						,				__a						,				__a						,				__a							):

						'''simple docstring'''





						__a			:       Optional[int]					    =  MaskaFormerForUniversalSegmentation(config=__a							)
						model.to(__a							)
						model.eval()

						def comm_check_on_output(__a							):
											# 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			:       Union[str, Any]					    =  model(pixel_values=__a						,				pixel_mask=__a							)
											__a			:       Optional[Any]					    =  model(__a							)

											comm_check_on_output(__a							)

											__a			:       Dict					    =  model(
											    pixel_values=__a						,				pixel_mask=__a						,				mask_labels=__a						,				class_labels=__a							)

						comm_check_on_output(__a							)

						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					):
	A_				=    (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
	A_				=    {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

	A_				=    False
	A_				=    False
	A_				=    False
	A_				=    False




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Optional[int]					    =  MaskaFormerModelTester(self							)
						__a			:       str					    =  ConfigTester(self						,				config_class=__a						,				has_text_modality=__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						self.config_tester.run_common_tests()




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       List[Any]					    =  self.model_tester.prepare_config_and_inputs_for_common()
						self.model_tester.create_and_check_maskaformer_model(__a						,				**__a						,				output_hidden_states=__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Union[str, Any]					    =  self.model_tester.prepare_config_and_inputs()
						self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*__a							)




	@unittest.skip(reason='Mask2Former does not use inputs_embeds'							)
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass




	@unittest.skip(reason='Mask2Former does not have a get_input_embeddings method'							)
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass




	@unittest.skip(reason='Mask2Former is not a generative model'							)
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass




	@unittest.skip(reason='Mask2Former does not use token embeddings'							)
	def       __UpperCAmelCase							(   self							):

						'''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       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						pass




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

						'''simple docstring'''





						pass




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       str					    =  self.model_tester.prepare_config_and_inputs_for_common()

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

											__a			:       int					    =  ['pixel_values']
											self.assertListEqual(arg_names[:1]						,				__a							)




	@slow
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
											__a			:       Optional[Any]					    =  MaskaFormerModel.from_pretrained(__a							)
											self.assertIsNotNone(__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       List[Any]					    =  (self.model_tester.min_size,) * 2
						__a			:       Optional[int]					    =  {
						    'pixel_values': torch.randn((2, 3, *size)						,				device=__a							),
						    'mask_labels': torch.randn((2, 10, *size)						,				device=__a							),
						    'class_labels': torch.zeros(2						,				10						,				device=__a							).long(),
						}
						__a			:       Dict					    =  self.model_tester.get_config()

						__a			:       List[Any]					    =  MaskaFormerForUniversalSegmentation(__a							).to(__a							)
						__a			:       List[str]					    =  model(**__a							)
						self.assertTrue(outputs.loss is not None							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       Tuple					    =  self.model_tester.prepare_config_and_inputs_for_common()
						self.model_tester.create_and_check_maskaformer_model(__a						,				**__a						,				output_hidden_states=__a							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a    ,				__a			:       str					    =  self.model_tester.prepare_config_and_inputs_for_common()

						for model_class in self.all_model_classes:
											__a			:       Optional[int]					    =  model_class(__a							).to(__a							)
											__a			:       List[str]					    =  model(**__a						,				output_attentions=__a							)
											self.assertTrue(outputs.attentions is not None							)




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						if not self.model_tester.is_training:
											return

						__a			:       List[str]					    =  self.all_model_classes[1]
						__a    ,				__a    ,				__a    ,				__a    ,				__a			:       List[Any]					    =  self.model_tester.prepare_config_and_inputs()

						__a			:       List[str]					    =  model_class(__a							)
						model.to(__a							)
						model.train()

						__a			:       Union[str, Any]					    =  model(__a						,				mask_labels=__a						,				class_labels=__a							).loss
						loss.backward()





	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Dict					    =  self.all_model_classes[1]
						__a    ,				__a    ,				__a    ,				__a    ,				__a			:       List[Any]					    =  self.model_tester.prepare_config_and_inputs()
						__a			:       List[Any]					    =  True
						__a			:       Optional[int]					    =  True

						__a			:       Optional[int]					    =  model_class(__a							).to(__a							)
						model.train()

						__a			:       Optional[int]					    =  model(__a						,				mask_labels=__a						,				class_labels=__a							)

						__a			:       Dict					    =  outputs.encoder_hidden_states[0]
						encoder_hidden_states.retain_grad()

						__a			:       List[str]					    =  outputs.pixel_decoder_hidden_states[0]
						pixel_decoder_hidden_states.retain_grad()

						__a			:       Dict					    =  outputs.transformer_decoder_hidden_states[0]
						transformer_decoder_hidden_states.retain_grad()

						__a			:       Union[str, Any]					    =  outputs.attentions[0]
						attentions.retain_grad()

						outputs.loss.backward(retain_graph=__a							)

						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	:						Any       =	1E-4






def   lowerCamelCase							():
					__a			:       Optional[int]					    =  Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
					return image





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




	@cached_property
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						return "facebook/mask2former-swin-small-coco-instance"




	@cached_property
	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





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




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Optional[Any]					    =  MaskaFormerModel.from_pretrained(self.model_checkpoints							).to(__a							)
						__a			:       List[Any]					    =  self.default_image_processor
						__a			:       Dict					    =  prepare_img()
						__a			:       Union[str, Any]					    =  image_processor(__a						,				return_tensors='pt'							).to(__a							)
						__a			:       int					    =  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(__a						,				(1, 3, 384, 384)							)

						with torch.no_grad():
											__a			:       List[str]					    =  model(**__a							)

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

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

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




	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Optional[int]					    =  MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(__a							).eval()
						__a			:       List[Any]					    =  self.default_image_processor
						__a			:       Optional[Any]					    =  prepare_img()
						__a			:       Optional[int]					    =  image_processor(__a						,				return_tensors='pt'							).to(__a							)
						__a			:       Optional[int]					    =  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(__a						,				(1, 3, 384, 384)							)

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





	def       __UpperCAmelCase							(   self							):

						'''simple docstring'''





						__a			:       Any					    =  MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(__a							).eval()
						__a			:       Optional[int]					    =  self.default_image_processor

						__a			:       Tuple					    =  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'						,				)

						__a			:       Any					    =  inputs['pixel_values'].to(__a							)
						__a			:       int					    =  [el.to(__a							) for el in inputs['mask_labels']]
						__a			:       List[Any]					    =  [el.to(__a							) for el in inputs['class_labels']]

						with torch.no_grad():
											__a			:       Union[str, Any]					    =  model(**__a							)

						self.assertTrue(outputs.loss is not None							)







'''simple docstring'''



from __future__ import annotations

from fractions import Fraction
from math import gcd, sqrt






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int   ):
					__a			:       int					    =  int(number**0.5   )
					return number == sq * sq






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int						,      _SCREAMING_SNAKE_CASE      :   int   ):
					__a			:       int					    =  x_num * y_den * z_den + y_num * x_den * z_den + z_num * x_den * y_den
					__a			:       int					    =  x_den * y_den * z_den
					__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
					top //= hcf
					bottom //= hcf
					return top, bottom






def   lowerCamelCase							(_SCREAMING_SNAKE_CASE      :   int = 35   ):
					__a			:       set					    =  set()
					__a			:       int
					__a			:       Fraction					    =  Fraction(0   )
					__a			:       tuple[int, int]

					for x_num in range(1						,      order + 1   ):
										for x_den in range(x_num + 1						,      order + 1   ):
															for y_num in range(1						,      order + 1   ):
																				for y_den in range(y_num + 1						,      order + 1   ):
																									# n=1
																									__a			:       Union[str, Any]					    =  x_num * y_den + x_den * y_num
																									__a			:       Optional[Any]					    =  x_den * y_den
																									__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														__a			:       Any					    =  add_three(
																														    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														unique_s.add(_SCREAMING_SNAKE_CASE   )

																									# n=2
																									__a			:       Optional[int]					    =  (
																									    x_num * x_num * y_den * y_den + x_den * x_den * y_num * y_num
																									)
																									__a			:       Union[str, Any]					    =  x_den * x_den * y_den * y_den
																									if is_sq(_SCREAMING_SNAKE_CASE   ) and is_sq(_SCREAMING_SNAKE_CASE   ):
																														__a			:       List[Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Any					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Optional[int]					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			__a			:       List[Any]					    =  add_three(
																																			    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																																			unique_s.add(_SCREAMING_SNAKE_CASE   )

                    # n=-1
																									__a			:       int					    =  x_num * y_num
																									__a			:       Optional[Any]					    =  x_den * y_num + x_num * y_den
																									__a			:       Tuple					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																									z_num //= hcf
																									z_den //= hcf
																									if 0 < z_num < z_den <= order:
																														__a			:       Any					    =  add_three(
																														    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														unique_s.add(_SCREAMING_SNAKE_CASE   )

																									# n=2
																									__a			:       List[Any]					    =  x_num * x_num * y_num * y_num
																									__a			:       List[Any]					    =  (
																									    x_den * x_den * y_num * y_num + x_num * x_num * y_den * y_den
																									)
																									if is_sq(_SCREAMING_SNAKE_CASE   ) and is_sq(_SCREAMING_SNAKE_CASE   ):
																														__a			:       Optional[Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       Union[str, Any]					    =  int(sqrt(_SCREAMING_SNAKE_CASE   )   )
																														__a			:       int					    =  gcd(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																														z_num //= hcf
																														z_den //= hcf
																														if 0 < z_num < z_den <= order:
																																			__a			:       List[str]					    =  add_three(
																																			    _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )
																																			unique_s.add(_SCREAMING_SNAKE_CASE   )

					for num, den in unique_s:
										total += Fraction(_SCREAMING_SNAKE_CASE						,      _SCREAMING_SNAKE_CASE   )

					return total.denominator + total.numerator


if __name__ == "__main__":
	print(f'''{solution() = }''')



