

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




  def __init__(       self							,     lowerCAmelCase							,     lowerCAmelCase=2							,     lowerCAmelCase=True							,     lowerCAmelCase=False							,     lowerCAmelCase=10							,     lowerCAmelCase=3							,     lowerCAmelCase=32 * 4							,     lowerCAmelCase=32 * 6							,     lowerCAmelCase=4							,     lowerCAmelCase=32							,     )						->				int:
        '''simple docstring'''






        _lowercase			 =parent
        _lowercase			 =batch_size
        _lowercase			 =is_training
        _lowercase			 =use_auxiliary_loss
        _lowercase			 =num_queries
        _lowercase			 =num_channels
        _lowercase			 =min_size
        _lowercase			 =max_size
        _lowercase			 =num_labels
        _lowercase			 =mask_feature_size




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






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

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

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

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




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        return MaskFormerConfig.from_backbone_and_decoder_configs(
            backbone_config=SwinConfig(
                depths=[1, 1, 1, 1]							,     )							,     decoder_config=DetrConfig(
                decoder_ffn_dim=128							,     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 						A__  (       self      )						->				int:
        '''simple docstring'''






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




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase      )						->				Any:
        '''simple docstring'''






        _lowercase			 =output.encoder_hidden_states
        _lowercase			 =output.pixel_decoder_hidden_states
        _lowercase			 =output.transformer_decoder_hidden_states

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




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase=False      )						->				Optional[int]:
        '''simple docstring'''






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

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




  def 						A__  (       self							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )						->				List[str]:
        '''simple docstring'''






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

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

              comm_check_on_output(lowerCAmelCase      )

              _lowercase			 =model(
                  pixel_values=lowerCAmelCase							,     pixel_mask=lowerCAmelCase							,     mask_labels=lowerCAmelCase							,     class_labels=lowerCAmelCase      )

        comm_check_on_output(lowerCAmelCase      )

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





@require_torch
class 				__lowerCAmelCase  (      SCREAMING_SNAKE_CASE    ,    SCREAMING_SNAKE_CASE    ,    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 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        self.config_tester.run_common_tests()




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






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




  @unittest.skip(reason='MaskFormer does not use inputs_embeds'      )
  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        pass




  @unittest.skip(reason='MaskFormer does not have a get_input_embeddings method'      )
  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        pass




  @unittest.skip(reason='MaskFormer is not a generative model'      )
  def 						A__  (       self      )						->				Any:
        '''simple docstring'''






        pass




  @unittest.skip(reason='MaskFormer does not use token embeddings'      )
  def 						A__  (       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 						A__  (       self      )						->				Tuple:
        '''simple docstring'''






        pass




  @unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'      )
  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        pass




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.model_tester.prepare_config_and_inputs_for_common()

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

              _lowercase			 =['pixel_values']
              self.assertListEqual(arg_names[:1]							,     lowerCAmelCase      )




  @slow
  def 						A__  (       self      )						->				str:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase			 =(self.model_tester.min_size,) * 2
        _lowercase			 ={
            'pixel_values': torch.randn((2, 3, *size)							,     device=lowerCAmelCase      ),
            'mask_labels': torch.randn((2, 10, *size)							,     device=lowerCAmelCase      ),
            'class_labels': torch.zeros(2							,     10							,     device=lowerCAmelCase      ).long(),
        }

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




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






        _lowercase , _lowercase			 =self.model_tester.prepare_config_and_inputs_for_common()

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




  def 						A__  (       self      )						->				Optional[int]:
        '''simple docstring'''






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

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

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




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






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

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

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

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

        _lowercase			 =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
        _lowercase			 =outputs.transformer_decoder_hidden_states[0]
        transformer_decoder_hidden_states.retain_grad()

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

        outputs.loss.backward(retain_graph=lowerCAmelCase      )

        self.assertIsNotNone(encoder_hidden_states.grad      )
        self.assertIsNotNone(pixel_decoder_hidden_states.grad      )
        self.assertIsNotNone(transformer_decoder_hidden_states.grad      )
        self.assertIsNotNone(attentions.grad      )
lowercase_             =     1e-4
def   a   (    )					->   Optional[Any]:





      """simple docstring"""



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







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




  @cached_property
  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






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




  def 						A__  (       self      )						->				Union[str, Any]:
        '''simple docstring'''






        _lowercase			 =MaskFormerModel.from_pretrained('facebook/maskformer-swin-small-coco'      ).to(lowerCAmelCase      )
        _lowercase			 =self.default_image_processor
        _lowercase			 =prepare_img()
        _lowercase			 =image_processor(lowerCAmelCase							,     return_tensors='pt'      ).to(lowerCAmelCase      )
        _lowercase			 =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(lowerCAmelCase							,     (1, 3, 800, 1_088)      )

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

        _lowercase			 =torch.tensor(
            [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]      ).to(lowerCAmelCase      )
        self.assertTrue(
            torch.allclose(
                outputs.encoder_last_hidden_state[0, 0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )

        _lowercase			 =torch.tensor(
            [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]      ).to(lowerCAmelCase      )
        self.assertTrue(
            torch.allclose(
                outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )

        _lowercase			 =torch.tensor(
            [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]      ).to(lowerCAmelCase      )
        self.assertTrue(
            torch.allclose(
                outputs.transformer_decoder_last_hidden_state[0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =(
            MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-swin-small-coco'      )
            .to(lowerCAmelCase      )
            .eval()
        )
        _lowercase			 =self.default_image_processor
        _lowercase			 =prepare_img()
        _lowercase			 =image_processor(lowerCAmelCase							,     return_tensors='pt'      ).to(lowerCAmelCase      )
        _lowercase			 =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(lowerCAmelCase							,     (1, 3, 800, 1_088)      )

        with torch.no_grad():
              _lowercase			 =model(**lowerCAmelCase      )
        # masks_queries_logits
        _lowercase			 =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)							,     )
        _lowercase			 =[
            [-1.3737124, -1.7724937, -1.9364233],
            [-1.5977281, -1.9867939, -2.1523695],
            [-1.5795398, -1.9269832, -2.093942],
        ]
        _lowercase			 =torch.tensor(lowerCAmelCase      ).to(lowerCAmelCase      )
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )
        # class_queries_logits
        _lowercase			 =outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape							,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)      )
        _lowercase			 =torch.tensor(
            [
                [1.6512e00, -5.2572e00, -3.3519e00],
                [3.6169e-02, -5.9025e00, -2.9313e00],
                [1.0766e-04, -7.7630e00, -5.1263e00],
            ]      ).to(lowerCAmelCase      )
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )




  def 						A__  (       self      )						->				Optional[Any]:
        '''simple docstring'''






        _lowercase			 =(
            MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-resnet101-coco-stuff'      )
            .to(lowerCAmelCase      )
            .eval()
        )
        _lowercase			 =self.default_image_processor
        _lowercase			 =prepare_img()
        _lowercase			 =image_processor(lowerCAmelCase							,     return_tensors='pt'      ).to(lowerCAmelCase      )
        _lowercase			 =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(lowerCAmelCase							,     (1, 3, 800, 1_088)      )

        with torch.no_grad():
              _lowercase			 =model(**lowerCAmelCase      )
        # masks_queries_logits
        _lowercase			 =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)							,     )
        _lowercase			 =[[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
        _lowercase			 =torch.tensor(lowerCAmelCase      ).to(lowerCAmelCase      )
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )
        # class_queries_logits
        _lowercase			 =outputs.class_queries_logits
        self.assertEqual(
            class_queries_logits.shape							,     (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)      )
        _lowercase			 =torch.tensor(
            [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]      ).to(lowerCAmelCase      )
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]							,     lowerCAmelCase							,     atol=lowerCAmelCase      )      )




  def 						A__  (       self      )						->				Dict:
        '''simple docstring'''






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

        _lowercase			 =image_processor(
            [np.zeros((3, 800, 1_333)      ), np.zeros((3, 800, 1_333)      )]							,     segmentation_maps=[np.zeros((384, 384)      ).astype(np.floataa      ), np.zeros((384, 384)      ).astype(np.floataa      )]							,     return_tensors='pt'							,     )

        _lowercase			 =inputs['pixel_values'].to(lowerCAmelCase      )
        _lowercase			 =[el.to(lowerCAmelCase      ) for el in inputs['mask_labels']]
        _lowercase			 =[el.to(lowerCAmelCase      ) for el in inputs['class_labels']]

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

        self.assertTrue(outputs.loss is not None      )





import unittest

from knapsack import knapsack as k





class 				__lowerCAmelCase  (      unittest.TestCase							):




  def 						A__  (       self      )						->				List[str]:
        '''simple docstring'''






        _lowercase			 =0
        _lowercase			 =[0]
        _lowercase			 =[0]
        _lowercase			 =len(lowerCAmelCase      )
        self.assertEqual(k.knapsack(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )							,     0      )

        _lowercase			 =[60]
        _lowercase			 =[10]
        _lowercase			 =len(lowerCAmelCase      )
        self.assertEqual(k.knapsack(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )							,     0      )




  def 						A__  (       self      )						->				List[Any]:
        '''simple docstring'''






        _lowercase			 =3
        _lowercase			 =[1, 2, 3]
        _lowercase			 =[3, 2, 1]
        _lowercase			 =len(lowerCAmelCase      )
        self.assertEqual(k.knapsack(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )							,     5      )




  def 						A__  (       self      )						->				str:
        '''simple docstring'''






        _lowercase			 =50
        _lowercase			 =[60, 100, 120]
        _lowercase			 =[10, 20, 30]
        _lowercase			 =len(lowerCAmelCase      )
        self.assertEqual(k.knapsack(lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase							,     lowerCAmelCase      )							,     220      )


if __name__ == "__main__":
  unittest.main()


