



"""simple docstring"""





import unittest

from transformers import BarthezTokenizer, BarthezTokenizerFast, BatchEncoding
from transformers.testing_utils import require_sentencepiece, require_tokenizers, require_torch, slow

from ...test_tokenization_common import TokenizerTesterMixin
@require_tokenizers
@require_sentencepiece
@slow  # see https://github.com/huggingface/transformers/issues/11457
class 				lowercase__       (   SCREAMING_SNAKE_CASE    , unittest.TestCase				):







       '''simple docstring'''


       UpperCamelCase						=					BarthezTokenizer
       UpperCamelCase						=					BarthezTokenizerFast
       UpperCamelCase						=					True
       UpperCamelCase						=					True



       def 					lowercase__    (							self      :  Tuple   )			->						int:


             '''simple docstring'''




             super().setUp()

             UpperCAmelCase_      			=							BarthezTokenizerFast.from_pretrained("moussaKam/mbarthez"   )
             tokenizer.save_pretrained(self.tmpdirname   )
             tokenizer.save_pretrained(self.tmpdirname		,    legacy_format=_UpperCAmelCase   )
             UpperCAmelCase_      			=							tokenizer



       def 					lowercase__    (							self      :  Any   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							"<pad>"
             UpperCAmelCase_      			=							1

             self.assertEqual(self.get_tokenizer()._convert_token_to_id(_UpperCAmelCase   )		,    _UpperCAmelCase   )
             self.assertEqual(self.get_tokenizer()._convert_id_to_token(_UpperCAmelCase   )		,    _UpperCAmelCase   )



       def 					lowercase__    (							self      :  Any   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							list(self.get_tokenizer().get_vocab().keys()   )

             self.assertEqual(vocab_keys[0]		,    "<s>"   )
             self.assertEqual(vocab_keys[1]		,    "<pad>"   )
             self.assertEqual(vocab_keys[-1]		,    "<mask>"   )
             self.assertEqual(len(_UpperCAmelCase   )		,    101122   )



       def 					lowercase__    (							self      :  Any   )			->						List[str]:


             '''simple docstring'''




             self.assertEqual(self.get_tokenizer().vocab_size		,    101122   )



       @require_torch
       def 					lowercase__    (							self      :  Any   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							["A long paragraph for summarization.", "Another paragraph for summarization."]
             UpperCAmelCase_      			=							[0, 57, 3018, 70307, 91, 2]

             UpperCAmelCase_      			=							self.tokenizer(
                 _UpperCAmelCase		,    max_length=len(_UpperCAmelCase   )		,    padding=_UpperCAmelCase		,    truncation=_UpperCAmelCase		,    return_tensors="pt"   )
             self.assertIsInstance(_UpperCAmelCase		,    _UpperCAmelCase   )

             self.assertEqual((2, 6)		,    batch.input_ids.shape   )
             self.assertEqual((2, 6)		,    batch.attention_mask.shape   )
             UpperCAmelCase_      			=							batch.input_ids.tolist()[0]
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )



       def 					lowercase__    (							self      :  Optional[Any]   )			->						str:


             '''simple docstring'''




             if not self.test_rust_tokenizer:
                   return

             UpperCAmelCase_      			=							self.get_tokenizer()
             UpperCAmelCase_      			=							self.get_rust_tokenizer()

             UpperCAmelCase_      			=							"I was born in 92000, and this is falsé."

             UpperCAmelCase_      			=							tokenizer.tokenize(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.tokenize(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase		,    add_special_tokens=_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )

             UpperCAmelCase_      			=							self.get_rust_tokenizer()
             UpperCAmelCase_      			=							tokenizer.encode(_UpperCAmelCase   )
             UpperCAmelCase_      			=							rust_tokenizer.encode(_UpperCAmelCase   )
             self.assertListEqual(_UpperCAmelCase		,    _UpperCAmelCase   )







       @slow
       def 					lowercase__    (							self      :  Dict   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							{"input_ids": [[0, 490, 14328, 4507, 354, 47, 43669, 95, 25, 78117, 20215, 19779, 190, 22, 400, 4, 35343, 80310, 603, 86, 24937, 105, 33438, 94762, 196, 39642, 7, 15, 15933, 173, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1], [0, 10534, 87, 25, 66, 3358, 196, 55289, 8, 82961, 81, 2204, 75203, 7, 15, 763, 12956, 216, 178, 14328, 9595, 1377, 69693, 7, 448, 71021, 196, 18106, 1437, 13974, 108, 9083, 4, 49315, 7, 39, 86, 1326, 2793, 46333, 4, 448, 196, 74588, 7, 49315, 7, 39, 21, 822, 38470, 74, 21, 66723, 62480, 8, 22050, 5, 2]], "attention_mask": [[1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1]]}  # noqa: E501
             # fmt: on

             # moussaKam/mbarthez is a french model. So we also use french texts.
             UpperCAmelCase_      			=							[
                 "Le transformeur est un modèle d'apprentissage profond introduit en 2017, "
                 "utilisé principalement dans le domaine du traitement automatique des langues (TAL).",
                 "À l'instar des réseaux de neurones récurrents (RNN), les transformeurs sont conçus "
                 "pour gérer des données séquentielles, telles que le langage naturel, pour des tâches "
                 "telles que la traduction et la synthèse de texte.",
             ]

             self.tokenizer_integration_test_util(
                 expected_encoding=_UpperCAmelCase		,    model_name="moussaKam/mbarthez"		,    revision="c2e4ecbca5e3cd2c37fe1ac285ca4fbdf1366fb6"		,    sequences=_UpperCAmelCase		,    )









"""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 				lowercase__       :







       '''simple docstring'''


       def __init__(							self      :  Any		,    _UpperCAmelCase      :  str		,    _UpperCAmelCase      :  Union[str, Any]=2		,    _UpperCAmelCase      :  Any=True		,    _UpperCAmelCase      :  int=False		,    _UpperCAmelCase      :  str=10		,    _UpperCAmelCase      :  int=3		,    _UpperCAmelCase      :  Optional[int]=32 * 8		,    _UpperCAmelCase      :  str=32 * 8		,    _UpperCAmelCase      :  Any=4		,    _UpperCAmelCase      :  List[Any]=64		,    )			->						str:


             '''simple docstring'''




             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 					lowercase__    (							self      :  int   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]   ).to(
                 _UpperCAmelCase   )

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

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

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



       def 					lowercase__    (							self      :  Any   )			->						Tuple:


             '''simple docstring'''




             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 					lowercase__    (							self      :  Dict   )			->						Dict:


             '''simple docstring'''




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



       def 					lowercase__    (							self      :  Optional[Any]		,    _UpperCAmelCase      :  str		,    _UpperCAmelCase      :  Union[str, Any]   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_      			=							output.encoder_hidden_states
             UpperCAmelCase_      			=							output.pixel_decoder_hidden_states
             UpperCAmelCase_      			=							output.transformer_decoder_hidden_states

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



       def 					lowercase__    (							self      :  Tuple		,    _UpperCAmelCase      :  List[Any]		,    _UpperCAmelCase      :  Any		,    _UpperCAmelCase      :  Union[str, Any]		,    _UpperCAmelCase      :  Optional[int]=False   )			->						str:


             '''simple docstring'''




             with torch.no_grad():
                   UpperCAmelCase_      			=							MaskaFormerModel(config=_UpperCAmelCase   )
                   model.to(_UpperCAmelCase   )
                   model.eval()

                   UpperCAmelCase_      			=							model(pixel_values=_UpperCAmelCase		,    pixel_mask=_UpperCAmelCase   )
                   UpperCAmelCase_      			=							model(_UpperCAmelCase		,    output_hidden_states=_UpperCAmelCase   )

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







       def 					lowercase__    (							self      :  Optional[Any]		,    _UpperCAmelCase      :  Optional[int]		,    _UpperCAmelCase      :  Dict		,    _UpperCAmelCase      :  Optional[int]		,    _UpperCAmelCase      :  Union[str, Any]		,    _UpperCAmelCase      :  int   )			->						Optional[Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							MaskaFormerForUniversalSegmentation(config=_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.eval()

             def comm_check_on_output(_UpperCAmelCase      :  List[Any]   ):
                   # 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=_UpperCAmelCase		,    pixel_mask=_UpperCAmelCase   )
                   UpperCAmelCase_      			=							model(_UpperCAmelCase   )

                   comm_check_on_output(_UpperCAmelCase   )

                   UpperCAmelCase_      			=							model(
                       pixel_values=_UpperCAmelCase		,    pixel_mask=_UpperCAmelCase		,    mask_labels=_UpperCAmelCase		,    class_labels=_UpperCAmelCase   )

             comm_check_on_output(_UpperCAmelCase   )

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



@require_torch
class 				lowercase__       (   SCREAMING_SNAKE_CASE    , SCREAMING_SNAKE_CASE    , unittest.TestCase				):







       '''simple docstring'''


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

       UpperCamelCase						=					False
       UpperCamelCase						=					False
       UpperCamelCase						=					False
       UpperCamelCase						=					False



       def 					lowercase__    (							self      :  Tuple   )			->						Tuple:


             '''simple docstring'''




             UpperCAmelCase_      			=							MaskaFormerModelTester(self   )
             UpperCAmelCase_      			=							ConfigTester(self		,    config_class=_UpperCAmelCase		,    has_text_modality=_UpperCAmelCase   )



       def 					lowercase__    (							self      :  List[str]   )			->						Dict:


             '''simple docstring'''




             self.config_tester.run_common_tests()



       def 					lowercase__    (							self      :  Dict   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()
             self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase		,    **_UpperCAmelCase		,    output_hidden_states=_UpperCAmelCase   )



       def 					lowercase__    (							self      :  Optional[int]   )			->						Dict:


             '''simple docstring'''




             UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs()
             self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*_UpperCAmelCase   )



       @unittest.skip(reason="Mask2Former does not use inputs_embeds"   )
       def 					lowercase__    (							self      :  Tuple   )			->						Any:


             '''simple docstring'''




             pass



       @unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"   )
       def 					lowercase__    (							self      :  Tuple   )			->						Optional[int]:


             '''simple docstring'''




             pass



       @unittest.skip(reason="Mask2Former is not a generative model"   )
       def 					lowercase__    (							self      :  str   )			->						Dict:


             '''simple docstring'''




             pass



       @unittest.skip(reason="Mask2Former does not use token embeddings"   )
       def 					lowercase__    (							self      :  Union[str, Any]   )			->						Union[str, Any]:


             '''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 					lowercase__    (							self      :  List[Any]   )			->						Dict:


             '''simple docstring'''




             pass



       @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."   )
       def 					lowercase__    (							self      :  List[str]   )			->						List[str]:


             '''simple docstring'''




             pass



       def 					lowercase__    (							self      :  Tuple   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

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



       @slow
       def 					lowercase__    (							self      :  List[Any]   )			->						Dict:


             '''simple docstring'''




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



       def 					lowercase__    (							self      :  List[str]   )			->						List[str]:


             '''simple docstring'''




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

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



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						str:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()
             self.model_tester.create_and_check_maskaformer_model(_UpperCAmelCase		,    **_UpperCAmelCase		,    output_hidden_states=_UpperCAmelCase   )



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						List[str]:


             '''simple docstring'''




             UpperCAmelCase_			,   UpperCAmelCase_      			=							self.model_tester.prepare_config_and_inputs_for_common()

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



       def 					lowercase__    (							self      :  Union[str, Any]   )			->						List[str]:


             '''simple docstring'''




             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(_UpperCAmelCase   )
             model.to(_UpperCAmelCase   )
             model.train()

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







       def 					lowercase__    (							self      :  str   )			->						Optional[int]:


             '''simple docstring'''




             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(_UpperCAmelCase   ).to(_UpperCAmelCase   )
             model.train()

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

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

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



lowerCamelCase       	=						1e-4
def        a__     (				):
      UpperCAmelCase_      			=							Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"				)
      return image


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







       '''simple docstring'''


       @cached_property
       def 					lowercase__    (							self      :  Optional[Any]   )			->						int:


             '''simple docstring'''




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



       @cached_property
       def 					lowercase__    (							self      :  Dict   )			->						Optional[int]:


             '''simple docstring'''




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



       def 					lowercase__    (							self      :  Optional[Any]   )			->						Union[str, Any]:


             '''simple docstring'''




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

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

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

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

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



       def 					lowercase__    (							self      :  int   )			->						List[str]:


             '''simple docstring'''




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

             with torch.no_grad():
                   UpperCAmelCase_      			=							model(**_UpperCAmelCase   )
             # 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(_UpperCAmelCase   ).to(_UpperCAmelCase   )
             self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]		,    _UpperCAmelCase		,    atol=_UpperCAmelCase   )   )
             # 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(_UpperCAmelCase   )
             self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]		,    _UpperCAmelCase		,    atol=_UpperCAmelCase   )   )







       def 					lowercase__    (							self      :  List[Any]   )			->						Union[str, Any]:


             '''simple docstring'''




             UpperCAmelCase_      			=							MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints   ).to(_UpperCAmelCase   ).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(_UpperCAmelCase   )
             UpperCAmelCase_      			=							[el.to(_UpperCAmelCase   ) for el in inputs["mask_labels"]]
             UpperCAmelCase_      			=							[el.to(_UpperCAmelCase   ) for el in inputs["class_labels"]]

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

             self.assertTrue(outputs.loss is not None   )




