




import inspect
import unittest

import numpy as np

from tests.test_modeling_common import floats_tensor
from transformers import MaskaFormerConfig, 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 MaskaFormerForUniversalSegmentation, MaskaFormerModel

						if is_vision_available():
												from transformers import MaskaFormerImageProcessor

if is_vision_available():
						from PIL import Image







class 				lowerCAmelCase_       :






				def __init__(			self      ,snake_case__      ,snake_case__=2      ,snake_case__=True      ,snake_case__=False      ,snake_case__=10      ,snake_case__=3      ,snake_case__=32 * 8      ,snake_case__=32 * 8      ,snake_case__=4      ,snake_case__=64      ,):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      parent
							SCREAMING_SNAKE_CASE_   : Any					  =      batch_size
							SCREAMING_SNAKE_CASE_   : Any					  =      is_training
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      use_auxiliary_loss
							SCREAMING_SNAKE_CASE_   : List[str]					  =      num_queries
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      num_channels
							SCREAMING_SNAKE_CASE_   : List[str]					  =      min_size
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      max_size
							SCREAMING_SNAKE_CASE_   : List[str]					  =      num_labels
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      hidden_dim
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      hidden_dim






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size] ).to(
							    snake_case__ )

							SCREAMING_SNAKE_CASE_   : str					  =      torch.ones([self.batch_size, self.min_size, self.max_size]      ,device=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      (
							    torch.rand([self.batch_size, self.num_labels, self.min_size, self.max_size]      ,device=snake_case__ ) > 0.5
							).float()
							SCREAMING_SNAKE_CASE_   : Tuple					  =      (torch.rand((self.batch_size, self.num_labels)      ,device=snake_case__ ) > 0.5).long()

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      self.get_config()
							return config, pixel_values, pixel_mask, mask_labels, class_labels






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      MaskaFormerConfig(
							    hidden_size=self.hidden_dim      ,)
							SCREAMING_SNAKE_CASE_   : str					  =      self.num_queries
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.num_labels

							SCREAMING_SNAKE_CASE_   : int					  =      [1, 1, 1, 1]
							SCREAMING_SNAKE_CASE_   : Tuple					  =      self.num_channels

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      64
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      128
							SCREAMING_SNAKE_CASE_   : Tuple					  =      self.hidden_dim
							SCREAMING_SNAKE_CASE_   : str					  =      self.hidden_dim
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.hidden_dim
							return config






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : int					  =      self.prepare_config_and_inputs()
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      {'pixel_values': pixel_values, 'pixel_mask': pixel_mask}
							return config, inputs_dict






				def 		snake_case	(			self      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      output.encoder_hidden_states
							SCREAMING_SNAKE_CASE_   : Any					  =      output.pixel_decoder_hidden_states
							SCREAMING_SNAKE_CASE_   : Dict					  =      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_layers )






				def 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__=False ):
							with torch.no_grad():
										SCREAMING_SNAKE_CASE_   : Dict					  =      MaskaFormerModel(config=snake_case__ )
										model.to(snake_case__ )
										model.eval()

										SCREAMING_SNAKE_CASE_   : str					  =      model(pixel_values=snake_case__      ,pixel_mask=snake_case__ )
										SCREAMING_SNAKE_CASE_   : Tuple					  =      model(snake_case__      ,output_hidden_states=snake_case__ )

							self.parent.assertEqual(
							    output.transformer_decoder_last_hidden_state.shape      ,(self.batch_size, self.num_queries, self.hidden_dim)      ,)
							# 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 		snake_case	(			self      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__      ,snake_case__ ):
							SCREAMING_SNAKE_CASE_   : str					  =      MaskaFormerForUniversalSegmentation(config=snake_case__ )
							model.to(snake_case__ )
							model.eval()

							def comm_check_on_output(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():
										SCREAMING_SNAKE_CASE_   : List[str]					  =      model(pixel_values=snake_case__      ,pixel_mask=snake_case__ )
										SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      model(snake_case__ )

										comm_check_on_output(snake_case__ )

										SCREAMING_SNAKE_CASE_   : Tuple					  =      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 				lowerCAmelCase_       (					lowerCamelCase_						,     lowerCamelCase_						,     unittest.TestCase							):
				__a     :       Union[str, Any]						=     (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
				__a     :       Optional[Any]						=     {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

				__a     :       str						=     False
				__a     :       Optional[Any]						=     False
				__a     :       Dict						=     False
				__a     :       Any						=     False






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      MaskaFormerModelTester(self )
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      ConfigTester(self      ,config_class=snake_case__      ,has_text_modality=snake_case__ )






				def 		snake_case	(			self ):
							self.config_tester.run_common_tests()






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Any					  =      self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskaformer_model(snake_case__      ,**snake_case__      ,output_hidden_states=snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : str					  =      self.model_tester.prepare_config_and_inputs()
							self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*snake_case__ )






				@unittest.skip(reason='Mask2Former does not use inputs_embeds' )
				def 		snake_case	(			self ):
							pass






				@unittest.skip(reason='Mask2Former does not have a get_input_embeddings method' )
				def 		snake_case	(			self ):
							pass






				@unittest.skip(reason='Mask2Former is not a generative model' )
				def 		snake_case	(			self ):
							pass






				@unittest.skip(reason='Mask2Former does not use token embeddings' )
				def 		snake_case	(			self ):
							pass






				@require_torch_multi_gpu
				@unittest.skip(
				    reason='Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`' )
				def 		snake_case	(			self ):
							pass






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






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Optional[int]					  =      self.model_tester.prepare_config_and_inputs_for_common()

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

										SCREAMING_SNAKE_CASE_   : Any					  =      ['pixel_values']
										self.assertListEqual(arg_names[:1]      ,snake_case__ )






				@slow
				def 		snake_case	(			self ):
							for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
										SCREAMING_SNAKE_CASE_   : List[Any]					  =      MaskaFormerModel.from_pretrained(snake_case__ )
										self.assertIsNotNone(snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Dict					  =      (self.model_tester.min_size,) * 2
							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      {
							    '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(),
							}
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      self.model_tester.get_config()

							SCREAMING_SNAKE_CASE_   : Tuple					  =      MaskaFormerForUniversalSegmentation(snake_case__ ).to(snake_case__ )
							SCREAMING_SNAKE_CASE_   : Tuple					  =      model(**snake_case__ )
							self.assertTrue(outputs.loss is not None )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Any					  =      self.model_tester.prepare_config_and_inputs_for_common()
							self.model_tester.create_and_check_maskaformer_model(snake_case__      ,**snake_case__      ,output_hidden_states=snake_case__ )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : int					  =      self.model_tester.prepare_config_and_inputs_for_common()

							for model_class in self.all_model_classes:
										SCREAMING_SNAKE_CASE_   : Tuple					  =      model_class(snake_case__ ).to(snake_case__ )
										SCREAMING_SNAKE_CASE_   : List[str]					  =      model(**snake_case__      ,output_attentions=snake_case__ )
										self.assertTrue(outputs.attentions is not None )






				def 		snake_case	(			self ):
							if not self.model_tester.is_training:
										return

							SCREAMING_SNAKE_CASE_   : Dict					  =      self.all_model_classes[1]
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      self.model_tester.prepare_config_and_inputs()

							SCREAMING_SNAKE_CASE_   : Tuple					  =      model_class(snake_case__ )
							model.to(snake_case__ )
							model.train()

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      model(snake_case__      ,mask_labels=snake_case__      ,class_labels=snake_case__ ).loss
							loss.backward()






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      self.all_model_classes[1]
							SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_  ,    SCREAMING_SNAKE_CASE_   : str					  =      self.model_tester.prepare_config_and_inputs()
							SCREAMING_SNAKE_CASE_   : int					  =      True
							SCREAMING_SNAKE_CASE_   : str					  =      True

							SCREAMING_SNAKE_CASE_   : Optional[Any]					  =      model_class(snake_case__ ).to(snake_case__ )
							model.train()

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      model(snake_case__      ,mask_labels=snake_case__      ,class_labels=snake_case__ )

							SCREAMING_SNAKE_CASE_   : Tuple					  =      outputs.encoder_hidden_states[0]
							encoder_hidden_states.retain_grad()

							SCREAMING_SNAKE_CASE_   : str					  =      outputs.pixel_decoder_hidden_states[0]
							pixel_decoder_hidden_states.retain_grad()

							SCREAMING_SNAKE_CASE_   : str					  =      outputs.transformer_decoder_hidden_states[0]
							transformer_decoder_hidden_states.retain_grad()

							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      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 )



UpperCamelCase__ :   List[str]						=							1e-4





def        __UpperCAmelCase						(							)       ->  Any:







			"""simple docstring"""





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







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






				@cached_property
				def 		snake_case	(			self ):
							return "facebook/mask2former-swin-small-coco-instance"






				@cached_property
				def 		snake_case	(			self ):
							return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints ) if is_vision_available() else None






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : Any					  =      MaskaFormerModel.from_pretrained(self.model_checkpoints ).to(snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      self.default_image_processor
							SCREAMING_SNAKE_CASE_   : str					  =      prepare_img()
							SCREAMING_SNAKE_CASE_   : Any					  =      image_processor(snake_case__      ,return_tensors='pt' ).to(snake_case__ )
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      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, 384, 384) )

							with torch.no_grad():
										SCREAMING_SNAKE_CASE_   : Tuple					  =      model(**snake_case__ )

							SCREAMING_SNAKE_CASE_   : List[Any]					  =      torch.tensor(
							    [[-0.2790, -1.0717, -1.1668], [-0.5128, -0.3128, -0.4987], [-0.5832, 0.1971, -0.0197]] ).to(snake_case__ )
							self.assertTrue(
							    torch.allclose(
							        outputs.encoder_last_hidden_state[0, 0, :3, :3]      ,snake_case__      ,atol=snake_case__ ) )

							SCREAMING_SNAKE_CASE_   : List[str]					  =      torch.tensor(
							    [[0.8973, 1.1847, 1.1776], [1.1934, 1.5040, 1.5128], [1.1153, 1.4486, 1.4951]] ).to(snake_case__ )
							self.assertTrue(
							    torch.allclose(
							        outputs.pixel_decoder_last_hidden_state[0, 0, :3, :3]      ,snake_case__      ,atol=snake_case__ ) )

							SCREAMING_SNAKE_CASE_   : Any					  =      torch.tensor(
							    [[2.1152, 1.7000, -0.8603], [1.5808, 1.8004, -0.9353], [1.6043, 1.7495, -0.5999]] ).to(snake_case__ )
							self.assertTrue(
							    torch.allclose(
							        outputs.transformer_decoder_last_hidden_state[0, :3, :3]      ,snake_case__      ,atol=snake_case__ ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[Any]					  =      MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(snake_case__ ).eval()
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.default_image_processor
							SCREAMING_SNAKE_CASE_   : Tuple					  =      prepare_img()
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      image_processor(snake_case__      ,return_tensors='pt' ).to(snake_case__ )
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      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, 384, 384) )

							with torch.no_grad():
										SCREAMING_SNAKE_CASE_   : List[str]					  =      model(**snake_case__ )
							# masks_queries_logits
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      outputs.masks_queries_logits
							self.assertEqual(
							    masks_queries_logits.shape      ,(1, model.config.num_queries, inputs_shape[-2] // 4, inputs_shape[-1] // 4) )
							SCREAMING_SNAKE_CASE_   : Any					  =      [
							    [-8.7839, -9.0056, -8.8121],
							    [-7.4104, -7.0313, -6.5401],
							    [-6.6105, -6.3427, -6.4675],
							]
							SCREAMING_SNAKE_CASE_   : Optional[int]					  =      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
							SCREAMING_SNAKE_CASE_   : int					  =      outputs.class_queries_logits
							self.assertEqual(class_queries_logits.shape      ,(1, model.config.num_queries, model.config.num_labels + 1) )
							SCREAMING_SNAKE_CASE_   : int					  =      torch.tensor(
							    [
							        [1.8324, -8.0835, -4.1922],
							        [0.8450, -9.0050, -3.6053],
							        [0.3045, -7.7293, -3.0275],
							    ] ).to(snake_case__ )
							self.assertTrue(torch.allclose(outputs.class_queries_logits[0, :3, :3]      ,snake_case__      ,atol=snake_case__ ) )






				def 		snake_case	(			self ):
							SCREAMING_SNAKE_CASE_   : List[str]					  =      MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints ).to(snake_case__ ).eval()
							SCREAMING_SNAKE_CASE_   : Dict					  =      self.default_image_processor

							SCREAMING_SNAKE_CASE_   : Union[str, 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'      ,)

							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      inputs['pixel_values'].to(snake_case__ )
							SCREAMING_SNAKE_CASE_   : int					  =      [el.to(snake_case__ ) for el in inputs['mask_labels']]
							SCREAMING_SNAKE_CASE_   : Union[str, Any]					  =      [el.to(snake_case__ ) for el in inputs['class_labels']]

							with torch.no_grad():
										SCREAMING_SNAKE_CASE_   : Dict					  =      model(**snake_case__ )

							self.assertTrue(outputs.loss is not None )









import warnings

from ...utils import logging
from .image_processing_chinese_clip import ChineseCLIPImageProcessor


UpperCamelCase__ :   Dict						=							logging.get_logger(__name__)







class 				lowerCAmelCase_       (					lowerCamelCase_							):






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



