from argparse import ArgumentParser

from . import BaseTransformersCLICommand




def       _snake_case	(   lowerCAmelCase							:   Any	):
		"""simple docstring"""







		return DownloadCommand(args.model   , args.cache_dir   , args.force   , args.trust_remote_code	)







class 		a__						(					A__					):

					@staticmethod
					def 				__UpperCamelCase   (    _A      :       ArgumentParser    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Optional[Any]				      =    parser.add_parser("download"    )
							download_parser.add_argument(
							    "--cache-dir",type=_snake_case,default=_snake_case,help="Path to location to store the models"    )
							download_parser.add_argument(
							    "--force",action="store_true",help="Force the model to be download even if already in cache-dir"    )
							download_parser.add_argument(
							    "--trust-remote-code",action="store_true",help="Whether or not to allow for custom models defined on the Hub in their own modeling files. Use only if you\'ve reviewed the code as it will execute on your local machine",)
							download_parser.add_argument("model",type=_snake_case,help="Name of the model to download"    )
							download_parser.set_defaults(func=_snake_case    )

					def __init__(    self      :       Tuple,_A      :       str,_A      :       str,_A      :       bool,_A      :       bool    ):







							"""simple docstring"""






							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    model
							SCREAMING_SNAKE_CASE_  :		List[str]				      =    cache
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    force
							SCREAMING_SNAKE_CASE_  :		Union[str, Any]				      =    trust_remote_code






					def 				__UpperCamelCase   (    self      :       Union[str, Any]    ):







							"""simple docstring"""






							from ..models.auto import AutoModel, AutoTokenizer

							AutoModel.from_pretrained(
							    self._model,cache_dir=self._cache,force_download=self._force,trust_remote_code=self._trust_remote_code    )
							AutoTokenizer.from_pretrained(
							    self._model,cache_dir=self._cache,force_download=self._force,trust_remote_code=self._trust_remote_code    )






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







   def __init__(      self		:						List[str]					,						_snake_case		:						Union[str, Any]					,						_snake_case		:						List[str]=2					,						_snake_case		:						Any=True					,						_snake_case		:						Any=False					,						_snake_case		:						List[str]=10					,						_snake_case		:						Any=3					,						_snake_case		:						Union[str, Any]=32 * 4					,						_snake_case		:						List[Any]=32 * 6					,						_snake_case		:						Tuple=4					,						_snake_case		:						Dict=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 lowerCamelCase						(      self		:						Any):

        """simple docstring"""


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

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

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

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







   def lowerCamelCase						(      self		:						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 lowerCamelCase						(      self		:						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 lowerCamelCase						(      self		:						str					,						_snake_case		:						List[Any]					,						_snake_case		:						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(_snake_case)					,						len(config.backbone_config.depths))
        self.parent.assertTrue(len(_snake_case)					,						len(config.backbone_config.depths))
        self.parent.assertTrue(len(_snake_case)					,						config.decoder_config.decoder_layers)







   def lowerCamelCase						(      self		:						Union[str, Any]					,						_snake_case		:						List[str]					,						_snake_case		:						int					,						_snake_case		:						Optional[Any]					,						_snake_case		:						str=False):

        """simple docstring"""


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

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







   def lowerCamelCase						(      self		:						List[Any]					,						_snake_case		:						List[Any]					,						_snake_case		:						List[Any]					,						_snake_case		:						str					,						_snake_case		:						Optional[int]					,						_snake_case		:						Union[str, Any]):

        """simple docstring"""


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

        def comm_check_on_output(_snake_case		:						Tuple):
             # 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=_snake_case					,						pixel_mask=_snake_case)
             UpperCAmelCase_          =							model(_snake_case)

             comm_check_on_output(_snake_case)

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

        comm_check_on_output(_snake_case)

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







@require_torch
class __snake_case			(			a ,  a ,  unittest.TestCase		):
   UpperCAmelCase__  :    Union[str, Any]          =  (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
   UpperCAmelCase__  :    Optional[Any]          =  (
       {'''feature-extraction''': MaskFormerModel, '''image-segmentation''': MaskFormerForInstanceSegmentation}
       if is_torch_available()
       else {}
   )

   UpperCAmelCase__  :    Dict          =  False
   UpperCAmelCase__  :    List[str]          =  False
   UpperCAmelCase__  :    Optional[Any]          =  False
   UpperCAmelCase__  :    Union[str, Any]          =  False







   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


        self.config_tester.run_common_tests()







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        UpperCAmelCase_          =							self.model_tester.prepare_config_and_inputs()
        self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*_snake_case)







   @unittest.skip(reason='''MaskFormer does not use inputs_embeds''')
   def lowerCamelCase						(      self		:						Dict):

        """simple docstring"""


        pass







   @unittest.skip(reason='''MaskFormer does not have a get_input_embeddings method''')
   def lowerCamelCase						(      self		:						int):

        """simple docstring"""


        pass







   @unittest.skip(reason='''MaskFormer is not a generative model''')
   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        pass







   @unittest.skip(reason='''MaskFormer does not use token embeddings''')
   def lowerCamelCase						(      self		:						int):

        """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 lowerCamelCase						(      self		:						Any):

        """simple docstring"""


        pass







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

        """simple docstring"""


        pass







   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


        UpperCAmelCase_     ,       UpperCAmelCase_          =							self.model_tester.prepare_config_and_inputs_for_common()

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







   @slow
   def lowerCamelCase						(      self		:						Union[str, Any]):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


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

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







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						str):

        """simple docstring"""


        UpperCAmelCase_     ,       UpperCAmelCase_          =							self.model_tester.prepare_config_and_inputs_for_common()

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







   def lowerCamelCase						(      self		:						int):

        """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(_snake_case)
        model.to(_snake_case)
        model.train()

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







   def lowerCamelCase						(      self		:						Optional[int]):

        """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(_snake_case)
        model.to(_snake_case)
        model.train()

        UpperCAmelCase_          =							model(_snake_case					,						mask_labels=_snake_case					,						class_labels=_snake_case)

        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=_snake_case)

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







snake_case_ : Dict    		=       1e-4


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







     """simple docstring"""


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







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







   @cached_property
   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


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







   def lowerCamelCase						(      self		:						List[Any]):

        """simple docstring"""


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

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

        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(_snake_case)
        self.assertTrue(
            torch.allclose(
                outputs.encoder_last_hidden_state[0, 0, :3, :3]					,						_snake_case					,						atol=_snake_case))

        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(_snake_case)
        self.assertTrue(
            torch.allclose(
                outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]					,						_snake_case					,						atol=_snake_case))

        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(_snake_case)
        self.assertTrue(
            torch.allclose(
                outputs.transformer_decoder_last_hidden_state[0, :3, :3]					,						_snake_case					,						atol=_snake_case))







   def lowerCamelCase						(      self		:						List[str]):

        """simple docstring"""


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

        with torch.no_grad():
             UpperCAmelCase_          =							model(**_snake_case)
        # 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(_snake_case).to(_snake_case)
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]					,						_snake_case					,						atol=_snake_case))
        # 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.65_12e00, -5.25_72e00, -3.35_19e00],
                [3.61_69e-02, -5.90_25e00, -2.93_13e00],
                [1.07_66e-04, -7.76_30e00, -5.12_63e00],
            ]).to(_snake_case)
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]					,						_snake_case					,						atol=_snake_case))







   def lowerCamelCase						(      self		:						Optional[Any]):

        """simple docstring"""


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

        with torch.no_grad():
             UpperCAmelCase_          =							model(**_snake_case)
        # 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(_snake_case).to(_snake_case)
        self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]					,						_snake_case					,						atol=_snake_case))
        # 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(_snake_case)
        self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]					,						_snake_case					,						atol=_snake_case))







   def lowerCamelCase						(      self		:						Tuple):

        """simple docstring"""


        UpperCAmelCase_          =							(
            MaskFormerForInstanceSegmentation.from_pretrained('''facebook/maskformer-swin-small-coco''')
            .to(_snake_case)
            .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(_snake_case)
        UpperCAmelCase_          =							[el.to(_snake_case) for el in inputs['''mask_labels''']]
        UpperCAmelCase_          =							[el.to(_snake_case) for el in inputs['''class_labels''']]

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

        self.assertTrue(outputs.loss is not None)






