


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__	:






  def __init__(       self   :       Any		,    _lowercase   :       Dict		,    _lowercase   :       Optional[Any]=2		,    _lowercase   :       List[Any]=True		,    _lowercase   :       Optional[Any]=False		,    _lowercase   :       Optional[int]=10		,    _lowercase   :       Optional[int]=3		,    _lowercase   :       Optional[int]=32 * 4		,    _lowercase   :       int=32 * 6		,    _lowercase   :       List[Any]=4		,    _lowercase   :       List[Any]=32		,    ):




         """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__					    =  mask_feature_size






  def       _UpperCAmelCase	(       self   :       str			):




         """simple docstring"""







         UpperCAmelCase__					    =  floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]			).to(
             _lowercase			)

         UpperCAmelCase__					    =  torch.ones([self.batch_size, self.min_size, self.max_size]		,    device=_lowercase			)

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

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






  def       _UpperCAmelCase	(       self   :       Optional[Any]			):




         """simple docstring"""







         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   :       Optional[Any]			):




         """simple docstring"""







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






  def       _UpperCAmelCase	(       self   :       str		,    _lowercase   :       int		,    _lowercase   :       int			):




         """simple docstring"""







         UpperCAmelCase__					    =  output.encoder_hidden_states
         UpperCAmelCase__					    =  output.pixel_decoder_hidden_states
         UpperCAmelCase__					    =  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_config.decoder_layers			)






  def       _UpperCAmelCase	(       self   :       List[str]		,    _lowercase   :       Union[str, Any]		,    _lowercase   :       int		,    _lowercase   :       int		,    _lowercase   :       Tuple=False			):




         """simple docstring"""







         with torch.no_grad():
                UpperCAmelCase__					    =  MaskFormerModel(config=_lowercase			)
                model.to(_lowercase			)
                model.eval()

                UpperCAmelCase__					    =  model(pixel_values=_lowercase		,    pixel_mask=_lowercase			)
                UpperCAmelCase__					    =  model(_lowercase		,    output_hidden_states=_lowercase			)
         # 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(_lowercase		,    _lowercase			)






  def       _UpperCAmelCase	(       self   :       Union[str, Any]		,    _lowercase   :       Dict		,    _lowercase   :       Optional[int]		,    _lowercase   :       List[Any]		,    _lowercase   :       Optional[int]		,    _lowercase   :       Union[str, Any]			):




         """simple docstring"""







         UpperCAmelCase__					    =  MaskFormerForInstanceSegmentation(config=_lowercase			)
         model.to(_lowercase			)
         model.eval()

         def comm_check_on_output(_lowercase   :       Dict			):
                # 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=_lowercase		,    pixel_mask=_lowercase			)
                UpperCAmelCase__					    =  model(_lowercase			)

                comm_check_on_output(_lowercase			)

                UpperCAmelCase__					    =  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      lowercase__	(       __lowercase       ,				__lowercase       ,				unittest.TestCase		):
  A__=	(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
  A__=	(
      {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
      if is_torch_available()
      else {}
  )

  A__=	False
  A__=	False
  A__=	False
  A__=	False






  def       _UpperCAmelCase	(       self   :       Optional[Any]			):




         """simple docstring"""







         UpperCAmelCase__					    =  MaskFormerModelTester(self			)
         UpperCAmelCase__					    =  ConfigTester(self		,    config_class=_lowercase		,    has_text_modality=_lowercase			)






  def       _UpperCAmelCase	(       self   :       List[Any]			):




         """simple docstring"""







         self.config_tester.run_common_tests()






  def       _UpperCAmelCase	(       self   :       Tuple			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskformer_model(_lowercase		,    **_lowercase		,    output_hidden_states=_lowercase			)






  def       _UpperCAmelCase	(       self   :       Any			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*_lowercase			)






  @unittest.skip(reason="MaskFormer does not use inputs_embeds"			)
  def       _UpperCAmelCase	(       self   :       Optional[int]			):




         """simple docstring"""







         pass






  @unittest.skip(reason="MaskFormer does not have a get_input_embeddings method"			)
  def       _UpperCAmelCase	(       self   :       Any			):




         """simple docstring"""







         pass






  @unittest.skip(reason="MaskFormer is not a generative model"			)
  def       _UpperCAmelCase	(       self   :       Optional[Any]			):




         """simple docstring"""







         pass






  @unittest.skip(reason="MaskFormer does not use token embeddings"			)
  def       _UpperCAmelCase	(       self   :       List[str]			):




         """simple docstring"""







         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   :       Dict			):




         """simple docstring"""







         pass






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




         """simple docstring"""







         pass






  def       _UpperCAmelCase	(       self   :       List[str]			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs_for_common()

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






  @slow
  def       _UpperCAmelCase	(       self   :       List[Any]			):




         """simple docstring"""







         for model_name in ["facebook/maskformer-swin-small-coco"]:
                UpperCAmelCase__					    =  MaskFormerModel.from_pretrained(_lowercase			)
                self.assertIsNotNone(_lowercase			)






  def       _UpperCAmelCase	(       self   :       int			):




         """simple docstring"""







         UpperCAmelCase__					    =  (self.model_tester.min_size,) * 2
         UpperCAmelCase__					    =  {
             """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(),
         }

         UpperCAmelCase__					    =  MaskFormerForInstanceSegmentation(MaskFormerConfig()			).to(_lowercase			)
         UpperCAmelCase__					    =  model(**_lowercase			)
         self.assertTrue(outputs.loss is not None			)






  def       _UpperCAmelCase	(       self   :       List[str]			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs_for_common()
         self.model_tester.create_and_check_maskformer_model(_lowercase		,    **_lowercase		,    output_hidden_states=_lowercase			)






  def       _UpperCAmelCase	(       self   :       Optional[int]			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs_for_common()

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






  def       _UpperCAmelCase	(       self   :       List[Any]			):




         """simple docstring"""







         if not self.model_tester.is_training:
                return
         # only MaskFormerForInstanceSegmentation has the loss
         UpperCAmelCase__					    =  self.all_model_classes[1]
         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs()

         UpperCAmelCase__					    =  model_class(_lowercase			)
         model.to(_lowercase			)
         model.train()

         UpperCAmelCase__					    =  model(_lowercase		,    mask_labels=_lowercase		,    class_labels=_lowercase			).loss
         loss.backward()






  def       _UpperCAmelCase	(       self   :       Tuple			):




         """simple docstring"""







         UpperCAmelCase__					    =  self.all_model_classes[1]
         UpperCAmelCase__					    =  self.model_tester.prepare_config_and_inputs()
         UpperCAmelCase__					    =  True
         UpperCAmelCase__					    =  True

         UpperCAmelCase__					    =  model_class(_lowercase			)
         model.to(_lowercase			)
         model.train()

         UpperCAmelCase__					    =  model(_lowercase		,    mask_labels=_lowercase		,    class_labels=_lowercase			)

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

         UpperCAmelCase__					    =  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
         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=_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			)




A   =			1e-4





def __UpperCAmelCase							(		)    ->       Optional[Any]:



       '''simple docstring'''





       UpperCAmelCase__					    =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"      )
       return image




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






  @cached_property
  def       _UpperCAmelCase	(       self   :       int			):




         """simple docstring"""







         return (
             MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco"			)
             if is_vision_available()
             else None
         )






  def       _UpperCAmelCase	(       self   :       Tuple			):




         """simple docstring"""







         UpperCAmelCase__					    =  MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco"			).to(_lowercase			)
         UpperCAmelCase__					    =  self.default_image_processor
         UpperCAmelCase__					    =  prepare_img()
         UpperCAmelCase__					    =  image_processor(_lowercase		,    return_tensors="pt"			).to(_lowercase			)
         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(_lowercase		,    (1, 3, 8_00, 10_88)			)

         with torch.no_grad():
                UpperCAmelCase__					    =  model(**_lowercase			)

         UpperCAmelCase__					    =  torch.tensor(
             [[-0.0_4_8_2, 0.9_2_2_8, 0.4_9_5_1], [-0.2_5_4_7, 0.8_0_1_7, 0.8_5_2_7], [-0.0_0_6_9, 0.3_3_8_5, -0.0_0_8_9]]			).to(_lowercase			)
         self.assertTrue(
             torch.allclose(
                 outputs.encoder_last_hidden_state[0, 0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)

         UpperCAmelCase__					    =  torch.tensor(
             [[-0.8_4_2_2, -0.8_4_3_4, -0.9_7_1_8], [-1.0_1_4_4, -0.5_5_6_5, -0.4_1_9_5], [-1.0_0_3_8, -0.4_4_8_4, -0.1_9_6_1]]			).to(_lowercase			)
         self.assertTrue(
             torch.allclose(
                 outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)

         UpperCAmelCase__					    =  torch.tensor(
             [[0.2_8_5_2, -0.0_1_5_9, 0.9_7_3_5], [0.6_2_5_4, 0.1_8_5_8, 0.8_5_2_9], [-0.0_6_8_0, -0.4_1_1_6, 1.8_4_1_3]]			).to(_lowercase			)
         self.assertTrue(
             torch.allclose(
                 outputs.transformer_decoder_last_hidden_state[0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)






  def       _UpperCAmelCase	(       self   :       List[Any]			):




         """simple docstring"""







         UpperCAmelCase__					    =  (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"			)
             .to(_lowercase			)
             .eval()
         )
         UpperCAmelCase__					    =  self.default_image_processor
         UpperCAmelCase__					    =  prepare_img()
         UpperCAmelCase__					    =  image_processor(_lowercase		,    return_tensors="pt"			).to(_lowercase			)
         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(_lowercase		,    (1, 3, 8_00, 10_88)			)

         with torch.no_grad():
                UpperCAmelCase__					    =  model(**_lowercase			)
         # masks_queries_logits
         UpperCAmelCase__					    =  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)		,    )
         UpperCAmelCase__					    =  [
             [-1.3_7_3_7_1_2_4, -1.7_7_2_4_9_3_7, -1.9_3_6_4_2_3_3],
             [-1.5_9_7_7_2_8_1, -1.9_8_6_7_9_3_9, -2.1_5_2_3_6_9_5],
             [-1.5_7_9_5_3_9_8, -1.9_2_6_9_8_3_2, -2.0_9_3_9_4_2],
         ]
         UpperCAmelCase__					    =  torch.tensor(_lowercase			).to(_lowercase			)
         self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)
         # class_queries_logits
         UpperCAmelCase__					    =  outputs.class_queries_logits
         self.assertEqual(
             class_queries_logits.shape		,    (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)			)
         UpperCAmelCase__					    =  torch.tensor(
             [
                 [1.6512E00, -5.2572E00, -3.3519E00],
                 [3.6169E-02, -5.9025E00, -2.9313E00],
                 [1.0766E-04, -7.7630E00, -5.1263E00],
             ]			).to(_lowercase			)
         self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)






  def       _UpperCAmelCase	(       self   :       Any			):




         """simple docstring"""







         UpperCAmelCase__					    =  (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff"			)
             .to(_lowercase			)
             .eval()
         )
         UpperCAmelCase__					    =  self.default_image_processor
         UpperCAmelCase__					    =  prepare_img()
         UpperCAmelCase__					    =  image_processor(_lowercase		,    return_tensors="pt"			).to(_lowercase			)
         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(_lowercase		,    (1, 3, 8_00, 10_88)			)

         with torch.no_grad():
                UpperCAmelCase__					    =  model(**_lowercase			)
         # masks_queries_logits
         UpperCAmelCase__					    =  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)		,    )
         UpperCAmelCase__					    =  [[-0.9_0_4_6, -2.6_3_6_6, -4.6_0_6_2], [-3.4_1_7_9, -5.7_8_9_0, -8.8_0_5_7], [-4.9_1_7_9, -7.6_5_6_0, -1_0.7_7_1_1]]
         UpperCAmelCase__					    =  torch.tensor(_lowercase			).to(_lowercase			)
         self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)
         # class_queries_logits
         UpperCAmelCase__					    =  outputs.class_queries_logits
         self.assertEqual(
             class_queries_logits.shape		,    (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)			)
         UpperCAmelCase__					    =  torch.tensor(
             [[4.7_1_8_8, -3.2_5_8_5, -2.8_8_5_7], [6.6_8_7_1, -2.9_1_8_1, -1.2_4_8_7], [7.2_4_4_9, -2.2_7_6_4, -2.1_8_7_4]]			).to(_lowercase			)
         self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]		,    _lowercase		,    atol=_lowercase			)			)






  def       _UpperCAmelCase	(       self   :       Optional[Any]			):




         """simple docstring"""







         UpperCAmelCase__					    =  (
             MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"			)
             .to(_lowercase			)
             .eval()
         )
         UpperCAmelCase__					    =  self.default_image_processor

         UpperCAmelCase__					    =  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"		,    )

         UpperCAmelCase__					    =  inputs["""pixel_values"""].to(_lowercase			)
         UpperCAmelCase__					    =  [el.to(_lowercase			) for el in inputs["""mask_labels"""]]
         UpperCAmelCase__					    =  [el.to(_lowercase			) for el in inputs["""class_labels"""]]

         with torch.no_grad():
                UpperCAmelCase__					    =  model(**_lowercase			)

         self.assertTrue(outputs.loss is not None			)












'''simple docstring'''






import warnings

from ...utils import logging
from .image_processing_owlvit import OwlViTImageProcessor


__UpperCamelCase					    =	logging.get_logger(__name__)




class  _A (					__lowercase		):

		def __init__(   self					:   int  ,      *__magic_name__					:   Optional[Any]  ,      **__magic_name__					:   Any			)					->    None:


					"""simple docstring"""

					warnings.warn(
					    """The class OwlViTFeatureExtractor is deprecated and will be removed in version 5 of Transformers. Please"""
					    """ use OwlViTImageProcessor instead."""  ,      __magic_name__  ,      )
					super().__init__(*__magic_name__  ,      **__magic_name__			)


