




from collections.abc import Generator
from math import sin
def 		a_							( __lowerCAmelCase				):
  if len(__snake_case				) != 32:
    raise ValueError('''Input must be of length 32'''				)

  lowerCAmelCase__										=      B''''''
  for i in [3, 2, 1, 0]:
    little_endian += string_aa[8 * i : 8 * i + 8]
  return little_endian
def 		a_							( __lowerCAmelCase				):
  if i < 0:
    raise ValueError('''Input must be non-negative'''				)

  lowerCAmelCase__										=      format(__snake_case   , '''08x'''				)[-8:]
  lowerCAmelCase__										=      B''''''
  for i in [3, 2, 1, 0]:
    little_endian_hex += hex_rep[2 * i : 2 * i + 2].encode('''utf-8'''				)
  return little_endian_hex
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      B''''''
  for char in message:
    bit_string += format(__snake_case   , '''08b'''				).encode('''utf-8'''				)
  lowerCAmelCase__										=      format(len(__snake_case				)   , '''064b'''				).encode('''utf-8'''				)

  # Pad bit_string to a multiple of 512 chars
  bit_string += b"1"
  while len(__snake_case				) % 5_12 != 4_48:
    bit_string += b"0"
  bit_string += to_little_endian(start_len[32:]				) + to_little_endian(start_len[:32]				)

  return bit_string
def 		a_							( __lowerCAmelCase				):
  if len(__snake_case				) % 5_12 != 0:
    raise ValueError('''Input must have length that\'s a multiple of 512'''				)

  for pos in range(0   , len(__snake_case				)   , 5_12				):
    lowerCAmelCase__										=      bit_string[pos : pos + 5_12]
    lowerCAmelCase__										=      []
    for i in range(0   , 5_12   , 32				):
      block_words.append(int(to_little_endian(block[i : i + 32]				)   , 2				)				)
    yield block_words
def 		a_							( __lowerCAmelCase				):
  if i < 0:
    raise ValueError('''Input must be non-negative'''				)

  lowerCAmelCase__										=      format(__snake_case   , '''032b'''				)
  lowerCAmelCase__										=      ''''''
  for c in i_str:
    new_str += "1" if c == "0" else "0"
  return int(__snake_case   , 2				)
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase				):
  return (a + b) % 2**32
def 		a_							( __lowerCAmelCase   , __lowerCAmelCase				):
  if i < 0:
    raise ValueError('''Input must be non-negative'''				)
  if shift < 0:
    raise ValueError('''Shift must be non-negative'''				)
  return ((i << shift) ^ (i >> (32 - shift))) % 2**32
def 		a_							( __lowerCAmelCase				):
  lowerCAmelCase__										=      preprocess(__snake_case				)

  lowerCAmelCase__										=      [int(2**32 * abs(sin(i + 1				)				)				) for i in range(64				)]

  # Starting states
  lowerCAmelCase__										=      0x6745_2301
  lowerCAmelCase__										=      0xEFCD_AB89
  lowerCAmelCase__										=      0x98BA_DCFE
  lowerCAmelCase__										=      0x1032_5476

  lowerCAmelCase__										=      [
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      7,
      12,
      17,
      22,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      5,
      9,
      14,
      20,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      4,
      11,
      16,
      23,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
      6,
      10,
      15,
      21,
  ]

  # Process bit string in chunks, each with 16 32-char words
  for block_words in get_block_words(__snake_case				):
    lowerCAmelCase__										=      aa
    lowerCAmelCase__										=      ba
    lowerCAmelCase__										=      ca
    lowerCAmelCase__										=      da

    # Hash current chunk
    for i in range(64				):
      if i <= 15:
        # f = (b & c) | (not_32(b) & d)     # Alternate definition for f
        lowerCAmelCase__										=      d ^ (b & (c ^ d))
        lowerCAmelCase__										=      i
      elif i <= 31:
        # f = (d & b) | (not_32(d) & c)     # Alternate definition for f
        lowerCAmelCase__										=      c ^ (d & (b ^ c))
        lowerCAmelCase__										=      (5 * i + 1) % 16
      elif i <= 47:
        lowerCAmelCase__										=      b ^ c ^ d
        lowerCAmelCase__										=      (3 * i + 5) % 16
      else:
        lowerCAmelCase__										=      c ^ (b | not_aa(__snake_case				))
        lowerCAmelCase__										=      (7 * i) % 16
      lowerCAmelCase__										=      (f + a + added_consts[i] + block_words[g]) % 2**32
      lowerCAmelCase__										=      d
      lowerCAmelCase__										=      c
      lowerCAmelCase__										=      b
      lowerCAmelCase__										=      sum_aa(__snake_case   , left_rotate_aa(__snake_case   , shift_amounts[i]				)				)

    # Add hashed chunk to running total
    lowerCAmelCase__										=      sum_aa(__snake_case   , __snake_case				)
    lowerCAmelCase__										=      sum_aa(__snake_case   , __snake_case				)
    lowerCAmelCase__										=      sum_aa(__snake_case   , __snake_case				)
    lowerCAmelCase__										=      sum_aa(__snake_case   , __snake_case				)

  lowerCAmelCase__										=      reformat_hex(__snake_case				) + reformat_hex(__snake_case				) + reformat_hex(__snake_case				) + reformat_hex(__snake_case				)
  return digest


if __name__ == "__main__":
      import doctest

      doctest.testmod()


'''simple docstring'''






import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import DetrConfig, MaskFormerConfig, SwinConfig, 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 MaskFormerForInstanceSegmentation, MaskFormerModel

   if is_vision_available():
      from transformers import MaskFormerImageProcessor

if is_vision_available():
   from PIL import Image







class lowercase_       :







   """simple docstring"""

   def __init__(      self      :			Optional[Any], UpperCamelCase__      :			Tuple, UpperCamelCase__      :			Any=2, UpperCamelCase__      :			Union[str, Any]=True, UpperCamelCase__      :			Optional[Any]=False, UpperCamelCase__      :			int=10, UpperCamelCase__      :			List[str]=3, UpperCamelCase__      :			List[str]=32 * 4, UpperCamelCase__      :			List[Any]=32 * 6, UpperCamelCase__      :			Dict=4, UpperCamelCase__      :			str=32, )  ->			Dict:
        _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    		=  mask_feature_size
   def 	__UpperCAmelCase   (      self      :			List[Any]     )  ->			Tuple:
        _A    		=  floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]     ).to(
            UpperCamelCase__     )

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

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

        _A    		=  self.get_config()
        return config, pixel_values, pixel_mask, mask_labels, class_labels
   def 	__UpperCAmelCase   (      self      :			Tuple     )  ->			Optional[int]:
        return MaskFormerConfig.from_backbone_and_decoder_configs(
            backbone_config=SwinConfig(
                depths=[1, 1, 1, 1], ), decoder_config=DetrConfig(
                decoder_ffn_dim=1_28, num_queries=self.num_queries, decoder_attention_heads=2, d_model=self.mask_feature_size, ), mask_feature_size=self.mask_feature_size, fpn_feature_size=self.mask_feature_size, num_channels=self.num_channels, num_labels=self.num_labels, )
   def 	__UpperCAmelCase   (      self      :			int     )  ->			Tuple:
        _A		,       _A		,       _A		,       _A		,       _A    		=  self.prepare_config_and_inputs()
        _A    		=  {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
        return config, inputs_dict
   def 	__UpperCAmelCase   (      self      :			Optional[int], UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			Dict     )  ->			List[Any]:
        _A    		=  output.encoder_hidden_states
        _A    		=  output.pixel_decoder_hidden_states
        _A    		=  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_config.decoder_layers     )
   def 	__UpperCAmelCase   (      self      :			Any, UpperCamelCase__      :			Any, UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			Optional[int], UpperCamelCase__      :			Optional[Any]=False     )  ->			Optional[Any]:
        with torch.no_grad():
             _A    		=  MaskFormerModel(config=UpperCamelCase__     )
             model.to(UpperCamelCase__     )
             model.eval()

             _A    		=  model(pixel_values=UpperCamelCase__, pixel_mask=UpperCamelCase__     )
             _A    		=  model(UpperCamelCase__, output_hidden_states=UpperCamelCase__     )
        # the correct shape of output.transformer_decoder_hidden_states ensure the correcteness of the
        # encoder and pixel decoder
        self.parent.assertEqual(
            output.transformer_decoder_last_hidden_state.shape, (self.batch_size, self.num_queries, self.mask_feature_size), )
        # 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 	__UpperCAmelCase   (      self      :			List[Any], UpperCamelCase__      :			Tuple, UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			int, UpperCamelCase__      :			Optional[Any], UpperCamelCase__      :			Tuple     )  ->			str:
        _A    		=  MaskFormerForInstanceSegmentation(config=UpperCamelCase__     )
        model.to(UpperCamelCase__     )
        model.eval()

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

             comm_check_on_output(UpperCamelCase__     )

             _A    		=  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_       (		_UpperCamelCase    ,    _UpperCamelCase    ,    unittest.TestCase			):







   """simple docstring"""

   __lowerCAmelCase         =   (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
   __lowerCAmelCase         =   (
       {"feature-extraction": MaskFormerModel, "image-segmentation": MaskFormerForInstanceSegmentation}
       if is_torch_available()
       else {}
   )

   __lowerCAmelCase         =   False
   __lowerCAmelCase         =   False
   __lowerCAmelCase         =   False
   __lowerCAmelCase         =   False
   def 	__UpperCAmelCase   (      self      :			Optional[Any]     )  ->			Tuple:
        _A    		=  MaskFormerModelTester(self     )
        _A    		=  ConfigTester(self, config_class=UpperCamelCase__, has_text_modality=UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			List[str]     )  ->			int:
        self.config_tester.run_common_tests()
   def 	__UpperCAmelCase   (      self      :			Dict     )  ->			int:
        _A		,       _A    		=  self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.create_and_check_maskformer_model(UpperCamelCase__, **UpperCamelCase__, output_hidden_states=UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			List[str]     )  ->			Optional[int]:
        _A    		=  self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*UpperCamelCase__     )
   @unittest.skip(reason='MaskFormer does not use inputs_embeds'     )
   def 	__UpperCAmelCase   (      self      :			Optional[Any]     )  ->			Any:
        pass
   @unittest.skip(reason='MaskFormer does not have a get_input_embeddings method'     )
   def 	__UpperCAmelCase   (      self      :			Dict     )  ->			Union[str, Any]:
        pass
   @unittest.skip(reason='MaskFormer is not a generative model'     )
   def 	__UpperCAmelCase   (      self      :			Tuple     )  ->			Union[str, Any]:
        pass
   @unittest.skip(reason='MaskFormer does not use token embeddings'     )
   def 	__UpperCAmelCase   (      self      :			Optional[int]     )  ->			Union[str, Any]:
        pass
   @require_torch_multi_gpu
   @unittest.skip(
       reason='MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'     )
   def 	__UpperCAmelCase   (      self      :			List[Any]     )  ->			Union[str, Any]:
        pass
   @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'     )
   def 	__UpperCAmelCase   (      self      :			Any     )  ->			Any:
        pass
   def 	__UpperCAmelCase   (      self      :			Union[str, Any]     )  ->			List[str]:
        _A		,       _A    		=  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             _A    		=  model_class(UpperCamelCase__     )
             _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], UpperCamelCase__     )
   @slow
   def 	__UpperCAmelCase   (      self      :			Optional[int]     )  ->			Optional[int]:
        for model_name in ["facebook/maskformer-swin-small-coco"]:
             _A    		=  MaskFormerModel.from_pretrained(UpperCamelCase__     )
             self.assertIsNotNone(UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			Optional[Any]     )  ->			List[Any]:
        _A    		=  (self.model_tester.min_size,) * 2
        _A    		=  {
            '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(),
        }

        _A    		=  MaskFormerForInstanceSegmentation(MaskFormerConfig()     ).to(UpperCamelCase__     )
        _A    		=  model(**UpperCamelCase__     )
        self.assertTrue(outputs.loss is not None     )
   def 	__UpperCAmelCase   (      self      :			Dict     )  ->			Dict:
        _A		,       _A    		=  self.model_tester.prepare_config_and_inputs_for_common()
        self.model_tester.create_and_check_maskformer_model(UpperCamelCase__, **UpperCamelCase__, output_hidden_states=UpperCamelCase__     )
   def 	__UpperCAmelCase   (      self      :			int     )  ->			Tuple:
        _A		,       _A    		=  self.model_tester.prepare_config_and_inputs_for_common()

        for model_class in self.all_model_classes:
             _A    		=  model_class(UpperCamelCase__     ).to(UpperCamelCase__     )
             _A    		=  model(**UpperCamelCase__, output_attentions=UpperCamelCase__     )
             self.assertTrue(outputs.attentions is not None     )
   def 	__UpperCAmelCase   (      self      :			List[Any]     )  ->			List[Any]:
        if not self.model_tester.is_training:
             return
        # only MaskFormerForInstanceSegmentation has the loss
        _A    		=  self.all_model_classes[1]
        _A		,       _A		,       _A		,       _A		,       _A    		=  self.model_tester.prepare_config_and_inputs()

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

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

   def 	__UpperCAmelCase   (      self      :			Dict     )  ->			List[str]:
        # only MaskFormerForInstanceSegmentation has the loss
        _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(UpperCamelCase__     )
        model.to(UpperCamelCase__     )
        model.train()

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

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

        _A    		=  outputs.pixel_decoder_hidden_states[0]
        pixel_decoder_hidden_states.retain_grad()
        # we requires_grad=True in inputs_embeds (line 2152), the original implementation don't
        _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=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     )






_UpperCAmelCase    :     Any         =       1E-4





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







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







   """simple docstring"""

   @cached_property
   def 	__UpperCAmelCase   (      self      :			str     )  ->			Optional[int]:
        return (
            MaskFormerImageProcessor.from_pretrained('facebook/maskformer-swin-small-coco'     )
            if is_vision_available()
            else None
        )
   def 	__UpperCAmelCase   (      self      :			Any     )  ->			List[str]:
        _A    		=  MaskFormerModel.from_pretrained('facebook/maskformer-swin-small-coco'     ).to(UpperCamelCase__     )
        _A    		=  self.default_image_processor
        _A    		=  prepare_img()
        _A    		=  image_processor(UpperCamelCase__, return_tensors='pt'     ).to(UpperCamelCase__     )
        _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(UpperCamelCase__, (1, 3, 8_00, 10_88)     )

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

        _A    		=  torch.tensor(
            [[-0.0_482, 0.9_228, 0.4_951], [-0.2_547, 0.8_017, 0.8_527], [-0.0_069, 0.3_385, -0.0_089]]     ).to(UpperCamelCase__     )
        self.assertTrue(
            torch.allclose(
                outputs.encoder_last_hidden_state[0, 0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )

        _A    		=  torch.tensor(
            [[-0.8_422, -0.8_434, -0.9_718], [-1.0_144, -0.5_565, -0.4_195], [-1.0_038, -0.4_484, -0.1_961]]     ).to(UpperCamelCase__     )
        self.assertTrue(
            torch.allclose(
                outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )

        _A    		=  torch.tensor(
            [[0.2_852, -0.0_159, 0.9_735], [0.6_254, 0.1_858, 0.8_529], [-0.0_680, -0.4_116, 1.8_413]]     ).to(UpperCamelCase__     )
        self.assertTrue(
            torch.allclose(
                outputs.transformer_decoder_last_hidden_state[0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )
   def 	__UpperCAmelCase   (      self      :			Union[str, Any]     )  ->			Optional[int]:
        _A    		=  (
            MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-swin-small-coco'     )
            .to(UpperCamelCase__     )
            .eval()
        )
        _A    		=  self.default_image_processor
        _A    		=  prepare_img()
        _A    		=  image_processor(UpperCamelCase__, return_tensors='pt'     ).to(UpperCamelCase__     )
        _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(UpperCamelCase__, (1, 3, 8_00, 10_88)     )

        with torch.no_grad():
             _A    		=  model(**UpperCamelCase__     )
        # masks_queries_logits
        _A    		=  outputs.masks_queries_logits
        self.assertEqual(
            masks_queries_logits.shape, (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4), )
        _A    		=  [
            [-1.3_737_124, -1.7_724_937, -1.9_364_233],
            [-1.5_977_281, -1.9_867_939, -2.1_523_695],
            [-1.5_795_398, -1.9_269_832, -2.093_942],
        ]
        _A    		=  torch.tensor(UpperCamelCase__     ).to(UpperCamelCase__     )
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )
        # class_queries_logits
        _A    		=  outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape, (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)     )
        _A    		=  torch.tensor(
            [
                [1.6512e00, -5.2572e00, -3.3519e00],
                [3.6169e-02, -5.9025e00, -2.9313e00],
                [1.0766e-04, -7.7630e00, -5.1263e00],
            ]     ).to(UpperCamelCase__     )
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )
   def 	__UpperCAmelCase   (      self      :			List[Any]     )  ->			Optional[Any]:
        _A    		=  (
            MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-resnet101-coco-stuff'     )
            .to(UpperCamelCase__     )
            .eval()
        )
        _A    		=  self.default_image_processor
        _A    		=  prepare_img()
        _A    		=  image_processor(UpperCamelCase__, return_tensors='pt'     ).to(UpperCamelCase__     )
        _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(UpperCamelCase__, (1, 3, 8_00, 10_88)     )

        with torch.no_grad():
             _A    		=  model(**UpperCamelCase__     )
        # masks_queries_logits
        _A    		=  outputs.masks_queries_logits
        self.assertEqual(
            masks_queries_logits.shape, (1, model.config.decoder_config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4), )
        _A    		=  [[-0.9_046, -2.6_366, -4.6_062], [-3.4_179, -5.7_890, -8.8_057], [-4.9_179, -7.6_560, -10.7_711]]
        _A    		=  torch.tensor(UpperCamelCase__     ).to(UpperCamelCase__     )
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )
        # class_queries_logits
        _A    		=  outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape, (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)     )
        _A    		=  torch.tensor(
            [[4.7_188, -3.2_585, -2.8_857], [6.6_871, -2.9_181, -1.2_487], [7.2_449, -2.2_764, -2.1_874]]     ).to(UpperCamelCase__     )
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3], UpperCamelCase__, atol=UpperCamelCase__     )     )

   def 	__UpperCAmelCase   (      self      :			Dict     )  ->			int:
        _A    		=  (
            MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-swin-small-coco'     )
            .to(UpperCamelCase__     )
            .eval()
        )
        _A    		=  self.default_image_processor

        _A    		=  image_processor(
            [np.zeros((3, 8_00, 13_33)     ), np.zeros((3, 8_00, 13_33)     )], segmentation_maps=[np.zeros((3_84, 3_84)     ).astype(np.floataa     ), np.zeros((3_84, 3_84)     ).astype(np.floataa     )], return_tensors='pt', )

        _A    		=  inputs['pixel_values'].to(UpperCamelCase__     )
        _A    		=  [el.to(UpperCamelCase__     ) for el in inputs['mask_labels']]
        _A    		=  [el.to(UpperCamelCase__     ) for el in inputs['class_labels']]

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

        self.assertTrue(outputs.loss is not None     )



