



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      :  Any						, __UpperCamelCase      :  Dict						, __UpperCamelCase      :  Union[str, Any]=2						, __UpperCamelCase      :  Union[str, Any]=True						, __UpperCamelCase      :  Any=False						, __UpperCamelCase      :  Any=10						, __UpperCamelCase      :  str=3						, __UpperCamelCase      :  Dict=32 * 4						, __UpperCamelCase      :  Dict=32 * 6						, __UpperCamelCase      :  Dict=4						, __UpperCamelCase      :  Tuple=32						, )		->     List[Any]:
											A      						=    parent
											A      						=    batch_size
											A      						=    is_training
											A      						=    use_auxiliary_loss
											A      						=    num_queries
											A      						=    num_channels
											A      						=    min_size
											A      						=    max_size
											A      						=    num_labels
											A      						=    mask_feature_size


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Optional[Any]:
											A      						=    floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]       ).to(
											    __UpperCamelCase       )

											A      						=    torch.ones([self.batch_size, self.min_size, self.max_size]						, device=__UpperCamelCase       )

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

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


				def __UpperCamelCase						(							self      :  List[Any]       )		->     Tuple:
											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 __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Union[str, Any]:
											A						,   A						,   A						,   A						,   A      						=    self.prepare_config_and_inputs()
											A      						=    {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
											return config, inputs_dict


				def __UpperCamelCase						(							self      :  Optional[Any]						, __UpperCamelCase      :  Tuple						, __UpperCamelCase      :  Optional[Any]       )		->     List[Any]:
											A      						=    output.encoder_hidden_states
											A      						=    output.pixel_decoder_hidden_states
											A      						=    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 __UpperCamelCase						(							self      :  str						, __UpperCamelCase      :  Tuple						, __UpperCamelCase      :  int						, __UpperCamelCase      :  Union[str, Any]						, __UpperCamelCase      :  Any=False       )		->     Union[str, Any]:
											with torch.no_grad():
																		A      						=    MaskFormerModel(config=__UpperCamelCase       )
																		model.to(__UpperCamelCase       )
																		model.eval()

																		A      						=    model(pixel_values=__UpperCamelCase						, pixel_mask=__UpperCamelCase       )
																		A      						=    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 __UpperCamelCase						(							self      :  Any						, __UpperCamelCase      :  int						, __UpperCamelCase      :  Optional[Any]						, __UpperCamelCase      :  Any						, __UpperCamelCase      :  Optional[int]						, __UpperCamelCase      :  Optional[Any]       )		->     Optional[int]:
											A      						=    MaskFormerForInstanceSegmentation(config=__UpperCamelCase       )
											model.to(__UpperCamelCase       )
											model.eval()

											def comm_check_on_output(__UpperCamelCase      :  Optional[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():
																		A      						=    model(pixel_values=__UpperCamelCase						, pixel_mask=__UpperCamelCase       )
																		A      						=    model(__UpperCamelCase       )

																		comm_check_on_output(__UpperCamelCase       )

																		A      						=    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        lowerCAmelCase__					(  _lowerCamelCase ,				_lowerCamelCase ,				unittest.TestCase       ):
				A_   :     Any								=     (MaskFormerModel, MaskFormerForInstanceSegmentation) if is_torch_available() else ()
				A_   :     Any								=     (
				    {'feature-extraction': MaskFormerModel, 'image-segmentation': MaskFormerForInstanceSegmentation}
				    if is_torch_available()
				    else {}
				)

				A_   :     Dict								=     False
				A_   :     Dict								=     False
				A_   :     Optional[Any]								=     False
				A_   :     List[Any]								=     False


				def __UpperCamelCase						(							self      :  Tuple       )		->     List[str]:
											A      						=    MaskFormerModelTester(self       )
											A      						=    ConfigTester(self						, config_class=__UpperCamelCase						, has_text_modality=__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Optional[int]:
											self.config_tester.run_common_tests()


				def __UpperCamelCase						(							self      :  List[str]       )		->     int:
											A						,   A      						=    self.model_tester.prepare_config_and_inputs_for_common()
											self.model_tester.create_and_check_maskformer_model(__UpperCamelCase						, **__UpperCamelCase						, output_hidden_states=__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  List[Any]       )		->     Dict:
											A      						=    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 __UpperCamelCase						(							self      :  Tuple       )		->     Union[str, Any]:
											pass


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


				@unittest.skip(reason='MaskFormer is not a generative model'       )
				def __UpperCamelCase						(							self      :  str       )		->     List[str]:
											pass


				@unittest.skip(reason='MaskFormer does not use token embeddings'       )
				def __UpperCamelCase						(							self      :  Optional[Any]       )		->     Optional[Any]:
											pass


				@require_torch_multi_gpu
				@unittest.skip(
				    reason='MaskFormer has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`'       )
				def __UpperCamelCase						(							self      :  str       )		->     Tuple:
											pass


				@unittest.skip('Will be fixed soon by reducing the size of the model used for common tests.'       )
				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     Optional[int]:
											pass


				def __UpperCamelCase						(							self      :  List[Any]       )		->     Optional[int]:
											A						,   A      						=    self.model_tester.prepare_config_and_inputs_for_common()

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

																		A      						=    ['pixel_values']
																		self.assertListEqual(arg_names[:1]						, __UpperCamelCase       )


				@slow
				def __UpperCamelCase						(							self      :  int       )		->     List[str]:
											for model_name in ["facebook/maskformer-swin-small-coco"]:
																		A      						=    MaskFormerModel.from_pretrained(__UpperCamelCase       )
																		self.assertIsNotNone(__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  List[str]       )		->     Union[str, Any]:
											A      						=    (self.model_tester.min_size,) * 2
											A      						=    {
											    '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(),
											}

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


				def __UpperCamelCase						(							self      :  Optional[Any]       )		->     List[str]:
											A						,   A      						=    self.model_tester.prepare_config_and_inputs_for_common()
											self.model_tester.create_and_check_maskformer_model(__UpperCamelCase						, **__UpperCamelCase						, output_hidden_states=__UpperCamelCase       )


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[str]:
											A						,   A      						=    self.model_tester.prepare_config_and_inputs_for_common()

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


				def __UpperCamelCase						(							self      :  Dict       )		->     Tuple:
											if not self.model_tester.is_training:
																		return
											# only MaskFormerForInstanceSegmentation has the loss
											A      						=    self.all_model_classes[1]
											A						,   A						,   A						,   A						,   A      						=    self.model_tester.prepare_config_and_inputs()

											A      						=    model_class(__UpperCamelCase       )
											model.to(__UpperCamelCase       )
											model.train()

											A      						=    model(__UpperCamelCase						, mask_labels=__UpperCamelCase						, class_labels=__UpperCamelCase       ).loss
											loss.backward()


				def __UpperCamelCase						(							self      :  Union[str, Any]       )		->     List[str]:
											# only MaskFormerForInstanceSegmentation has the loss
											A      						=    self.all_model_classes[1]
											A						,   A						,   A						,   A						,   A      						=    self.model_tester.prepare_config_and_inputs()
											A      						=    True
											A      						=    True

											A      						=    model_class(__UpperCamelCase       )
											model.to(__UpperCamelCase       )
											model.train()

											A      						=    model(__UpperCamelCase						, mask_labels=__UpperCamelCase						, class_labels=__UpperCamelCase       )

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

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

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





__snake_case     :Optional[Any]			       =1E-4






def  lowerCamelCase_	(      )       ->							Optional[Any]:

							'''simple docstring'''






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



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


				@cached_property
				def __UpperCamelCase						(							self      :  List[str]       )		->     Dict:
											return (
											    MaskFormerImageProcessor.from_pretrained('facebook/maskformer-swin-small-coco'       )
											    if is_vision_available()
											    else None
											)


				def __UpperCamelCase						(							self      :  Dict       )		->     Optional[Any]:
											A      						=    MaskFormerModel.from_pretrained('facebook/maskformer-swin-small-coco'       ).to(__UpperCamelCase       )
											A      						=    self.default_image_processor
											A      						=    prepare_img()
											A      						=    image_processor(__UpperCamelCase						, return_tensors='pt'       ).to(__UpperCamelCase       )
											A      						=    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, 1_088)       )

											with torch.no_grad():
																		A      						=    model(**__UpperCamelCase       )

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

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

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


				def __UpperCamelCase						(							self      :  str       )		->     int:
											A      						=    (
											    MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-swin-small-coco'       )
											    .to(__UpperCamelCase       )
											    .eval()
											)
											A      						=    self.default_image_processor
											A      						=    prepare_img()
											A      						=    image_processor(__UpperCamelCase						, return_tensors='pt'       ).to(__UpperCamelCase       )
											A      						=    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, 1_088)       )

											with torch.no_grad():
																		A      						=    model(**__UpperCamelCase       )
											# masks_queries_logits
											A      						=    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)						, )
											A      						=    [
											    [-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],
											]
											A      						=    torch.tensor(__UpperCamelCase       ).to(__UpperCamelCase       )
											self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]						, __UpperCamelCase						, atol=__UpperCamelCase       )       )
											# class_queries_logits
											A      						=    outputs.class_queries_logits
											self.assertEqual(
											    class_queries_logits.shape						, (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)       )
											A      						=    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 __UpperCamelCase						(							self      :  Tuple       )		->     int:
											A      						=    (
											    MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-resnet101-coco-stuff'       )
											    .to(__UpperCamelCase       )
											    .eval()
											)
											A      						=    self.default_image_processor
											A      						=    prepare_img()
											A      						=    image_processor(__UpperCamelCase						, return_tensors='pt'       ).to(__UpperCamelCase       )
											A      						=    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, 1_088)       )

											with torch.no_grad():
																		A      						=    model(**__UpperCamelCase       )
											# masks_queries_logits
											A      						=    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)						, )
											A      						=    [[-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]]
											A      						=    torch.tensor(__UpperCamelCase       ).to(__UpperCamelCase       )
											self.assertTrue(torch.allclose(masks_queries_logits[0, 0, :3, :3]						, __UpperCamelCase						, atol=__UpperCamelCase       )       )
											# class_queries_logits
											A      						=    outputs.class_queries_logits
											self.assertEqual(
											    class_queries_logits.shape						, (1, model.config.decoder_config.num_queries, model.config.num_labels + 1)       )
											A      						=    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(__UpperCamelCase       )
											self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]						, __UpperCamelCase						, atol=__UpperCamelCase       )       )


				def __UpperCamelCase						(							self      :  Any       )		->     List[Any]:
											A      						=    (
											    MaskFormerForInstanceSegmentation.from_pretrained('facebook/maskformer-swin-small-coco'       )
											    .to(__UpperCamelCase       )
											    .eval()
											)
											A      						=    self.default_image_processor

											A      						=    image_processor(
											    [np.zeros((3, 800, 1_333)       ), np.zeros((3, 800, 1_333)       )]						, segmentation_maps=[np.zeros((384, 384)       ).astype(np.floataa       ), np.zeros((384, 384)       ).astype(np.floataa       )]						, return_tensors='pt'						, )

											A      						=    inputs['pixel_values'].to(__UpperCamelCase       )
											A      						=    [el.to(__UpperCamelCase       ) for el in inputs['mask_labels']]
											A      						=    [el.to(__UpperCamelCase       ) for el in inputs['class_labels']]

											with torch.no_grad():
																		A      						=    model(**__UpperCamelCase       )

											self.assertTrue(outputs.loss is not None       )




"""simple docstring"""







import warnings

from ...utils import logging
from .image_processing_segformer import SegformerImageProcessor


a_							=    logging.get_logger(__name__)







class 					A_(SCREAMING_SNAKE_CASE_      ):







			"""simple docstring"""



			def __init__(	self				,   *A				,   **A							):
						warnings.warn(
						    'The class SegformerFeatureExtractor is deprecated and will be removed in version 5 of Transformers.'
						    ' Please use SegformerImageProcessor instead.'				,   A				,   )
						super().__init__(*A				,   **A							)





