




'''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      lowerCAmelCase :


       def __init__( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=2     ,	__SCREAMING_SNAKE_CASE=True     ,	__SCREAMING_SNAKE_CASE=False     ,	__SCREAMING_SNAKE_CASE=10     ,	__SCREAMING_SNAKE_CASE=3     ,	__SCREAMING_SNAKE_CASE=32 * 4     ,	__SCREAMING_SNAKE_CASE=32 * 6     ,	__SCREAMING_SNAKE_CASE=4     ,	__SCREAMING_SNAKE_CASE=32     ,	)   ->	Any:



            '''simple docstring'''




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


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]	).to(
                __SCREAMING_SNAKE_CASE	)

            __snake_case            =	torch.ones([self.batch_size, self.min_size, self.max_size]     ,	device=__SCREAMING_SNAKE_CASE	)

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

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


       def    lowerCAmelCase   ( self	)   ->	Tuple:



            '''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	)   ->	Any:



            '''simple docstring'''




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


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Tuple:



            '''simple docstring'''




            __snake_case            =	output.encoder_hidden_states
            __snake_case            =	output.pixel_decoder_hidden_states
            __snake_case            =	output.transformer_decoder_hidden_states

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


       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE=False	)   ->	Any:



            '''simple docstring'''




            with torch.no_grad():
                 __snake_case            =	MaskFormerModel(config=__SCREAMING_SNAKE_CASE	)
                 model.to(__SCREAMING_SNAKE_CASE	)
                 model.eval()

                 __snake_case            =	model(pixel_values=__SCREAMING_SNAKE_CASE     ,	pixel_mask=__SCREAMING_SNAKE_CASE	)
                 __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	output_hidden_states=__SCREAMING_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(__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)




       def    lowerCAmelCase   ( self     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE     ,	__SCREAMING_SNAKE_CASE	)   ->	Optional[Any]:



            '''simple docstring'''




            __snake_case            =	MaskFormerForInstanceSegmentation(config=__SCREAMING_SNAKE_CASE	)
            model.to(__SCREAMING_SNAKE_CASE	)
            model.eval()

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

                 comm_check_on_output(__SCREAMING_SNAKE_CASE	)

                 __snake_case            =	model(
                     pixel_values=__SCREAMING_SNAKE_CASE     ,	pixel_mask=__SCREAMING_SNAKE_CASE     ,	mask_labels=__SCREAMING_SNAKE_CASE     ,	class_labels=__SCREAMING_SNAKE_CASE	)

            comm_check_on_output(__SCREAMING_SNAKE_CASE	)

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





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

       __lowercase	:   Any										=      False
       __lowercase	:   Any										=      False
       __lowercase	:   Optional[Any]										=      False
       __lowercase	:   Optional[Any]										=      False


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            __snake_case            =	MaskFormerModelTester(self	)
            __snake_case            =	ConfigTester(self     ,	config_class=__SCREAMING_SNAKE_CASE     ,	has_text_modality=__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	List[Any]:



            '''simple docstring'''




            self.config_tester.run_common_tests()


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()
            self.model_tester.create_and_check_maskformer_model(__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE     ,	output_hidden_states=__SCREAMING_SNAKE_CASE	)


       def    lowerCAmelCase   ( self	)   ->	Optional[Any]:



            '''simple docstring'''




            __snake_case            =	self.model_tester.prepare_config_and_inputs()
            self.model_tester.create_and_check_maskformer_instance_segmentation_head_model(*__SCREAMING_SNAKE_CASE	)


       @unittest.skip(reason='''MaskFormer does not use inputs_embeds'''	)
       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            pass


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



            '''simple docstring'''




            pass


       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()

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

                 __snake_case            =	['''pixel_values''']
                 self.assertListEqual(arg_names[:1]     ,	__SCREAMING_SNAKE_CASE	)


       @slow
       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




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


       def    lowerCAmelCase   ( self	)   ->	Any:



            '''simple docstring'''




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

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


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



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()
            self.model_tester.create_and_check_maskformer_model(__SCREAMING_SNAKE_CASE     ,	**__SCREAMING_SNAKE_CASE     ,	output_hidden_states=__SCREAMING_SNAKE_CASE	)


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



            '''simple docstring'''




            __snake_case       ,     __snake_case            =	self.model_tester.prepare_config_and_inputs_for_common()

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


       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




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

            __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
            model.to(__SCREAMING_SNAKE_CASE	)
            model.train()

            __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	mask_labels=__SCREAMING_SNAKE_CASE     ,	class_labels=__SCREAMING_SNAKE_CASE	).loss
            loss.backward()




       def    lowerCAmelCase   ( self	)   ->	Optional[int]:



            '''simple docstring'''




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

            __snake_case            =	model_class(__SCREAMING_SNAKE_CASE	)
            model.to(__SCREAMING_SNAKE_CASE	)
            model.train()

            __snake_case            =	model(__SCREAMING_SNAKE_CASE     ,	mask_labels=__SCREAMING_SNAKE_CASE     ,	class_labels=__SCREAMING_SNAKE_CASE	)

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

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

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

            outputs.loss.backward(retain_graph=__SCREAMING_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	)





UpperCAmelCase_							:	List[str]	     =		1E-4







def       _UpperCamelCase			()-> str:




     '''simple docstring'''





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







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


       @cached_property
       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




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


       def    lowerCAmelCase   ( self	)   ->	Dict:



            '''simple docstring'''




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

            with torch.no_grad():
                 __snake_case            =	model(**__SCREAMING_SNAKE_CASE	)

            __snake_case            =	torch.tensor(
                [[-0.0_482, 0.9_228, 0.4_951], [-0.2_547, 0.8_017, 0.8_527], [-0.0_069, 0.3_385, -0.0_089]]	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(
                torch.allclose(
                    outputs.encoder_last_hidden_state[0, 0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)

            __snake_case            =	torch.tensor(
                [[-0.8_422, -0.8_434, -0.9_718], [-1.0_144, -0.5_565, -0.4_195], [-1.0_038, -0.4_484, -0.1_961]]	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(
                torch.allclose(
                    outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)

            __snake_case            =	torch.tensor(
                [[0.2_852, -0.0_159, 0.9_735], [0.6_254, 0.1_858, 0.8_529], [-0.0_680, -0.4_116, 1.8_413]]	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(
                torch.allclose(
                    outputs.transformer_decoder_last_hidden_state[0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)


       def    lowerCAmelCase   ( self	)   ->	int:



            '''simple docstring'''




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

            with torch.no_grad():
                 __snake_case            =	model(**__SCREAMING_SNAKE_CASE	)
            # masks_queries_logits
            __snake_case            =	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)     ,	)
            __snake_case            =	[
                [-1.3_737_124, -1.7_724_937, -1.9_364_233],
                [-1.5_977_281, -1.9_867_939, -2.1_523_695],
                [-1.5_795_398, -1.9_269_832, -2.093_942],
            ]
            __snake_case            =	torch.tensor(__SCREAMING_SNAKE_CASE	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)
            # class_queries_logits
            __snake_case            =	outputs.class_queries_logits
            self.assertEqual(
                class_queries_logits.shape     ,	(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)	)
            __snake_case            =	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(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)


       def    lowerCAmelCase   ( self	)   ->	str:



            '''simple docstring'''




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

            with torch.no_grad():
                 __snake_case            =	model(**__SCREAMING_SNAKE_CASE	)
            # masks_queries_logits
            __snake_case            =	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)     ,	)
            __snake_case            =	[[-0.9_046, -2.6_366, -4.6_062], [-3.4_179, -5.7_890, -8.8_057], [-4.9_179, -7.6_560, -10.7_711]]
            __snake_case            =	torch.tensor(__SCREAMING_SNAKE_CASE	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)
            # class_queries_logits
            __snake_case            =	outputs.class_queries_logits
            self.assertEqual(
                class_queries_logits.shape     ,	(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)	)
            __snake_case            =	torch.tensor(
                [[4.7_188, -3.2_585, -2.8_857], [6.6_871, -2.9_181, -1.2_487], [7.2_449, -2.2_764, -2.1_874]]	).to(__SCREAMING_SNAKE_CASE	)
            self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]     ,	__SCREAMING_SNAKE_CASE     ,	atol=__SCREAMING_SNAKE_CASE	)	)




       def    lowerCAmelCase   ( self	)   ->	List[str]:



            '''simple docstring'''




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

            __snake_case            =	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'''     ,	)

            __snake_case            =	inputs['''pixel_values'''].to(__SCREAMING_SNAKE_CASE	)
            __snake_case            =	[el.to(__SCREAMING_SNAKE_CASE	) for el in inputs['''mask_labels''']]
            __snake_case            =	[el.to(__SCREAMING_SNAKE_CASE	) for el in inputs['''class_labels''']]

            with torch.no_grad():
                 __snake_case            =	model(**__SCREAMING_SNAKE_CASE	)

            self.assertTrue(outputs.loss is not None	)













from ...configuration_utils import PretrainedConfig
from ...utils import logging


UpperCAmelCase_							=				logging.get_logger(__name__)

UpperCAmelCase_							=				{
    """google/canine-s""": """https://huggingface.co/google/canine-s/resolve/main/config.json""",
    # See all CANINE models at https://huggingface.co/models?filter=canine
}
class     UpperCamelCase__					(     lowerCamelCase__				):






		'''simple docstring'''






		__a       :       Optional[int]       =	"""canine"""






		def __init__(							self,   snake_case__=7_68,   snake_case__=12,   snake_case__=12,   snake_case__=30_72,   snake_case__="gelu",   snake_case__=0.1,   snake_case__=0.1,   snake_case__=1_63_84,   snake_case__=16,   snake_case__=0.02,   snake_case__=1E-12,   snake_case__=0,   snake_case__=0XE_0_0_0,   snake_case__=0XE_0_0_1,   snake_case__=4,   snake_case__=4,   snake_case__=8,   snake_case__=1_63_84,   snake_case__=1_28,   **snake_case__,   )       -> Optional[int]:






									"""simple docstring"""
									super().__init__(pad_token_id=snake_case__,   bos_token_id=snake_case__,   eos_token_id=snake_case__,   **snake_case__  )

									lowercase_	:   int  				=     max_position_embeddings
									lowercase_	:   Union[str, Any]  				=     hidden_size
									lowercase_	:   Optional[Any]  				=     num_hidden_layers
									lowercase_	:   str  				=     num_attention_heads
									lowercase_	:   List[Any]  				=     intermediate_size
									lowercase_	:   Optional[Any]  				=     hidden_act
									lowercase_	:   List[str]  				=     hidden_dropout_prob
									lowercase_	:   Any  				=     attention_probs_dropout_prob
									lowercase_	:   Union[str, Any]  				=     initializer_range
									lowercase_	:   Optional[Any]  				=     type_vocab_size
									lowercase_	:   Dict  				=     layer_norm_eps

									# Character config:
									lowercase_	:   Optional[int]  				=     downsampling_rate
									lowercase_	:   List[str]  				=     upsampling_kernel_size
									lowercase_	:   int  				=     num_hash_functions
									lowercase_	:   List[str]  				=     num_hash_buckets
									lowercase_	:   List[str]  				=     local_transformer_stride