



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'''

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







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase	:				str					  =       floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]).to(
														    lowercase_)

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

														_lowerCAmelCase	:				Union[str, Any]					  =       (
														    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size],     device=lowercase_) > 0.5
														).float()
														_lowerCAmelCase	:				Optional[int]					  =       (torch.rand((self.batch_size, self.num_labels),     device=lowercase_) > 0.5).long()

														_lowerCAmelCase	:				Tuple					  =       self.get_config()
														return config, pixel_values, pixel_mask, mask_labels, class_labels







							def   snake_case__ (  self):

														'''simple docstring'''

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

														_lowerCAmelCase	:				str					  =       [1, 1, 1, 1]
														_lowerCAmelCase	:				Dict					  =       self.num_channels

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







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase	:				str					  =       self.prepare_config_and_inputs()
														_lowerCAmelCase	:				Dict					  =       {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
														return config, inputs_dict







							def   snake_case__ (  self,     __a,     __a):

														'''simple docstring'''

														_lowerCAmelCase	:				Optional[int]					  =       output.encoder_hidden_states
														_lowerCAmelCase	:				Dict					  =       output.pixel_decoder_hidden_states
														_lowerCAmelCase	:				Tuple					  =       output.transformer_decoder_hidden_states

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







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

														'''simple docstring'''

														with torch.no_grad():
																					_lowerCAmelCase	:				Any					  =       MaskaFormerModel(config=lowercase_)
																					model.to(lowercase_)
																					model.eval()

																					_lowerCAmelCase	:				str					  =       model(pixel_values=lowercase_,     pixel_mask=lowercase_)
																					_lowerCAmelCase	:				Dict					  =       model(lowercase_,     output_hidden_states=lowercase_)

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







							def   snake_case__ (  self,     __a,     __a,     __a,     __a,     __a):

														'''simple docstring'''

														_lowerCAmelCase	:				List[Any]					  =       MaskaFormerForUniversalSegmentation(config=lowercase_)
														model.to(lowercase_)
														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():
																					_lowerCAmelCase	:				Tuple					  =       model(pixel_values=lowercase_,     pixel_mask=lowercase_)
																					_lowerCAmelCase	:				int					  =       model(lowercase_)

																					comm_check_on_output(lowercase_)

																					_lowerCAmelCase	:				Any					  =       model(
																					    pixel_values=lowercase_,     pixel_mask=lowercase_,     mask_labels=lowercase_,     class_labels=lowercase_)

														comm_check_on_output(lowercase_)

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



@require_torch
class     UpperCAmelCase_       (			__a  ,   __a  ,   unittest.TestCase):
							lowerCamelCase__       =						(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
							lowerCamelCase__       =						{'feature-extraction': MaskaFormerModel} if is_torch_available() else {}

							lowerCamelCase__       =						False
							lowerCamelCase__       =						False
							lowerCamelCase__       =						False
							lowerCamelCase__       =						False







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase	:				int					  =       MaskaFormerModelTester(self)
														_lowerCAmelCase	:				List[Any]					  =       ConfigTester(self,     config_class=lowercase_,     has_text_modality=lowercase_)







							def   snake_case__ (  self):

														'''simple docstring'''

														self.config_tester.run_common_tests()







							def   snake_case__ (  self):

														'''simple docstring'''

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







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase	:				Any					  =       self.model_tester.prepare_config_and_inputs()
														self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowercase_)







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

														'''simple docstring'''

														pass







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

														'''simple docstring'''

														pass







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

														'''simple docstring'''

														pass







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

														'''simple docstring'''

														pass







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

														'''simple docstring'''

														pass







							def   snake_case__ (  self):

														'''simple docstring'''

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

														for model_class in self.all_model_classes:
																					_lowerCAmelCase	:				Union[str, Any]					  =       model_class(lowercase_)
																					_lowerCAmelCase	:				Tuple					  =       inspect.signature(model.forward)
																					# signature.parameters is an OrderedDict => so arg_names order is deterministic
																					_lowerCAmelCase	:				List[str]					  =       [*signature.parameters.keys()]

																					_lowerCAmelCase	:				str					  =       ["pixel_values"]
																					self.assertListEqual(arg_names[:1],     lowercase_)







							@slow
							def   snake_case__ (  self):

														'''simple docstring'''

														for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
																					_lowerCAmelCase	:				List[str]					  =       MaskaFormerModel.from_pretrained(lowercase_)
																					self.assertIsNotNone(lowercase_)







							def   snake_case__ (  self):

														'''simple docstring'''

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

														_lowerCAmelCase	:				Any					  =       MaskaFormerForUniversalSegmentation(lowercase_).to(lowercase_)
														_lowerCAmelCase	:				int					  =       model(**lowercase_)
														self.assertTrue(outputs.loss is not None)







							def   snake_case__ (  self):

														'''simple docstring'''

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







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase  ,       _lowerCAmelCase	:				Optional[Any]					  =       self.model_tester.prepare_config_and_inputs_for_common()

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







							def   snake_case__ (  self):

														'''simple docstring'''

														if not self.model_tester.is_training:
																					return

														_lowerCAmelCase	:				Any					  =       self.all_model_classes[1]
														_lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase  ,       _lowerCAmelCase	:				Union[str, Any]					  =       self.model_tester.prepare_config_and_inputs()

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

														_lowerCAmelCase	:				Any					  =       model(lowercase_,     mask_labels=lowercase_,     class_labels=lowercase_).loss
														loss.backward()







							def   snake_case__ (  self):

														'''simple docstring'''

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

														_lowerCAmelCase	:				Tuple					  =       model_class(lowercase_).to(lowercase_)
														model.train()

														_lowerCAmelCase	:				Union[str, Any]					  =       model(lowercase_,     mask_labels=lowercase_,     class_labels=lowercase_)

														_lowerCAmelCase	:				Any					  =       outputs.encoder_hidden_states[0]
														encoder_hidden_states.retain_grad()

														_lowerCAmelCase	:				Optional[Any]					  =       outputs.pixel_decoder_hidden_states[0]
														pixel_decoder_hidden_states.retain_grad()

														_lowerCAmelCase	:				int					  =       outputs.transformer_decoder_hidden_states[0]
														transformer_decoder_hidden_states.retain_grad()

														_lowerCAmelCase	:				Dict					  =       outputs.attentions[0]
														attentions.retain_grad()

														outputs.loss.backward(retain_graph=lowercase_)

														self.assertIsNotNone(encoder_hidden_states.grad)
														self.assertIsNotNone(pixel_decoder_hidden_states.grad)
														self.assertIsNotNone(transformer_decoder_hidden_states.grad)
														self.assertIsNotNone(attentions.grad)



_snake_case						=    1e-4






def 							A							(   ):





							'''simple docstring'''




							_lowerCAmelCase	:				Optional[int]					  =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
							return image



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







							@cached_property
							def   snake_case__ (  self):

														'''simple docstring'''

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







							@cached_property
							def   snake_case__ (  self):

														'''simple docstring'''

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







							def   snake_case__ (  self):

														'''simple docstring'''

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

														with torch.no_grad():
																					_lowerCAmelCase	:				int					  =       model(**lowercase_)

														_lowerCAmelCase	:				List[str]					  =       torch.tensor(
														    [[-0.2_790, -1.0_717, -1.1_668], [-0.5_128, -0.3_128, -0.4_987], [-0.5_832, 0.1_971, -0.0_197]]).to(lowercase_)
														self.assertTrue(
														    torch.allclose(
														        outputs.encoder_last_hidden_state[0, 0, :3, :3],     lowercase_,     atol=lowercase_))

														_lowerCAmelCase	:				Optional[Any]					  =       torch.tensor(
														    [[0.8_973, 1.1_847, 1.1_776], [1.1_934, 1.5_040, 1.5_128], [1.1_153, 1.4_486, 1.4_951]]).to(lowercase_)
														self.assertTrue(
														    torch.allclose(
														        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3],     lowercase_,     atol=lowercase_))

														_lowerCAmelCase	:				Optional[int]					  =       torch.tensor(
														    [[2.1_152, 1.7_000, -0.8_603], [1.5_808, 1.8_004, -0.9_353], [1.6_043, 1.7_495, -0.5_999]]).to(lowercase_)
														self.assertTrue(
														    torch.allclose(
														        outputs.transformer_decoder_last_hidden_state[0, :3, :3],     lowercase_,     atol=lowercase_))







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase	:				Optional[Any]					  =       MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints).to(lowercase_).eval()
														_lowerCAmelCase	:				Tuple					  =       self.default_image_processor
														_lowerCAmelCase	:				str					  =       prepare_img()
														_lowerCAmelCase	:				Dict					  =       image_processor(lowercase_,     return_tensors="pt").to(lowercase_)
														_lowerCAmelCase	:				Optional[Any]					  =       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(lowercase_,     (1, 3, 384, 384))

														with torch.no_grad():
																					_lowerCAmelCase	:				str					  =       model(**lowercase_)
														# masks_queries_logits
														_lowerCAmelCase	:				Optional[int]					  =       outputs.masks_queries_logits
														self.assertEqual(
														    masks_queries_logits.shape,     (1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4))
														_lowerCAmelCase	:				Dict					  =       [
														    [-8.7_839, -9.0_056, -8.8_121],
														    [-7.4_104, -7.0_313, -6.5_401],
														    [-6.6_105, -6.3_427, -6.4_675],
														]
														_lowerCAmelCase	:				Dict					  =       torch.tensor(lowercase_).to(lowercase_)
														self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3],     lowercase_,     atol=lowercase_))
														# class_queries_logits
														_lowerCAmelCase	:				Tuple					  =       outputs.class_queries_logits
														self.assertEqual(class_queries_logits.shape,     (1, model.config.num_queries, model.config.num_labels + 1))
														_lowerCAmelCase	:				List[str]					  =       torch.tensor(
														    [
														        [1.8_324, -8.0_835, -4.1_922],
														        [0.8_450, -9.0_050, -3.6_053],
														        [0.3_045, -7.7_293, -3.0_275],
														    ]).to(lowercase_)
														self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3],     lowercase_,     atol=lowercase_))







							def   snake_case__ (  self):

														'''simple docstring'''

														_lowerCAmelCase	:				int					  =       MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints).to(lowercase_).eval()
														_lowerCAmelCase	:				str					  =       self.default_image_processor

														_lowerCAmelCase	:				Optional[Any]					  =       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	:				List[str]					  =       inputs["pixel_values"].to(lowercase_)
														_lowerCAmelCase	:				List[str]					  =       [el.to(lowercase_) for el in inputs["mask_labels"]]
														_lowerCAmelCase	:				Any					  =       [el.to(lowercase_) for el in inputs["class_labels"]]

														with torch.no_grad():
																					_lowerCAmelCase	:				Tuple					  =       model(**lowercase_)

														self.assertTrue(outputs.loss is not None)

'''simple docstring'''


import math

def   A_      (       SCREAMING_SNAKE_CASE_						)			->int:

  if not isinstance(SCREAMING_SNAKE_CASE_ ,	SCREAMING_SNAKE_CASE_						):
    lowercase_     =       f"""Input value of [number={number}] must be an integer"""
    raise TypeError(SCREAMING_SNAKE_CASE_						)

  if number < 1:
    lowercase_     =       f"""Input value of [number={number}] must be > 0"""
    raise ValueError(SCREAMING_SNAKE_CASE_						)
  elif number == 1:
    return 3
  elif number == 2:
    return 5
  else:
    lowercase_     =       int(math.log(number // 3 ,	2						)						) + 2

    lowercase_     =       [3, 5]
    lowercase_     =       2
    lowercase_     =       3
    for block in range(1 ,	SCREAMING_SNAKE_CASE_						):
      for _ in range(SCREAMING_SNAKE_CASE_						):
        proth_list.append(2 ** (block + 1) + proth_list[proth_index - 1]						)
        proth_index += 1
      increment *= 2

  return proth_list[number - 1]


if __name__ == "__main__":
       import doctest

       doctest.testmod()

       for number in range(11):
              __snake_case						  =		0
              try:
                     __snake_case						  =		proth(number)
              except ValueError:
                     print(f'''ValueError: there is no {number}th Proth number''')
                     continue

              print(f'''The {number}th Proth number: {value}''')

