






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					:

				"""simple docstring"""




				def __init__(     self						:    List[str],  lowerCamelCase						:    Any,  lowerCamelCase						:    Tuple=2,  lowerCamelCase						:    Optional[int]=True,  lowerCamelCase						:    int=False,  lowerCamelCase						:    Optional[int]=10,  lowerCamelCase						:    Any=3,  lowerCamelCase						:    List[Any]=32 * 8,  lowerCamelCase						:    List[str]=32 * 8,  lowerCamelCase						:    Dict=4,  lowerCamelCase						:    Dict=64,  ):

								'''simple docstring'''
								lowercase__    =			parent
								lowercase__    =			batch_size
								lowercase__    =			is_training
								lowercase__    =			use_auxiliary_loss
								lowercase__    =			num_queries
								lowercase__    =			num_channels
								lowercase__    =			min_size
								lowercase__    =			max_size
								lowercase__    =			num_labels
								lowercase__    =			hidden_dim
								lowercase__    =			hidden_dim




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__    =			floats_tensor([self.batch_size, self.num_channels, self.min_size, self.max_size]  ).to(
								    lowerCamelCase  )

								lowercase__    =			torch.ones([self.batch_size, self.min_size, self.max_size],  device=lowerCamelCase  )

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

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




				def 				lowercase__   (     self						:    Optional[int]  ):

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

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

								lowercase__    =			64
								lowercase__    =			128
								lowercase__    =			self.hidden_dim
								lowercase__    =			self.hidden_dim
								lowercase__    =			self.hidden_dim
								return config




				def 				lowercase__   (     self						:    List[str]  ):

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




				def 				lowercase__   (     self						:    Any,  lowerCamelCase						:    str,  lowerCamelCase						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			output.encoder_hidden_states
								lowercase__    =			output.pixel_decoder_hidden_states
								lowercase__    =			output.transformer_decoder_hidden_states

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




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Any,  lowerCamelCase						:    str,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    str=False  ):

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

												lowercase__    =			model(pixel_values=lowerCamelCase,  pixel_mask=lowerCamelCase  )
												lowercase__    =			model(lowerCamelCase,  output_hidden_states=lowerCamelCase  )

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




				def 				lowercase__   (     self						:    List[str],  lowerCamelCase						:    Tuple,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    str,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Any  ):

								'''simple docstring'''
								lowercase__    =			MaskaFormerForUniversalSegmentation(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()

								def comm_check_on_output(lowerCamelCase						:    Union[str, 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():
												lowercase__    =			model(pixel_values=lowerCamelCase,  pixel_mask=lowerCamelCase  )
												lowercase__    =			model(lowerCamelCase  )

												comm_check_on_output(lowerCamelCase  )

												lowercase__    =			model(
												    pixel_values=lowerCamelCase,  pixel_mask=lowerCamelCase,  mask_labels=lowerCamelCase,  class_labels=lowerCamelCase  )

								comm_check_on_output(lowerCamelCase  )

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



@require_torch
class       _UpperCAmelCase					(       A__		,A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       (MaskaFormerModel, MaskaFormerForUniversalSegmentation) if is_torch_available() else ()
				lowercase__											=       {"""feature-extraction""": MaskaFormerModel} if is_torch_available() else {}

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			MaskaFormerModelTester(self  )
								lowercase__    =			ConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase  )




				def 				lowercase__   (     self						:    str  ):

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




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

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
								self.model_tester.create_and_check_maskaformer_model(lowerCamelCase,  **lowerCamelCase,  output_hidden_states=lowerCamelCase  )




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

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_maskaformer_instance_segmentation_head_model(*lowerCamelCase  )




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

								'''simple docstring'''
								pass




				@unittest.skip(reason='''Mask2Former does not have a get_input_embeddings method'''  )
				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								pass




				@unittest.skip(reason='''Mask2Former is not a generative model'''  )
				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								pass




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

								'''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 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								pass




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

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    List[Any]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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

												lowercase__    =			['''pixel_values''']
												self.assertListEqual(arg_names[:1],  lowerCamelCase  )




				@slow
				def 				lowercase__   (     self						:    List[str]  ):

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




				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								lowercase__    =			(self.model_tester.min_size,) * 2
								lowercase__    =			{
								    '''pixel_values''': torch.randn((2, 3, *size),  device=lowerCamelCase  ),
								    '''mask_labels''': torch.randn((2, 10, *size),  device=lowerCamelCase  ),
								    '''class_labels''': torch.zeros(2,  10,  device=lowerCamelCase  ).long(),
								}
								lowercase__    =			self.model_tester.get_config()

								lowercase__    =			MaskaFormerForUniversalSegmentation(lowerCamelCase  ).to(lowerCamelCase  )
								lowercase__    =			model(**lowerCamelCase  )
								self.assertTrue(outputs.loss is not None  )




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
								self.model_tester.create_and_check_maskaformer_model(lowerCamelCase,  **lowerCamelCase,  output_hidden_states=lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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




				def 				lowercase__   (     self						:    int  ):

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

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

								lowercase__    =			model_class(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.train()

								lowercase__    =			model(lowerCamelCase,  mask_labels=lowerCamelCase,  class_labels=lowerCamelCase  ).loss
								loss.backward()




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			self.all_model_classes[1]
								lowercase__ ,						lowercase__ ,						lowercase__ ,						lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs()
								lowercase__    =			True
								lowercase__    =			True

								lowercase__    =			model_class(lowerCamelCase  ).to(lowerCamelCase  )
								model.train()

								lowercase__    =			model(lowerCamelCase,  mask_labels=lowerCamelCase,  class_labels=lowerCamelCase  )

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

								lowercase__    =			outputs.pixel_decoder_hidden_states[0]
								pixel_decoder_hidden_states.retain_grad()

								lowercase__    =			outputs.transformer_decoder_hidden_states[0]
								transformer_decoder_hidden_states.retain_grad()

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

								outputs.loss.backward(retain_graph=lowerCamelCase  )

								self.assertIsNotNone(encoder_hidden_states.grad  )
								self.assertIsNotNone(pixel_decoder_hidden_states.grad  )
								self.assertIsNotNone(transformer_decoder_hidden_states.grad  )
								self.assertIsNotNone(attentions.grad  )



A__	:			List[Any]			   = 1e-4






def   a			(						):






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




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

				"""simple docstring"""




				@cached_property
				def 				lowercase__   (     self						:    Any  ):

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




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

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




				def 				lowercase__   (     self						:    str  ):

								'''simple docstring'''
								lowercase__    =			MaskaFormerModel.from_pretrained(self.model_checkpoints  ).to(lowerCamelCase  )
								lowercase__    =			self.default_image_processor
								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )
								lowercase__    =			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(lowerCamelCase,  (1, 3, 384, 384)  )

								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )

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

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

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




				def 				lowercase__   (     self						:    int  ):

								'''simple docstring'''
								lowercase__    =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints  ).to(lowerCamelCase  ).eval()
								lowercase__    =			self.default_image_processor
								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )
								lowercase__    =			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(lowerCamelCase,  (1, 3, 384, 384)  )

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




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__    =			MaskaFormerForUniversalSegmentation.from_pretrained(self.model_checkpoints  ).to(lowerCamelCase  ).eval()
								lowercase__    =			self.default_image_processor

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

								lowercase__    =			inputs['''pixel_values'''].to(lowerCamelCase  )
								lowercase__    =			[el.to(lowerCamelCase  ) for el in inputs['''mask_labels''']]
								lowercase__    =			[el.to(lowerCamelCase  ) for el in inputs['''class_labels''']]

								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )

								self.assertTrue(outputs.loss is not None  )












import inspect
import unittest

from transformers import DPTConfig
from transformers.file_utils import is_torch_available, is_vision_available
from transformers.models.auto import get_values
from transformers.testing_utils import require_torch, require_vision, slow, torch_device

from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, _config_zero_init, floats_tensor, ids_tensor
from ...test_pipeline_mixin import PipelineTesterMixin


if is_torch_available():
							import torch
							from torch import nn

							from transformers import MODEL_MAPPING, DPTForDepthEstimation, DPTForSemanticSegmentation, DPTModel
							from transformers.models.dpt.modeling_dpt import DPT_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
							from PIL import Image

							from transformers import DPTImageProcessor
class       _UpperCAmelCase					:

				"""simple docstring"""




				def __init__(     self						:    str,  lowerCamelCase						:    Dict,  lowerCamelCase						:    List[str]=2,  lowerCamelCase						:    List[str]=32,  lowerCamelCase						:    Tuple=16,  lowerCamelCase						:    List[Any]=3,  lowerCamelCase						:    List[Any]=True,  lowerCamelCase						:    str=True,  lowerCamelCase						:    Tuple=32,  lowerCamelCase						:    Dict=4,  lowerCamelCase						:    Dict=[0, 1, 2, 3],  lowerCamelCase						:    Union[str, Any]=4,  lowerCamelCase						:    Optional[int]=37,  lowerCamelCase						:    Optional[Any]="gelu",  lowerCamelCase						:    List[Any]=0.1,  lowerCamelCase						:    Optional[Any]=0.1,  lowerCamelCase						:    Optional[int]=0.02,  lowerCamelCase						:    str=3,  lowerCamelCase						:    str=[1, 384, 24, 24],  lowerCamelCase						:    Optional[int]=True,  lowerCamelCase						:    List[str]=None,  ):

								'''simple docstring'''
								lowercase__    =			parent
								lowercase__    =			batch_size
								lowercase__    =			image_size
								lowercase__    =			patch_size
								lowercase__    =			num_channels
								lowercase__    =			is_training
								lowercase__    =			use_labels
								lowercase__    =			hidden_size
								lowercase__    =			num_hidden_layers
								lowercase__    =			backbone_out_indices
								lowercase__    =			num_attention_heads
								lowercase__    =			intermediate_size
								lowercase__    =			hidden_act
								lowercase__    =			hidden_dropout_prob
								lowercase__    =			attention_probs_dropout_prob
								lowercase__    =			initializer_range
								lowercase__    =			num_labels
								lowercase__    =			backbone_featmap_shape
								lowercase__    =			scope
								lowercase__    =			is_hybrid
								# sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
								lowercase__    =			(image_size // patch_size) ** 2
								lowercase__    =			num_patches + 1




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )

								lowercase__    =			None
								if self.use_labels:
												lowercase__    =			ids_tensor([self.batch_size, self.image_size, self.image_size],  self.num_labels  )

								lowercase__    =			self.get_config()

								return config, pixel_values, labels




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__    =			{
								    '''global_padding''': '''same''',
								    '''layer_type''': '''bottleneck''',
								    '''depths''': [3, 4, 9],
								    '''out_features''': ['''stage1''', '''stage2''', '''stage3'''],
								    '''embedding_dynamic_padding''': True,
								    '''hidden_sizes''': [96, 192, 384, 768],
								    '''num_groups''': 2,
								}

								return DPTConfig(
								    image_size=self.image_size,  patch_size=self.patch_size,  num_channels=self.num_channels,  hidden_size=self.hidden_size,  num_hidden_layers=self.num_hidden_layers,  backbone_out_indices=self.backbone_out_indices,  num_attention_heads=self.num_attention_heads,  intermediate_size=self.intermediate_size,  hidden_act=self.hidden_act,  hidden_dropout_prob=self.hidden_dropout_prob,  attention_probs_dropout_prob=self.attention_probs_dropout_prob,  is_decoder=lowerCamelCase,  initializer_range=self.initializer_range,  is_hybrid=self.is_hybrid,  backbone_config=lowerCamelCase,  backbone_featmap_shape=self.backbone_featmap_shape,  )




				def 				lowercase__   (     self						:    str,  lowerCamelCase						:    Optional[Any],  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    Union[str, Any]  ):

								'''simple docstring'''
								lowercase__    =			DPTModel(config=lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(result.last_hidden_state.shape,  (self.batch_size, self.seq_length, self.hidden_size)  )




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

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DPTForDepthEstimation(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase  )
								self.parent.assertEqual(result.predicted_depth.shape,  (self.batch_size, self.image_size, self.image_size)  )




				def 				lowercase__   (     self						:    int,  lowerCamelCase						:    Any,  lowerCamelCase						:    Optional[int],  lowerCamelCase						:    int  ):

								'''simple docstring'''
								lowercase__    =			self.num_labels
								lowercase__    =			DPTForSemanticSegmentation(lowerCamelCase  )
								model.to(lowerCamelCase  )
								model.eval()
								lowercase__    =			model(lowerCamelCase,  labels=lowerCamelCase  )
								self.parent.assertEqual(
								    result.logits.shape,  (self.batch_size, self.num_labels, self.image_size, self.image_size)  )




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__    =			self.prepare_config_and_inputs()
								lowercase__ ,						lowercase__ ,						lowercase__    =			config_and_inputs
								lowercase__    =			{'''pixel_values''': pixel_values}
								return config, inputs_dict



@require_torch
class       _UpperCAmelCase					(       A__		,A__		,unittest.TestCase	):

				"""simple docstring"""




				lowercase__											=       (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				lowercase__											=       (
				    {
				        """depth-estimation""": DPTForDepthEstimation,
				        """feature-extraction""": DPTModel,
				        """image-segmentation""": DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				lowercase__											=       False
				lowercase__											=       False
				lowercase__											=       False




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

								'''simple docstring'''
								lowercase__    =			DPTModelTester(self  )
								lowercase__    =			ConfigTester(self,  config_class=lowerCamelCase,  has_text_modality=lowerCamelCase,  hidden_size=37  )




				def 				lowercase__   (     self						:    int  ):

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




				@unittest.skip(reason='''DPT does not use inputs_embeds'''  )
				def 				lowercase__   (     self						:    Union[str, Any]  ):

								'''simple docstring'''
								pass




				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

								for model_class in self.all_model_classes:
												lowercase__    =			model_class(lowerCamelCase  )
												self.assertIsInstance(model.get_input_embeddings(),  (nn.Module)  )
												lowercase__    =			model.get_output_embeddings()
												self.assertTrue(x is None or isinstance(lowerCamelCase,  nn.Linear  )  )




				def 				lowercase__   (     self						:    Optional[int]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

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

												lowercase__    =			['''pixel_values''']
												self.assertListEqual(arg_names[:1],  lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_model(*lowerCamelCase  )




				def 				lowercase__   (     self						:    Tuple  ):

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_depth_estimation(*lowerCamelCase  )




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

								'''simple docstring'''
								lowercase__    =			self.model_tester.prepare_config_and_inputs()
								self.model_tester.create_and_check_for_semantic_segmentation(*lowerCamelCase  )




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								for model_class in self.all_model_classes:
												if model_class.__name__ == "DPTForDepthEstimation":
																continue

												lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
												lowercase__    =			True

												if model_class in get_values(lowerCamelCase  ):
																continue

												lowercase__    =			model_class(lowerCamelCase  )
												model.to(lowerCamelCase  )
												model.train()
												lowercase__    =			self._prepare_for_class(lowerCamelCase,  lowerCamelCase,  return_labels=lowerCamelCase  )
												lowercase__    =			model(**lowerCamelCase  ).loss
												loss.backward()




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								for model_class in self.all_model_classes:
												if model_class.__name__ == "DPTForDepthEstimation":
																continue

												lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
												lowercase__    =			False
												lowercase__    =			True

												if model_class in get_values(lowerCamelCase  ) or not model_class.supports_gradient_checkpointing:
																continue
												lowercase__    =			model_class(lowerCamelCase  )
												model.to(lowerCamelCase  )
												model.gradient_checkpointing_enable()
												model.train()
												lowercase__    =			self._prepare_for_class(lowerCamelCase,  lowerCamelCase,  return_labels=lowerCamelCase  )
												lowercase__    =			model(**lowerCamelCase  ).loss
												loss.backward()




				def 				lowercase__   (     self						:    List[str]  ):

								'''simple docstring'''
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()

								lowercase__    =			_config_zero_init(lowerCamelCase  )
								for model_class in self.all_model_classes:
												lowercase__    =			model_class(config=lowerCamelCase  )
												# Skip the check for the backbone
												lowercase__    =			[]
												for name, module in model.named_modules():
																if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																				lowercase__    =			[F"""{name}.{key}""" for key in module.state_dict().keys()]
																				break

												for name, param in model.named_parameters():
																if param.requires_grad:
																				if name in backbone_params:
																								continue
																				self.assertIn(
																				    ((param.data.mean() * 1E9).round() / 1E9).item(),  [0.0, 1.0],  msg=F"""Parameter {name} of model {model_class} seems not properly initialized""",  )




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

								'''simple docstring'''
								pass




				@slow
				def 				lowercase__   (     self						:    Dict  ):

								'''simple docstring'''
								for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[1:]:
												lowercase__    =			DPTModel.from_pretrained(lowerCamelCase  )
												self.assertIsNotNone(lowerCamelCase  )




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

								'''simple docstring'''
								# We do this test only for DPTForDepthEstimation since it is the only model that uses readout_type
								lowercase__ ,						lowercase__    =			self.model_tester.prepare_config_and_inputs_for_common()
								lowercase__    =			'''add'''
								with self.assertRaises(lowerCamelCase  ):
												lowercase__    =			DPTForDepthEstimation(lowerCamelCase  )






def   a			(						):






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




@require_torch
@require_vision
@slow
class       _UpperCAmelCase					(       unittest.TestCase	):

				"""simple docstring"""




				def 				lowercase__   (     self						:    Optional[Any]  ):

								'''simple docstring'''
								lowercase__    =			DPTImageProcessor.from_pretrained('''Intel/dpt-hybrid-midas'''  )
								lowercase__    =			DPTForDepthEstimation.from_pretrained('''Intel/dpt-hybrid-midas'''  ).to(lowerCamelCase  )

								lowercase__    =			prepare_img()
								lowercase__    =			image_processor(images=lowerCamelCase,  return_tensors='''pt'''  ).to(lowerCamelCase  )

								# forward pass
								with torch.no_grad():
												lowercase__    =			model(**lowerCamelCase  )
												lowercase__    =			outputs.predicted_depth

								# verify the predicted depth
								lowercase__    =			torch.Size((1, 384, 384)  )
								self.assertEqual(predicted_depth.shape,  lowerCamelCase  )

								lowercase__    =			torch.tensor(
								    [[[5.6437, 5.6146, 5.6511], [5.4371, 5.5649, 5.5958], [5.5215, 5.5184, 5.5293]]]  ).to(lowerCamelCase  )

								self.assertTrue(torch.allclose(outputs.predicted_depth[:3, :3, :3] / 100,  lowerCamelCase,  atol=1E-4  )  )




