



"""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    :						Any	,       _UpperCAmelCase    :						Optional[Any]	,       _UpperCAmelCase    :						Any=2	,       _UpperCAmelCase    :						Tuple=True	,       _UpperCAmelCase    :						Dict=False	,       _UpperCAmelCase    :						int=10	,       _UpperCAmelCase    :						Optional[Any]=3	,       _UpperCAmelCase    :						Union[str, Any]=32 * 4	,       _UpperCAmelCase    :						Dict=32 * 6	,       _UpperCAmelCase    :						List[Any]=4	,       _UpperCAmelCase    :						Union[str, Any]=32	,       )				->		str:


             '''simple docstring'''




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



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


             '''simple docstring'''




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

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

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

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



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


             '''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   lowercase__       (							self    :						Any					)				->		int:


             '''simple docstring'''




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



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


             '''simple docstring'''




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

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



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


             '''simple docstring'''




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

                   UpperCAmelCase_    				=							model(pixel_values=_UpperCAmelCase	,       pixel_mask=_UpperCAmelCase					)
                   UpperCAmelCase_    				=							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   lowercase__       (							self    :						List[str]	,       _UpperCAmelCase    :						Any	,       _UpperCAmelCase    :						str	,       _UpperCAmelCase    :						int	,       _UpperCAmelCase    :						str	,       _UpperCAmelCase    :						Dict					)				->		int:


             '''simple docstring'''




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

             def comm_check_on_output(_UpperCAmelCase    :						List[Any]					):
                   # let's still check that all the required stuff is there
                   self.parent.assertTrue(result.transformer_decoder_last_hidden_state is not None					)
                   self.parent.assertTrue(result.pixel_decoder_last_hidden_state is not None					)
                   self.parent.assertTrue(result.encoder_last_hidden_state is not None					)
                   # okay, now we need to check the logits shape
                   # due to the encoder compression, masks have a //4 spatial size
                   self.parent.assertEqual(
                       result.masks_queries_logits.shape	,       (self.batch_size, self.num_queries, self.min_size // 4, self.max_size // 4)	,       )
                   # + 1 for null class
                   self.parent.assertEqual(
                       result.class_queries_logits.shape	,       (self.batch_size, self.num_queries, self.num_labels + 1)					)

             with torch.no_grad():
                   UpperCAmelCase_    				=							model(pixel_values=_UpperCAmelCase	,       pixel_mask=_UpperCAmelCase					)
                   UpperCAmelCase_    				=							model(_UpperCAmelCase					)

                   comm_check_on_output(_UpperCAmelCase					)

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

             comm_check_on_output(_UpperCAmelCase					)

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



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







       '''simple docstring'''


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

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



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


             '''simple docstring'''




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



       def   lowercase__       (							self    :						str					)				->		str:


             '''simple docstring'''




             self.config_tester.run_common_tests()



       def   lowercase__       (							self    :						Dict					)				->		Dict:


             '''simple docstring'''




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



       def   lowercase__       (							self    :						Dict					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							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   lowercase__       (							self    :						Any					)				->		Tuple:


             '''simple docstring'''




             pass



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


             '''simple docstring'''




             pass



       @unittest.skip(reason="MaskFormer is not a generative model"					)
       def   lowercase__       (							self    :						Any					)				->		Union[str, Any]:


             '''simple docstring'''




             pass



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


             '''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   lowercase__       (							self    :						Any					)				->		str:


             '''simple docstring'''




             pass



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


             '''simple docstring'''




             pass



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


             '''simple docstring'''




             UpperCAmelCase_				,					UpperCAmelCase_    				=							self.model_tester.prepare_config_and_inputs_for_common()

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

                   UpperCAmelCase_    				=							["pixel_values"]
                   self.assertListEqual(arg_names[:1]	,       _UpperCAmelCase					)



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


             '''simple docstring'''




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



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


             '''simple docstring'''




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

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



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


             '''simple docstring'''




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



       def   lowercase__       (							self    :						Dict					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_				,					UpperCAmelCase_    				=							self.model_tester.prepare_config_and_inputs_for_common()

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



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


             '''simple docstring'''




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

             UpperCAmelCase_    				=							model_class(_UpperCAmelCase					)
             model.to(_UpperCAmelCase					)
             model.train()

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







       def   lowercase__       (							self    :						Tuple					)				->		str:


             '''simple docstring'''




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

             UpperCAmelCase_    				=							model_class(_UpperCAmelCase					)
             model.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()
             # 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=_UpperCAmelCase					)

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



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


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







       '''simple docstring'''


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


             '''simple docstring'''




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



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


             '''simple docstring'''




             UpperCAmelCase_    				=							MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco"					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							self.default_image_processor
             UpperCAmelCase_    				=							prepare_img()
             UpperCAmelCase_    				=							image_processor(_UpperCAmelCase	,       return_tensors="pt"					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							inputs["pixel_values"].shape
             # check size is divisible by 32
             self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
             # check size
             self.assertEqual(_UpperCAmelCase	,       (1, 3, 800, 1088)					)

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

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

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

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



       def   lowercase__       (							self    :						Any					)				->		int:


             '''simple docstring'''




             UpperCAmelCase_    				=							(
                 MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"					)
                 .to(_UpperCAmelCase					)
                 .eval()
             )
             UpperCAmelCase_    				=							self.default_image_processor
             UpperCAmelCase_    				=							prepare_img()
             UpperCAmelCase_    				=							image_processor(_UpperCAmelCase	,       return_tensors="pt"					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							inputs["pixel_values"].shape
             # check size is divisible by 32
             self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
             # check size
             self.assertEqual(_UpperCAmelCase	,       (1, 3, 800, 1088)					)

             with torch.no_grad():
                   UpperCAmelCase_    				=							model(**_UpperCAmelCase					)
             # 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.373_7124, -1.772_4937, -1.936_4233],
                 [-1.597_7281, -1.986_7939, -2.152_3695],
                 [-1.579_5398, -1.926_9832, -2.09_3942],
             ]
             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.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(_UpperCAmelCase					)
             self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]	,       _UpperCAmelCase	,       atol=_UpperCAmelCase					)					)



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


             '''simple docstring'''




             UpperCAmelCase_    				=							(
                 MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff"					)
                 .to(_UpperCAmelCase					)
                 .eval()
             )
             UpperCAmelCase_    				=							self.default_image_processor
             UpperCAmelCase_    				=							prepare_img()
             UpperCAmelCase_    				=							image_processor(_UpperCAmelCase	,       return_tensors="pt"					).to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							inputs["pixel_values"].shape
             # check size is divisible by 32
             self.assertTrue((inputs_shape[-1] % 32) == 0 and (inputs_shape[-2] % 32) == 0					)
             # check size
             self.assertEqual(_UpperCAmelCase	,       (1, 3, 800, 1088)					)

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







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


             '''simple docstring'''




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

             UpperCAmelCase_    				=							image_processor(
                 [np.zeros((3, 800, 1333)					), np.zeros((3, 800, 1333)					)]	,       segmentation_maps=[np.zeros((384, 384)					).astype(np.floataa					), np.zeros((384, 384)					).astype(np.floataa					)]	,       return_tensors="pt"	,       )

             UpperCAmelCase_    				=							inputs["pixel_values"].to(_UpperCAmelCase					)
             UpperCAmelCase_    				=							[el.to(_UpperCAmelCase					) for el in inputs["mask_labels"]]
             UpperCAmelCase_    				=							[el.to(_UpperCAmelCase					) for el in inputs["class_labels"]]

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

             self.assertTrue(outputs.loss is not None					)









"""simple docstring"""





import colorsys

from PIL import Image  # type: ignore
def      a__			(   lowerCAmelCase__			,    lowerCAmelCase__			,    lowerCAmelCase__   ):
      UpperCAmelCase_    				=							x
      UpperCAmelCase_    				=							y
      for step in range(lowerCAmelCase__   ):  # noqa: B007
            UpperCAmelCase_    				=							a * a - b * b + x
            UpperCAmelCase_    				=							2 * a * b + y
            UpperCAmelCase_    				=							a_new

            # divergence happens for all complex number with an absolute value
            # greater than 4
            if a * a + b * b > 4:
                  break
      return step / (max_step - 1)
def      a__			(   lowerCAmelCase__   ):
      if distance == 1:
            return (0, 0, 0)
      else:
            return (255, 255, 255)
def      a__			(   lowerCAmelCase__   ):
      if distance == 1:
            return (0, 0, 0)
      else:
            return tuple(round(i * 255   ) for i in colorsys.hsv_to_rgb(lowerCAmelCase__			,    1			,    1   )   )
def      a__			(   lowerCAmelCase__ = 800			,    lowerCAmelCase__ = 600			,    lowerCAmelCase__ = -0.6			,    lowerCAmelCase__ = 0			,    lowerCAmelCase__ = 3.2			,    lowerCAmelCase__ = 50			,    lowerCAmelCase__ = True			,    ):
      UpperCAmelCase_    				=							Image.new("RGB"			,    (image_width, image_height)   )
      UpperCAmelCase_    				=							img.load()

      # loop through the image-coordinates
      for image_x in range(lowerCAmelCase__   ):
            for image_y in range(lowerCAmelCase__   ):
                  # determine the figure-coordinates based on the image-coordinates
                  UpperCAmelCase_    				=							figure_width / image_width * image_height
                  UpperCAmelCase_    				=							figure_center_x + (image_x / image_width - 0.5) * figure_width
                  UpperCAmelCase_    				=							figure_center_y + (image_y / image_height - 0.5) * figure_height

                  UpperCAmelCase_    				=							get_distance(lowerCAmelCase__			,    lowerCAmelCase__			,    lowerCAmelCase__   )

                  # color the corresponding pixel based on the selected coloring-function
                  if use_distance_color_coding:
                        UpperCAmelCase_    				=							get_color_coded_rgb(lowerCAmelCase__   )
                  else:
                        UpperCAmelCase_    				=							get_black_and_white_rgb(lowerCAmelCase__   )

      return img


if __name__ == "__main__":
  import doctest

  doctest.testmod()

  # colored version, full figure
  lowerCamelCase      =		get_image()

  # uncomment for colored version, different section, zoomed in
  # img = get_image(figure_center_x = -0.6, figure_center_y = -0.4,
  # figure_width = 0.8)

  # uncomment for black and white version, full figure
  # img = get_image(use_distance_color_coding = False)

  # uncomment to save the image
  # img.save("mandelbrot.png")

  img.show()




