





'''simple docstring'''


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







	def __init__(					self      : Tuple			,			lowerCamelCase      : Optional[Any]			,			lowerCamelCase      : List[Any]=2			,			lowerCamelCase      : Dict=True			,			lowerCamelCase      : Dict=False			,			lowerCamelCase      : Dict=1_0			,			lowerCamelCase      : Union[str, Any]=3			,			lowerCamelCase      : Dict=3_2 * 8			,			lowerCamelCase      : List[str]=3_2 * 8			,			lowerCamelCase      : Any=4			,			lowerCamelCase      : Optional[int]=6_4			,			):




				'''simple docstring'''
				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__	 =			hidden_dim
				a__	 =			hidden_dim







	def     __a (					self      : Any		):




				'''simple docstring'''
				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     __a (					self      : Any		):




				'''simple docstring'''
				a__	 =			MaskaFormerConfig(
				    hidden_size=self.hidden_dim			,			)
				a__	 =			self.num_queries
				a__	 =			self.num_labels

				a__	 =			[1, 1, 1, 1]
				a__	 =			self.num_channels

				a__	 =			6_4
				a__	 =			1_2_8
				a__	 =			self.hidden_dim
				a__	 =			self.hidden_dim
				a__	 =			self.hidden_dim
				return config







	def     __a (					self      : Optional[Any]		):




				'''simple docstring'''
				a__ ,					a__ ,					a__ ,					a__ ,					a__	 =			self.prepare_config_and_inputs()
				a__	 =			{"pixel_values": pixel_values, "pixel_mask": pixel_mask}
				return config, inputs_dict







	def     __a (					self      : Optional[Any]			,			lowerCamelCase      : Any			,			lowerCamelCase      : List[Any]		):




				'''simple docstring'''
				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_layers		)







	def     __a (					self      : Dict			,			lowerCamelCase      : List[str]			,			lowerCamelCase      : str			,			lowerCamelCase      : Any			,			lowerCamelCase      : List[str]=False		):




				'''simple docstring'''
				with torch.no_grad():
							a__	 =			MaskaFormerModel(config=__UpperCAmelCase		)
							model.to(__UpperCAmelCase		)
							model.eval()

							a__	 =			model(pixel_values=__UpperCAmelCase			,			pixel_mask=__UpperCAmelCase		)
							a__	 =			model(__UpperCAmelCase			,			output_hidden_states=__UpperCAmelCase		)

				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(__UpperCAmelCase			,			__UpperCAmelCase		)







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




				'''simple docstring'''
				a__	 =			MaskaFormerForUniversalSegmentation(config=__UpperCAmelCase		)
				model.to(__UpperCAmelCase		)
				model.eval()

				def comm_check_on_output(lowerCamelCase      : 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    UpperCamelCase__	(		lowerCAmelCase__						,lowerCAmelCase__						,unittest.TestCase  ):
	lowerCAmelCase__       :      List[str]										=    (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
	lowerCAmelCase__       :      List[Any]										=    {"feature-extraction": MaskaFormerModel} if is_torch_available() else {}

	lowerCAmelCase__       :      Optional[Any]										=    False
	lowerCAmelCase__       :      Union[str, Any]										=    False
	lowerCAmelCase__       :      Dict										=    False
	lowerCAmelCase__       :      Any										=    False







	def     __a (					self      : Tuple		):




				'''simple docstring'''
				a__	 =			MaskaFormerModelTester(self		)
				a__	 =			ConfigTester(self			,			config_class=__UpperCAmelCase			,			has_text_modality=__UpperCAmelCase		)







	def     __a (					self      : List[Any]		):




				'''simple docstring'''
				self.config_tester.run_common_tests()







	def     __a (					self      : Tuple		):




				'''simple docstring'''
				a__ ,					a__	 =			self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.create_and_check_maskaformer_model(__UpperCAmelCase			,			**__UpperCAmelCase			,			output_hidden_states=__UpperCAmelCase		)







	def     __a (					self      : Optional[Any]		):




				'''simple docstring'''
				a__	 =			self.model_tester.prepare_config_and_inputs()
				self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*__UpperCAmelCase		)







	@unittest.skip(reason="Mask2Former does not use inputs_embeds"		)
	def     __a (					self      : List[str]		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former does not have a get_input_embeddings method"		)
	def     __a (					self      : Dict		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former is not a generative model"		)
	def     __a (					self      : Optional[int]		):




				'''simple docstring'''
				pass







	@unittest.skip(reason="Mask2Former does not use token embeddings"		)
	def     __a (					self      : Optional[int]		):




				'''simple docstring'''
				pass







	@require_torch_multi_gpu
	@unittest.skip(
	    reason="Mask2Former has some layers using `add_module` which doesn\'t work well with `nn.DataParallel`"		)
	def     __a (					self      : List[Any]		):




				'''simple docstring'''
				pass







	@unittest.skip("Will be fixed soon by reducing the size of the model used for common tests."		)
	def     __a (					self      : List[str]		):




				'''simple docstring'''
				pass







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




				'''simple docstring'''
				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     __a (					self      : Any		):




				'''simple docstring'''
				for model_name in ["facebook/mask2former-swin-small-coco-instance"]:
							a__	 =			MaskaFormerModel.from_pretrained(__UpperCAmelCase		)
							self.assertIsNotNone(__UpperCAmelCase		)







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




				'''simple docstring'''
				a__	 =			(self.model_tester.min_size,) * 2
				a__	 =			{
				    "pixel_values": torch.randn((2, 3, *size)			,			device=__UpperCAmelCase		),
				    "mask_labels": torch.randn((2, 1_0, *size)			,			device=__UpperCAmelCase		),
				    "class_labels": torch.zeros(2			,			1_0			,			device=__UpperCAmelCase		).long(),
				}
				a__	 =			self.model_tester.get_config()

				a__	 =			MaskaFormerForUniversalSegmentation(__UpperCAmelCase		).to(__UpperCAmelCase		)
				a__	 =			model(**__UpperCAmelCase		)
				self.assertTrue(outputs.loss is not None		)







	def     __a (					self      : List[str]		):




				'''simple docstring'''
				a__ ,					a__	 =			self.model_tester.prepare_config_and_inputs_for_common()
				self.model_tester.create_and_check_maskaformer_model(__UpperCAmelCase			,			**__UpperCAmelCase			,			output_hidden_states=__UpperCAmelCase		)







	def     __a (					self      : Optional[int]		):




				'''simple docstring'''
				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     __a (					self      : List[str]		):




				'''simple docstring'''
				if not self.model_tester.is_training:
							return

				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     __a (					self      : Tuple		):




				'''simple docstring'''
				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		).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()

				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		)





lowerCAmelCase_ : int	  =       1E-4







def  _lowerCamelCase	() ->     List[str]:
			a__	 =			Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"  )
			return image






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







	@cached_property
	def     __a (					self      : Tuple		):




				'''simple docstring'''
				return "facebook/mask2former-swin-small-coco-instance"







	@cached_property
	def     __a (					self      : Union[str, Any]		):




				'''simple docstring'''
				return MaskaFormerImageProcessor.from_pretrained(self.model_checkpoints		) if is_vision_available() else None







	def     __a (					self      : Dict		):




				'''simple docstring'''
				a__	 =			MaskaFormerModel.from_pretrained(self.model_checkpoints		).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] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0		)
				# check size
				self.assertEqual(__UpperCAmelCase			,			(1, 3, 3_8_4, 3_8_4)		)

				with torch.no_grad():
							a__	 =			model(**__UpperCAmelCase		)

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

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

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







	def     __a (					self      : Optional[Any]		):




				'''simple docstring'''
				a__	 =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).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] % 3_2) == 0 and (inputs_shape[-2] % 3_2) == 0		)
				# check size
				self.assertEqual(__UpperCAmelCase			,			(1, 3, 3_8_4, 3_8_4)		)

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







	def     __a (					self      : List[Any]		):




				'''simple docstring'''
				a__	 =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints		).to(__UpperCAmelCase		).eval()
				a__	 =			self.default_image_processor

				a__	 =			image_processor(
				    [np.zeros((3, 8_0_0, 1_3_3_3)		), np.zeros((3, 8_0_0, 1_3_3_3)		)]			,			segmentation_maps=[np.zeros((3_8_4, 3_8_4)		).astype(np.floataa		), np.zeros((3_8_4, 3_8_4)		).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		)








import os
import sys
import unittest


a_								=       os.path.abspath(os.path.dirname(os.path.dirname(os.path.dirname(__file__))))
sys.path.append(os.path.join(git_repo_path, """utils"""))

import check_dummies  # noqa: E402
from check_dummies import create_dummy_files, create_dummy_object, find_backend, read_init  # noqa: E402


# Align TRANSFORMERS_PATH in check_dummies with the current path
a_								=       os.path.join(git_repo_path, """src""", """transformers""")

a_								=       """
{0} = None
"""

a_								=       """
class {0}(metaclass=DummyObject):
    _backends = {1}

    def __init__(self, *args, **kwargs):
        requires_backends(self, {1})
"""


a_								=       """
def {0}(*args, **kwargs):
    requires_backends({0}, {1})
"""



class 			__lowerCAmelCase  (						unittest.TestCase ):




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     find_backend('''    _import_structure["models.albert"].append("AlbertTokenizerFast")'''					)
    self.assertIsNone(__UpperCAmelCase					)

    __lowerCamelCase    				=     find_backend('''    if not is_tokenizers_available():'''					)
    self.assertEqual(__UpperCAmelCase						,					'''tokenizers'''					)

    __lowerCamelCase    				=     find_backend('''    if not is_tensorflow_text_available():'''					)
    self.assertEqual(__UpperCAmelCase						,					'''tensorflow_text'''					)

    __lowerCamelCase    				=     find_backend('''    if not (is_sentencepiece_available() and is_tokenizers_available()):'''					)
    self.assertEqual(__UpperCAmelCase						,					'''sentencepiece_and_tokenizers'''					)

    __lowerCamelCase    				=     find_backend(
        '''    if not (is_sentencepiece_available() and is_tensorflow_text_available()):'''					)
    self.assertEqual(__UpperCAmelCase						,					'''sentencepiece_and_tensorflow_text'''					)

    __lowerCamelCase    				=     find_backend(
        '''    if not (is_sentencepiece_available() and is_tokenizers_available() and is_vision_available()):'''					)
    self.assertEqual(__UpperCAmelCase						,					'''sentencepiece_and_tokenizers_and_vision'''					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     read_init()
    # We don't assert on the exact list of keys to allow for smooth grow of backend-specific objects
    self.assertIn('''torch'''						,					__UpperCAmelCase					)
    self.assertIn('''tensorflow_text'''						,					__UpperCAmelCase					)
    self.assertIn('''sentencepiece_and_tokenizers'''						,					__UpperCAmelCase					)

    # Likewise, we can't assert on the exact content of a key
    self.assertIn('''BertModel'''						,					objects['''torch''']					)
    self.assertIn('''TFBertModel'''						,					objects['''tf''']					)
    self.assertIn('''FlaxBertModel'''						,					objects['''flax''']					)
    self.assertIn('''BertModel'''						,					objects['''torch''']					)
    self.assertIn('''TFBertTokenizer'''						,					objects['''tensorflow_text''']					)
    self.assertIn('''convert_slow_tokenizer'''						,					objects['''sentencepiece_and_tokenizers''']					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     create_dummy_object('''CONSTANT'''						,					'''\'torch\''''					)
    self.assertEqual(__UpperCAmelCase						,					'''\nCONSTANT = None\n'''					)

    __lowerCamelCase    				=     create_dummy_object('''function'''						,					'''\'torch\''''					)
    self.assertEqual(
        __UpperCAmelCase						,					'''\ndef function(*args, **kwargs):\n    requires_backends(function, \'torch\')\n'''					)

    __lowerCamelCase    				=     '''
class FakeClass(metaclass=DummyObject):
    _backends = \'torch\'

    def __init__(self, *args, **kwargs):
        requires_backends(self, \'torch\')
'''
    __lowerCamelCase    				=     create_dummy_object('''FakeClass'''						,					'''\'torch\''''					)
    self.assertEqual(__UpperCAmelCase						,					__UpperCAmelCase					)




 def 							lowerCamelCase   (    self					):



    '''simple docstring'''
    __lowerCamelCase    				=     '''# This file is autogenerated by the command `make fix-copies`, do not edit.
from ..utils import DummyObject, requires_backends


CONSTANT = None


def function(*args, **kwargs):
    requires_backends(function, ["torch"])


class FakeClass(metaclass=DummyObject):
    _backends = ["torch"]

    def __init__(self, *args, **kwargs):
        requires_backends(self, ["torch"])
'''
    __lowerCamelCase    				=     create_dummy_files({'''torch''': ['''CONSTANT''', '''function''', '''FakeClass''']}					)
    self.assertEqual(dummy_files['''torch''']						,					__UpperCAmelCase					)






