

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


 def __init__(						self		: Any			,						lowerCAmelCase__		: List[Any]			,						lowerCAmelCase__		: Any=2			,						lowerCAmelCase__		: Union[str, Any]=True			,						lowerCAmelCase__		: List[Any]=False			,						lowerCAmelCase__		: Any=1_0			,						lowerCAmelCase__		: List[Any]=3			,						lowerCAmelCase__		: int=3_2 * 8			,						lowerCAmelCase__		: Union[str, Any]=3_2 * 8			,						lowerCAmelCase__		: int=4			,						lowerCAmelCase__		: Any=6_4			,						)    ->      List[Any]:
   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 _UpperCamelCase	(						self		: Any    )    ->      int:
   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 _UpperCamelCase	(						self		: Any    )    ->      Any:
   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					      =  6_4
   UpperCAmelCase					      =  1_2_8
   UpperCAmelCase					      =  self.hidden_dim
   UpperCAmelCase					      =  self.hidden_dim
   UpperCAmelCase					      =  self.hidden_dim
   return config


 def _UpperCamelCase	(						self		: Optional[int]    )    ->      Union[str, Any]:
   UpperCAmelCase					      =  self.prepare_config_and_inputs()
   UpperCAmelCase					      =  {'''pixel_values''': pixel_values, '''pixel_mask''': pixel_mask}
   return config, inputs_dict


 def _UpperCamelCase	(						self		: Dict			,						lowerCAmelCase__		: Union[str, Any]			,						lowerCAmelCase__		: Optional[int]    )    ->      Optional[Any]:
   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 _UpperCamelCase	(						self		: Optional[int]			,						lowerCAmelCase__		: Dict			,						lowerCAmelCase__		: Tuple			,						lowerCAmelCase__		: Tuple			,						lowerCAmelCase__		: int=False    )    ->      Dict:
   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 _UpperCamelCase	(						self		: List[Any]			,						lowerCAmelCase__		: Union[str, Any]			,						lowerCAmelCase__		: Optional[int]			,						lowerCAmelCase__		: Dict			,						lowerCAmelCase__		: Tuple			,						lowerCAmelCase__		: List[str]    )    ->      List[str]:
   UpperCAmelCase					      =  MaskaFormerForUniversalSegmentation(config=UpperCAmelCase__    )
   model.to(UpperCAmelCase__    )
   model.eval()

   def comm_check_on_output(lowerCAmelCase__		: Union[str, 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 						__magic_name__    (       lowercase__	,						lowercase__	,						unittest.TestCase    ):
 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 _UpperCamelCase	(						self		: Union[str, Any]    )    ->      Any:
   UpperCAmelCase					      =  MaskaFormerModelTester(self    )
   UpperCAmelCase					      =  ConfigTester(self			,						config_class=UpperCAmelCase__			,						has_text_modality=UpperCAmelCase__    )


 def _UpperCamelCase	(						self		: Optional[Any]    )    ->      List[str]:
   self.config_tester.run_common_tests()


 def _UpperCamelCase	(						self		: Optional[int]    )    ->      Any:
   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 _UpperCamelCase	(						self		: List[Any]    )    ->      List[str]:
   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 _UpperCamelCase	(						self		: Dict    )    ->      Optional[Any]:
   pass


 @unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"    )
 def _UpperCamelCase	(						self		: List[Any]    )    ->      Dict:
   pass


 @unittest.skip(reason="Mask2Former is not a generative model"    )
 def _UpperCamelCase	(						self		: List[str]    )    ->      List[Any]:
   pass


 @unittest.skip(reason="Mask2Former does not use token embeddings"    )
 def _UpperCamelCase	(						self		: Tuple    )    ->      List[Any]:
   pass


 @require_torch_multi_gpu
 @unittest.skip(
     reason="Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`"    )
 def _UpperCamelCase	(						self		: Optional[int]    )    ->      Union[str, Any]:
   pass


 @unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."    )
 def _UpperCamelCase	(						self		: int    )    ->      Tuple:
   pass


 def _UpperCamelCase	(						self		: Optional[int]    )    ->      Optional[Any]:
   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 _UpperCamelCase	(						self		: Dict    )    ->      Any:
   for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
     UpperCAmelCase					      =  MaskaFormerModel.from_pretrained(UpperCAmelCase__    )
     self.assertIsNotNone(UpperCAmelCase__    )


 def _UpperCamelCase	(						self		: Tuple    )    ->      Optional[int]:
   UpperCAmelCase					      =  (self.model_tester.min_size,) * 2
   UpperCAmelCase					      =  {
       '''pixel_values''': torch.randn((2, 3, *size)			,						device=UpperCAmelCase__    ),
       '''mask_labels''': torch.randn((2, 1_0, *size)			,						device=UpperCAmelCase__    ),
       '''class_labels''': torch.zeros(2			,						1_0			,						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 _UpperCamelCase	(						self		: List[str]    )    ->      Optional[int]:
   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 _UpperCamelCase	(						self		: List[str]    )    ->      Union[str, Any]:
   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 _UpperCamelCase	(						self		: int    )    ->      str:
   if not self.model_tester.is_training:
     return

   UpperCAmelCase					      =  self.all_model_classes[1]
   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 _UpperCamelCase	(						self		: Union[str, Any]    )    ->      List[Any]:
   UpperCAmelCase					      =  self.all_model_classes[1]
   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      _lowerCAmelCase(	):
  UpperCAmelCase					      =  Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"			)
  return image






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


 @cached_property
 def _UpperCamelCase	(						self		: Dict    )    ->      Optional[Any]:
   return "facebook/mask2former-swin-small-coco-instance"


 @cached_property
 def _UpperCamelCase	(						self		: Union[str, Any]    )    ->      Any:
   return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints    ) if is_vision_available() else None


 def _UpperCamelCase	(						self		: List[Any]    )    ->      List[Any]:
   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] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0    )
   # check size
   self.assertEqual(UpperCAmelCase__			,						(1, 3, 3_8_4, 3_8_4)    )

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

   UpperCAmelCase					      =  torch.tensor(
       [[-0.2_790, -1.0_717, -1.1_668], [-0.5_128, -0.3_128, -0.4_987], [-0.5_832, 0.1_971, -0.0_197]]    ).to(UpperCAmelCase__    )
   self.assertTrue(
       torch.allclose(
           outputs.encoder_last_hidden_state[0, 0, :3, :3]			,						UpperCAmelCase__			,						atol=UpperCAmelCase__    )    )

   UpperCAmelCase					      =  torch.tensor(
       [[0.8_973, 1.1_847, 1.1_776], [1.1_934, 1.5_040, 1.5_128], [1.1_153, 1.4_486, 1.4_951]]    ).to(UpperCAmelCase__    )
   self.assertTrue(
       torch.allclose(
           outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]			,						UpperCAmelCase__			,						atol=UpperCAmelCase__    )    )

   UpperCAmelCase					      =  torch.tensor(
       [[2.1_152, 1.7_000, -0.8_603], [1.5_808, 1.8_004, -0.9_353], [1.6_043, 1.7_495, -0.5_999]]    ).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[Any]:
   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] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0    )
   # check size
   self.assertEqual(UpperCAmelCase__			,						(1, 3, 3_8_4, 3_8_4)    )

   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.7_839, -9.0_056, -8.8_121],
       [-7.4_104, -7.0_313, -6.5_401],
       [-6.6_105, -6.3_427, -6.4_675],
   ]
   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.8_324, -8.0_835, -4.1_922],
           [0.8_450, -9.0_050, -3.6_053],
           [0.3_045, -7.7_293, -3.0_275],
       ]    ).to(UpperCAmelCase__    )
   self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]			,						UpperCAmelCase__			,						atol=UpperCAmelCase__    )    )


 def _UpperCamelCase	(						self		: Tuple    )    ->      Union[str, Any]:
   UpperCAmelCase					      =  MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints    ).to(UpperCAmelCase__    ).eval()
   UpperCAmelCase					      =  self.default_image_processor

   UpperCAmelCase					      =  image_processor(
       [np.zeros((3, 8_0_0, 1_3_3_3)    ), np.zeros((3, 8_0_0, 1_3_3_3)    )]			,						segmentation_maps=[np.zeros((3_8_4, 3_8_4)    ).astype(np.floataa    ), np.zeros((3_8_4, 3_8_4)    ).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    )







def      _lowerCAmelCase(	__A   ,       __A			):
  return (pointa[0] - pointa[0]) ** 2 + (pointa[1] - pointa[1]) ** 2
def      _lowerCAmelCase(	__A   ,       __A=0			):
  return sorted(__A   ,       key=lambda __A			: x[column]			)
def      _lowerCAmelCase(	__A   ,       __A   ,       __A=float("inf"			)			):

  for i in range(points_counts - 1			):
    for j in range(i + 1   ,       __A			):
      UpperCAmelCase					      =  euclidean_distance_sqr(points[i]   ,       points[j]			)
      if current_dis < min_dis:
        UpperCAmelCase					      =  current_dis
  return min_dis
def      _lowerCAmelCase(	__A   ,       __A   ,       __A=float("inf"			)			):

  for i in range(min(6   ,       points_counts - 1			)   ,       __A			):
    for j in range(max(0   ,       i - 6			)   ,       __A			):
      UpperCAmelCase					      =  euclidean_distance_sqr(points[i]   ,       points[j]			)
      if current_dis < min_dis:
        UpperCAmelCase					      =  current_dis
  return min_dis
def      _lowerCAmelCase(	__A   ,       __A   ,       __A			):

  # base case
  if points_counts <= 3:
    return dis_between_closest_pair(__A   ,       __A			)

  # recursion
  UpperCAmelCase					      =  points_counts // 2
  UpperCAmelCase					      =  closest_pair_of_points_sqr(
      __A   ,       points_sorted_on_y[:mid]   ,       __A			)
  UpperCAmelCase					      =  closest_pair_of_points_sqr(
      __A   ,       points_sorted_on_y[mid:]   ,       points_counts - mid			)
  UpperCAmelCase					      =  min(__A   ,       __A			)
  UpperCAmelCase					      =  []
  for point in points_sorted_on_x:
    if abs(point[0] - points_sorted_on_x[mid][0]			) < closest_pair_dis:
      cross_strip.append(__A			)

  UpperCAmelCase					      =  dis_between_closest_in_strip(
      __A   ,       len(__A			)   ,       __A			)
  return min(__A   ,       __A			)
def      _lowerCAmelCase(	__A   ,       __A			):
  UpperCAmelCase					      =  column_based_sort(__A   ,       column=0			)
  UpperCAmelCase					      =  column_based_sort(__A   ,       column=1			)
  return (
      closest_pair_of_points_sqr(
          __A   ,       __A   ,       __A			)
  ) ** 0.5


if __name__ == "__main__":
      lowerCAmelCase__       = [(2, 3), (12, 30), (40, 50), (5, 1), (12, 10), (3, 4)]
      print("Distance:", closest_pair_of_points(points, len(points)))



