






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


						'''simple docstring'''




						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		,				) ->				int:
								snake_case_				:							List[Any]						 =       parent
								snake_case_				:							str						 =       batch_size
								snake_case_				:							Any						 =       is_training
								snake_case_				:							Optional[Any]						 =       use_auxiliary_loss
								snake_case_				:							Union[str, Any]						 =       num_queries
								snake_case_				:							List[str]						 =       num_channels
								snake_case_				:							Tuple						 =       min_size
								snake_case_				:							Dict						 =       max_size
								snake_case_				:							Union[str, Any]						 =       num_labels
								snake_case_				:							List[str]						 =       mask_feature_size






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								snake_case_				:							List[Any]						 =       floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]				).to(
								    _SCREAMING_SNAKE_CASE				)

								snake_case_				:							List[Any]						 =       torch.ones([self.batch_size, self.min_size, self.max_size]		,				device=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							Dict						 =       (
								    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]		,				device=_SCREAMING_SNAKE_CASE				) > 0.5
								).float()
								snake_case_				:							str						 =       (torch.rand((self.batch_size, self.num_labels)		,				device=_SCREAMING_SNAKE_CASE				) > 0.5).long()

								snake_case_				:							str						 =       self.get_config()
								return config, pixel_values, pixel_mask, mask_labels, class_labels






						def       _lowerCAmelCase       (	self				) ->				Optional[int]:
								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				) ->				Dict:
								snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_				:							List[str]						 =       self.prepare_config_and_inputs()
								snake_case_				:							Dict						 =       {"pixel_values": pixel_values, "pixel_mask": pixel_mask}
								return config, inputs_dict






						def       _lowerCAmelCase       (	self		,				_SCREAMING_SNAKE_CASE		,				_SCREAMING_SNAKE_CASE				) ->				List[str]:
								snake_case_				:							Any						 =       output.encoder_hidden_states
								snake_case_				:							Tuple						 =       output.pixel_decoder_hidden_states
								snake_case_				:							str						 =       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				) ->				List[Any]:
								with torch.no_grad():
										snake_case_				:							List[str]						 =       MaskFormerModel(config=_SCREAMING_SNAKE_CASE				)
										model.to(_SCREAMING_SNAKE_CASE				)
										model.eval()

										snake_case_				:							Any						 =       model(pixel_values=_SCREAMING_SNAKE_CASE		,				pixel_mask=_SCREAMING_SNAKE_CASE				)
										snake_case_				:							Union[str, Any]						 =       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				) ->				Tuple:
								snake_case_				:							Optional[Any]						 =       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_				:							Optional[int]						 =       model(pixel_values=_SCREAMING_SNAKE_CASE		,				pixel_mask=_SCREAMING_SNAKE_CASE				)
										snake_case_				:							str						 =       model(_SCREAMING_SNAKE_CASE				)

										comm_check_on_output(_SCREAMING_SNAKE_CASE				)

										snake_case_				:							Any						 =       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 		UpperCAmelCase_						(	SCREAMING_SNAKE_CASE__					,  SCREAMING_SNAKE_CASE__					,  unittest.TestCase					):


						'''simple docstring'''




						A     :   Optional[Any]						=					(MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
						A     :   Optional[Any]						=					(
						    {'feature-extraction': MaskFormerModel, 'image-segmentation': MaskFormerForInstanceSegmentation}
						    if is_torch_available()
						    else {}
						)

						A     :   Any						=					False
						A     :   Dict						=					False
						A     :   Tuple						=					False
						A     :   str						=					False






						def       _lowerCAmelCase       (	self				) ->				Tuple:
								snake_case_				:							int						 =       MaskFormerModelTester(self				)
								snake_case_				:							List[Any]						 =       ConfigTester(self		,				config_class=_SCREAMING_SNAKE_CASE		,				has_text_modality=_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				Optional[int]:
								self.config_tester.run_common_tests()






						def       _lowerCAmelCase       (	self				) ->				Tuple:
								snake_case_ ,       snake_case_				:							Optional[Any]						 =       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				) ->				Tuple:
								snake_case_				:							Optional[Any]						 =       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				) ->				Tuple:
								pass






						@unittest.skip(reason="MaskFormer does not have a get_input_embeddings method"				)
						def       _lowerCAmelCase       (	self				) ->				str:
								pass






						@unittest.skip(reason="MaskFormer is not a generative model"				)
						def       _lowerCAmelCase       (	self				) ->				Optional[int]:
								pass






						@unittest.skip(reason="MaskFormer does not use token embeddings"				)
						def       _lowerCAmelCase       (	self				) ->				Optional[int]:
								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				) ->				Optional[Any]:
								pass






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






						def       _lowerCAmelCase       (	self				) ->				Union[str, Any]:
								snake_case_ ,       snake_case_				:							Optional[int]						 =       self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case_				:							int						 =       model_class(_SCREAMING_SNAKE_CASE				)
										snake_case_				:							List[Any]						 =       inspect.signature(model.forward				)
										# signature.parameters is an OrderedDict => so arg_names order is deterministic
										snake_case_				:							Optional[int]						 =       [*signature.parameters.keys()]

										snake_case_				:							Optional[int]						 =       ["pixel_values"]
										self.assertListEqual(arg_names[:1]		,				_SCREAMING_SNAKE_CASE				)






						@slow
						def       _lowerCAmelCase       (	self				) ->				Optional[Any]:
								for model_name in ["facebook/maskformer-swin-small-coco"]:
										snake_case_				:							List[Any]						 =       MaskFormerModel.from_pretrained(_SCREAMING_SNAKE_CASE				)
										self.assertIsNotNone(_SCREAMING_SNAKE_CASE				)






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								snake_case_				:							Dict						 =       (self.model_tester.min_size,) * 2
								snake_case_				:							Dict						 =       {
								    "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_				:							int						 =       MaskFormerForInstanceSegmentation(MaskFormerConfig()				).to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Optional[int]						 =       model(**_SCREAMING_SNAKE_CASE				)
								self.assertTrue(outputs.loss is not None				)






						def       _lowerCAmelCase       (	self				) ->				int:
								snake_case_ ,       snake_case_				:							Any						 =       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				) ->				Tuple:
								snake_case_ ,       snake_case_				:							Optional[int]						 =       self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
										snake_case_				:							List[Any]						 =       model_class(_SCREAMING_SNAKE_CASE				).to(_SCREAMING_SNAKE_CASE				)
										snake_case_				:							List[Any]						 =       model(**_SCREAMING_SNAKE_CASE		,				output_attentions=_SCREAMING_SNAKE_CASE				)
										self.assertTrue(outputs.attentions is not None				)






						def       _lowerCAmelCase       (	self				) ->				List[str]:
								if not self.model_tester.is_training:
										return
								# only MaskFormerForInstanceSegmentation has the loss
								snake_case_				:							int						 =       self.all_model_classes[1]
								snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_				:							Union[str, Any]						 =       self.model_tester.prepare_config_and_inputs()

								snake_case_				:							Optional[int]						 =       model_class(_SCREAMING_SNAKE_CASE				)
								model.to(_SCREAMING_SNAKE_CASE				)
								model.train()

								snake_case_				:							Tuple						 =       model(_SCREAMING_SNAKE_CASE		,				mask_labels=_SCREAMING_SNAKE_CASE		,				class_labels=_SCREAMING_SNAKE_CASE				).loss
								loss.backward()






						def       _lowerCAmelCase       (	self				) ->				Dict:
								# only MaskFormerForInstanceSegmentation has the loss
								snake_case_				:							Optional[Any]						 =       self.all_model_classes[1]
								snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_ ,       snake_case_				:							Dict						 =       self.model_tester.prepare_config_and_inputs()
								snake_case_				:							Tuple						 =       True
								snake_case_				:							Union[str, Any]						 =       True

								snake_case_				:							Union[str, Any]						 =       model_class(_SCREAMING_SNAKE_CASE				)
								model.to(_SCREAMING_SNAKE_CASE				)
								model.train()

								snake_case_				:							Optional[int]						 =       model(_SCREAMING_SNAKE_CASE		,				mask_labels=_SCREAMING_SNAKE_CASE		,				class_labels=_SCREAMING_SNAKE_CASE				)

								snake_case_				:							int						 =       outputs.encoder_hidden_states[0]
								encoder_hidden_states.retain_grad()

								snake_case_				:							List[Any]						 =       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_				:							Optional[Any]						 =       outputs.transformer_decoder_hidden_states[0]
								transformer_decoder_hidden_states.retain_grad()

								snake_case_				:							Tuple						 =       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				)




lowercase  :							Dict			  =    1e-4

def      lowerCAmelCase__	(    ):
		snake_case_				:							Any						 =       Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"    )
		return image




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


						'''simple docstring'''




						@cached_property
						def       _lowerCAmelCase       (	self				) ->				Union[str, Any]:
								return (
								    MaskFormerImageProcessor.from_pretrained("facebook/maskformer-swin-small-coco"				)
								    if is_vision_available()
								    else None
								)






						def       _lowerCAmelCase       (	self				) ->				List[Any]:
								snake_case_				:							str						 =       MaskFormerModel.from_pretrained("facebook/maskformer-swin-small-coco"				).to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Union[str, Any]						 =       self.default_image_processor
								snake_case_				:							str						 =       prepare_img()
								snake_case_				:							Any						 =       image_processor(_SCREAMING_SNAKE_CASE		,				return_tensors="pt"				).to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Dict						 =       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_				:							Optional[int]						 =       model(**_SCREAMING_SNAKE_CASE				)

								snake_case_				:							List[Any]						 =       torch.tensor(
								    [[-0.0482, 0.9228, 0.4951], [-0.2547, 0.8017, 0.8527], [-0.0069, 0.3385, -0.0089]]				).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_				:							Tuple						 =       torch.tensor(
								    [[-0.8422, -0.8434, -0.9718], [-1.0144, -0.5565, -0.4195], [-1.0038, -0.4484, -0.1961]]				).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_				:							int						 =       torch.tensor(
								    [[0.2852, -0.0159, 0.9735], [0.6254, 0.1858, 0.8529], [-0.0680, -0.4116, 1.8413]]				).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				) ->				Optional[Any]:
								snake_case_				:							Optional[Any]						 =       (
								    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"				)
								    .to(_SCREAMING_SNAKE_CASE				)
								    .eval()
								)
								snake_case_				:							int						 =       self.default_image_processor
								snake_case_				:							List[Any]						 =       prepare_img()
								snake_case_				:							Any						 =       image_processor(_SCREAMING_SNAKE_CASE		,				return_tensors="pt"				).to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							Dict						 =       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_				:							Optional[Any]						 =       model(**_SCREAMING_SNAKE_CASE				)
								# masks_queries_logits
								snake_case_				:							Any						 =       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_				:							Union[str, Any]						 =       [
								    [-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],
								]
								snake_case_				:							Optional[int]						 =       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_				:							List[str]						 =       outputs.class_queries_logits
								self.assertEqual(
								    class_queries_logits.shape		,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)				)
								snake_case_				:							Optional[int]						 =       torch.tensor(
								    [
								        [1.6512e00, -5.2572e00, -3.3519e00],
								        [3.6169e-02, -5.9025e00, -2.9313e00],
								        [1.0766e-04, -7.7630e00, -5.1263e00],
								    ]				).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]:
								snake_case_				:							Union[str, Any]						 =       (
								    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-resnet101-coco-stuff"				)
								    .to(_SCREAMING_SNAKE_CASE				)
								    .eval()
								)
								snake_case_				:							Any						 =       self.default_image_processor
								snake_case_				:							Union[str, Any]						 =       prepare_img()
								snake_case_				:							int						 =       image_processor(_SCREAMING_SNAKE_CASE		,				return_tensors="pt"				).to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							List[Any]						 =       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_				:							Optional[int]						 =       model(**_SCREAMING_SNAKE_CASE				)
								# masks_queries_logits
								snake_case_				:							Tuple						 =       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_				:							Any						 =       [[-0.9046, -2.6366, -4.6062], [-3.4179, -5.7890, -8.8057], [-4.9179, -7.6560, -10.7711]]
								snake_case_				:							Tuple						 =       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_				:							Union[str, Any]						 =       outputs.class_queries_logits
								self.assertEqual(
								    class_queries_logits.shape		,				(1, model.config.decoder_config.num_queries, model.config.num_labels + 1)				)
								snake_case_				:							Optional[Any]						 =       torch.tensor(
								    [[4.7188, -3.2585, -2.8857], [6.6871, -2.9181, -1.2487], [7.2449, -2.2764, -2.1874]]				).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				) ->				Union[str, Any]:
								snake_case_				:							Union[str, Any]						 =       (
								    MaskFormerForInstanceSegmentation.from_pretrained("facebook/maskformer-swin-small-coco"				)
								    .to(_SCREAMING_SNAKE_CASE				)
								    .eval()
								)
								snake_case_				:							Any						 =       self.default_image_processor

								snake_case_				:							List[Any]						 =       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_				:							str						 =       inputs["pixel_values"].to(_SCREAMING_SNAKE_CASE				)
								snake_case_				:							str						 =       [el.to(_SCREAMING_SNAKE_CASE				) for el in inputs["mask_labels"]]
								snake_case_				:							Optional[int]						 =       [el.to(_SCREAMING_SNAKE_CASE				) for el in inputs["class_labels"]]

								with torch.no_grad():
										snake_case_				:							Union[str, Any]						 =       model(**_SCREAMING_SNAKE_CASE				)

								self.assertTrue(outputs.loss is not None				)








from typing import TYPE_CHECKING

from ...utils import (
    OptionalDependencyNotAvailable,
    _LazyModule,
    is_flax_available,
    is_sentencepiece_available,
    is_tf_available,
    is_tokenizers_available,
    is_torch_available,
)


lowercase  :							Union[str, Any]			  =    {'''configuration_xglm''': ['''XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP''', '''XGLMConfig''']}

try:
							if not is_sentencepiece_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							Optional[int]			  =    ['''XGLMTokenizer''']

try:
							if not is_tokenizers_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							Tuple			  =    ['''XGLMTokenizerFast''']

try:
							if not is_torch_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							str			  =    [
							    '''XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''XGLMForCausalLM''',
							    '''XGLMModel''',
							    '''XGLMPreTrainedModel''',
							]


try:
							if not is_flax_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							str			  =    [
							    '''FlaxXGLMForCausalLM''',
							    '''FlaxXGLMModel''',
							    '''FlaxXGLMPreTrainedModel''',
							]


try:
							if not is_tf_available():
														raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
							pass
else:
							lowercase  :							Tuple			  =    [
							    '''TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST''',
							    '''TFXGLMForCausalLM''',
							    '''TFXGLMModel''',
							    '''TFXGLMPreTrainedModel''',
							]


if TYPE_CHECKING:
							from .configuration_xglm import XGLM_PRETRAINED_CONFIG_ARCHIVE_MAP, XGLMConfig

							try:
														if not is_sentencepiece_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xglm import XGLMTokenizer

							try:
														if not is_tokenizers_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .tokenization_xglm_fast import XGLMTokenizerFast

							try:
														if not is_torch_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_xglm import XGLM_PRETRAINED_MODEL_ARCHIVE_LIST, XGLMForCausalLM, XGLMModel, XGLMPreTrainedModel

							try:
														if not is_flax_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_flax_xglm import FlaxXGLMForCausalLM, FlaxXGLMModel, FlaxXGLMPreTrainedModel

							try:
														if not is_tf_available():
																					raise OptionalDependencyNotAvailable()
							except OptionalDependencyNotAvailable:
														pass
							else:
														from .modeling_tf_xglm import (
														    TF_XGLM_PRETRAINED_MODEL_ARCHIVE_LIST,
														    TFXGLMForCausalLM,
														    TFXGLMModel,
														    TFXGLMPreTrainedModel,
														)


else:
							import sys

							lowercase  :							Dict			  =    _LazyModule(__name__, globals()['''__file__'''], _import_structure)
