





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				,     snake_case_				,     snake_case_=2				,     snake_case_=True				,     snake_case_=False				,     snake_case_=10				,     snake_case_=3				,     snake_case_=32 * 8				,     snake_case_=32 * 8				,     snake_case_=4				,     snake_case_=64				,     ):
         _A     =							parent
         _A     =							batch_size
         _A     =							is_training
         _A     =							use_auxiliary_loss
         _A     =							num_queries
         _A     =							num_channels
         _A     =							min_size
         _A     =							max_size
         _A     =							num_labels
         _A     =							hidden_dim
         _A     =							hidden_dim




     def        lowerCAmelCase__		(    self							):
         _A     =							floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]							).to(
             snake_case_							)

         _A     =							torch.ones([self.batch_size, self.min_size, self.max_size]				,     device=snake_case_							)

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

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




     def        lowerCAmelCase__		(    self							):
         _A     =							MaskaFormerConfig(
             hidden_size=self.hidden_dim				,     )
         _A     =							self.num_queries
         _A     =							self.num_labels

         _A     =							[1, 1, 1, 1]
         _A     =							self.num_channels

         _A     =							64
         _A     =							128
         _A     =							self.hidden_dim
         _A     =							self.hidden_dim
         _A     =							self.hidden_dim
         return config




     def        lowerCAmelCase__		(    self							):
         _A,			_A,			_A,			_A,			_A     =							self.prepare_config_and_inputs()
         _A     =							{'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
         return config, inputs_dict




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_							):
         _A     =							output.encoder_hidden_states
         _A     =							output.pixel_decoder_hidden_states
         _A     =							output.transformer_decoder_hidden_states

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




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_=False							):
         with torch.no_grad():
             _A     =							MaskaFormerModel(config=snake_case_							)
             model.to(snake_case_							)
             model.eval()

             _A     =							model(pixel_values=snake_case_				,     pixel_mask=snake_case_							)
             _A     =							model(snake_case_				,     output_hidden_states=snake_case_							)

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




     def        lowerCAmelCase__		(    self				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_				,     snake_case_							):
         _A     =							MaskaFormerForUniversalSegmentation(config=snake_case_							)
         model.to(snake_case_							)
         model.eval()

         def comm_check_on_output(snake_case_							):
             # 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     =							model(pixel_values=snake_case_				,     pixel_mask=snake_case_							)
             _A     =							model(snake_case_							)

             comm_check_on_output(snake_case_							)

             _A     =							model(
                 pixel_values=snake_case_				,     pixel_mask=snake_case_				,     mask_labels=snake_case_				,     class_labels=snake_case_							)

         comm_check_on_output(snake_case_							)

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







@require_torch
class      lowerCamelCase(						__snake_case			, __snake_case			, unittest.TestCase	):
     '''simple docstring'''


     __magic_name__   =			(MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
     __magic_name__   =			{'feature-extraction': MaskaFormerModel} if is_torch_available() else {}

     __magic_name__   =			False
     __magic_name__   =			False
     __magic_name__   =			False
     __magic_name__   =			False




     def        lowerCAmelCase__		(    self							):
         _A     =							MaskaFormerModelTester(self							)
         _A     =							ConfigTester(self				,     config_class=snake_case_				,     has_text_modality=snake_case_							)




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




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskaformer_model(snake_case_				,     **snake_case_				,     output_hidden_states=snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A     =							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*snake_case_							)




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




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




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




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




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




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()

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

             _A     =							['pixel_values']
             self.assertListEqual(arg_names[:1]				,     snake_case_							)




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




     def        lowerCAmelCase__		(    self							):
         _A     =							(self.model_tester.min_size,) * 2
         _A     =							{
             'pixel_values': torch.randn((2, 3, *size)				,     device=snake_case_							),
             'mask_labels': torch.randn((2, 10, *size)				,     device=snake_case_							),
             'class_labels': torch.zeros(2				,     10				,     device=snake_case_							).long(),
         }
         _A     =							self.model_tester.get_config()

         _A     =							MaskaFormerForUniversalSegmentation(snake_case_							).to(snake_case_							)
         _A     =							model(**snake_case_							)
         self.assertTrue(outputs.loss is not None							)




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskaformer_model(snake_case_				,     **snake_case_				,     output_hidden_states=snake_case_							)




     def        lowerCAmelCase__		(    self							):
         _A,			_A     =							self.model_tester.prepare_config_and_inputs_for_common()

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




     def        lowerCAmelCase__		(    self							):
         if not self.model_tester.is_training:
             return

         _A     =							self.all_model_classes[1]
         _A,			_A,			_A,			_A,			_A     =							self.model_tester.prepare_config_and_inputs()

         _A     =							model_class(snake_case_							)
         model.to(snake_case_							)
         model.train()

         _A     =							model(snake_case_				,     mask_labels=snake_case_				,     class_labels=snake_case_							).loss
         loss.backward()




     def        lowerCAmelCase__		(    self							):
         _A     =							self.all_model_classes[1]
         _A,			_A,			_A,			_A,			_A     =							self.model_tester.prepare_config_and_inputs()
         _A     =							True
         _A     =							True

         _A     =							model_class(snake_case_							).to(snake_case_							)
         model.train()

         _A     =							model(snake_case_				,     mask_labels=snake_case_				,     class_labels=snake_case_							)

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

         _A     =							outputs.pixel_decoder_hidden_states[0]
         pixel_decoder_hidden_states.retain_grad()

         _A     =							outputs.transformer_decoder_hidden_states[0]
         transformer_decoder_hidden_states.retain_grad()

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

         outputs.loss.backward(retain_graph=snake_case_							)

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




__A							:			Optional[Any]         =			1E-4





def 				__lowerCAmelCase(       )							-> Tuple:




    """simple docstring"""




    _A     =							Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'				)
    return image







@require_vision
@slow
class      lowerCamelCase(						unittest.TestCase	):
     '''simple docstring'''


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




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




     def        lowerCAmelCase__		(    self							):
         _A     =							MaskaFormerModel.from_pretrained(self.model_checkpoints							).to(snake_case_							)
         _A     =							self.default_image_processor
         _A     =							prepare_img()
         _A     =							image_processor(snake_case_				,     return_tensors='pt'							).to(snake_case_							)
         _A     =							inputs['pixel_values'].shape
         # check size is divisible by 32
         self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0							)
         # check size
         self.assertEqual(snake_case_				,     (1, 3, 384, 384)							)

         with torch.no_grad():
             _A     =							model(**snake_case_							)

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

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

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




     def        lowerCAmelCase__		(    self							):
         _A     =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(snake_case_							).eval()
         _A     =							self.default_image_processor
         _A     =							prepare_img()
         _A     =							image_processor(snake_case_				,     return_tensors='pt'							).to(snake_case_							)
         _A     =							inputs['pixel_values'].shape
         # check size is divisible by 32
         self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0							)
         # check size
         self.assertEqual(snake_case_				,     (1, 3, 384, 384)							)

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




     def        lowerCAmelCase__		(    self							):
         _A     =							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints							).to(snake_case_							).eval()
         _A     =							self.default_image_processor

         _A     =							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     =							inputs['pixel_values'].to(snake_case_							)
         _A     =							[el.to(snake_case_							) for el in inputs['mask_labels']]
         _A     =							[el.to(snake_case_							) for el in inputs['class_labels']]

         with torch.no_grad():
             _A     =							model(**snake_case_							)

         self.assertTrue(outputs.loss is not None							)











'''simple docstring'''



def   lowercase__(			__UpperCamelCase:					int    ):

      """simple docstring"""






      if not isinstance(__UpperCamelCase      ,__UpperCamelCase    ):
            raise TypeError('Input value must be an \'int\' type'    )

      SCREAMING_SNAKE_CASE   :      int    					=						0
      while number:
            position += 1
            number >>= 1

      return position


if __name__ == "__main__":
      import doctest

      doctest.testmod()


