






"""simple docstring"""







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

				def __init__(     self       :    List[Any]       ,    _lowercase       :    List[str]       ,    _lowercase       :    Any=2       ,    _lowercase       :    Tuple=3_2       ,    _lowercase       :    str=1_6       ,    _lowercase       :    List[str]=3       ,    _lowercase       :    Dict=True       ,    _lowercase       :    Optional[int]=True       ,    _lowercase       :    Optional[Any]=3_2       ,    _lowercase       :    int=4       ,    _lowercase       :    Union[str, Any]=[0, 1, 2, 3]       ,    _lowercase       :    Tuple=4       ,    _lowercase       :    Any=3_7       ,    _lowercase       :    Union[str, Any]="gelu"       ,    _lowercase       :    str=0.1       ,    _lowercase       :    Any=0.1       ,    _lowercase       :    Tuple=0.02       ,    _lowercase       :    Dict=3       ,    _lowercase       :    Union[str, Any]=False       ,    _lowercase       :    Union[str, Any]=None       ,    ):


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

				def        A (     self       :    List[Any]     ):


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

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

										UpperCAmelCase__						=		self.get_config()

										return config, pixel_values, labels

				def        A (     self       :    List[Any]     ):


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

				def        A (     self       :    List[str]       ,    _lowercase       :    Optional[int]       ,    _lowercase       :    Tuple       ,    _lowercase       :    str     ):


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

				def        A (     self       :    Tuple       ,    _lowercase       :    Union[str, Any]       ,    _lowercase       :    Optional[int]       ,    _lowercase       :    Optional[Any]     ):


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

				def        A (     self       :    Tuple       ,    _lowercase       :    str       ,    _lowercase       :    Any       ,    _lowercase       :    Union[str, Any]     ):


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

				def        A (     self       :    int     ):


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


@require_torch
class 			_lowercase		(   lowerCAmelCase__      ,      lowerCAmelCase__      ,      unittest.TestCase  ):
				lowerCamelCase__						=       (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
				lowerCamelCase__						=       (
				    {
				        """depth-estimation""": DPTForDepthEstimation,
				        """feature-extraction""": DPTModel,
				        """image-segmentation""": DPTForSemanticSegmentation,
				    }
				    if is_torch_available()
				    else {}
				)

				lowerCamelCase__						=       False
				lowerCamelCase__						=       False
				lowerCamelCase__						=       False

				def        A (     self       :    str     ):


										'''simple docstring'''
										UpperCAmelCase__						=		DPTModelTester(self     )
										UpperCAmelCase__						=		ConfigTester(self       ,    config_class=lowerCAmelCase_       ,    has_text_modality=lowerCAmelCase_       ,    hidden_size=3_7     )

				def        A (     self       :    int     ):


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

				@unittest.skip(reason="""DPT does not use inputs_embeds"""     )
				def        A (     self       :    Dict     ):


										'''simple docstring'''
										pass

				def        A (     self       :    str     ):


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

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

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


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

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

																UpperCAmelCase__						=		["""pixel_values"""]
																self.assertListEqual(arg_names[:1]       ,    lowerCAmelCase_     )

				def        A (     self       :    Dict     ):


										'''simple docstring'''
										UpperCAmelCase__						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_model(*lowerCAmelCase_     )

				def        A (     self       :    Optional[int]     ):


										'''simple docstring'''
										UpperCAmelCase__						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_depth_estimation(*lowerCAmelCase_     )

				def        A (     self       :    Any     ):


										'''simple docstring'''
										UpperCAmelCase__						=		self.model_tester.prepare_config_and_inputs()
										self.model_tester.create_and_check_for_semantic_segmentation(*lowerCAmelCase_     )

				def        A (     self       :    Optional[int]     ):


										'''simple docstring'''






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

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

																if model_class in get_values(lowerCAmelCase_     ):
																						continue

																UpperCAmelCase__						=		model_class(lowerCAmelCase_     )
																model.to(lowerCAmelCase_     )
																model.train()
																UpperCAmelCase__						=		self._prepare_for_class(lowerCAmelCase_       ,    lowerCAmelCase_       ,    return_labels=lowerCAmelCase_     )
																UpperCAmelCase__						=		model(**lowerCAmelCase_     ).loss
																loss.backward()

				def        A (     self       :    str     ):


										'''simple docstring'''






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

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

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

				def        A (     self       :    Dict     ):


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

										UpperCAmelCase__						=		_config_zero_init(lowerCAmelCase_     )
										for model_class in self.all_model_classes:
																UpperCAmelCase__						=		model_class(config=lowerCAmelCase_     )
																# Skip the check for the backbone
																UpperCAmelCase__						=		[]
																for name, module in model.named_modules():
																						if module.__class__.__name__ == "DPTViTHybridEmbeddings":
																												UpperCAmelCase__						=		[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        A (     self       :    int     ):


										'''simple docstring'''
										pass

				@slow
				def        A (     self       :    Union[str, Any]     ):


										'''simple docstring'''






										for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
																UpperCAmelCase__						=		DPTModel.from_pretrained(lowerCAmelCase_     )
																self.assertIsNotNone(lowerCAmelCase_     )


def   a__      (		)->	Dict:
						UpperCAmelCase__						=		Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""			)
						return image







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

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


										'''simple docstring'''
										UpperCAmelCase__						=		DPTImageProcessor.from_pretrained("""Intel/dpt-large"""     )
										UpperCAmelCase__						=		DPTForDepthEstimation.from_pretrained("""Intel/dpt-large"""     ).to(lowerCAmelCase_     )

										UpperCAmelCase__						=		prepare_img()
										UpperCAmelCase__						=		image_processor(images=lowerCAmelCase_       ,    return_tensors="""pt"""     ).to(lowerCAmelCase_     )

										# forward pass
										with torch.no_grad():
																UpperCAmelCase__						=		model(**lowerCAmelCase_     )
																UpperCAmelCase__						=		outputs.predicted_depth

										# verify the predicted depth
										UpperCAmelCase__						=		torch.Size((1, 3_8_4, 3_8_4)     )
										self.assertEqual(predicted_depth.shape       ,    lowerCAmelCase_     )

										UpperCAmelCase__						=		torch.tensor(
										    [[6.3199, 6.3629, 6.4148], [6.3850, 6.3615, 6.4166], [6.3519, 6.3176, 6.3575]]     ).to(lowerCAmelCase_     )

										self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]       ,    lowerCAmelCase_       ,    atol=1e-4     )     )

				def        A (     self       :    List[str]     ):


										'''simple docstring'''
										UpperCAmelCase__						=		DPTImageProcessor.from_pretrained("""Intel/dpt-large-ade"""     )
										UpperCAmelCase__						=		DPTForSemanticSegmentation.from_pretrained("""Intel/dpt-large-ade"""     ).to(lowerCAmelCase_     )

										UpperCAmelCase__						=		prepare_img()
										UpperCAmelCase__						=		image_processor(images=lowerCAmelCase_       ,    return_tensors="""pt"""     ).to(lowerCAmelCase_     )

										# forward pass
										with torch.no_grad():
																UpperCAmelCase__						=		model(**lowerCAmelCase_     )

										# verify the logits
										UpperCAmelCase__						=		torch.Size((1, 1_5_0, 4_8_0, 4_8_0)     )
										self.assertEqual(outputs.logits.shape       ,    lowerCAmelCase_     )

										UpperCAmelCase__						=		torch.tensor(
										    [[4.0480, 4.2420, 4.4360], [4.3124, 4.5693, 4.8261], [4.5768, 4.8965, 5.2163]]     ).to(lowerCAmelCase_     )

										self.assertTrue(torch.allclose(outputs.logits[0, 0, :3, :3]       ,    lowerCAmelCase_       ,    atol=1e-4     )     )

				def        A (     self       :    List[str]     ):


										'''simple docstring'''
										UpperCAmelCase__						=		DPTImageProcessor.from_pretrained("""Intel/dpt-large-ade"""     )
										UpperCAmelCase__						=		DPTForSemanticSegmentation.from_pretrained("""Intel/dpt-large-ade"""     ).to(lowerCAmelCase_     )

										UpperCAmelCase__						=		prepare_img()
										UpperCAmelCase__						=		image_processor(images=lowerCAmelCase_       ,    return_tensors="""pt"""     ).to(lowerCAmelCase_     )

										# forward pass
										with torch.no_grad():
																UpperCAmelCase__						=		model(**lowerCAmelCase_     )

										UpperCAmelCase__						=		outputs.logits.detach().cpu()

										UpperCAmelCase__						=		image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_       ,    target_sizes=[(5_0_0, 3_0_0)]     )
										UpperCAmelCase__						=		torch.Size((5_0_0, 3_0_0)     )
										self.assertEqual(segmentation[0].shape       ,    lowerCAmelCase_     )

										UpperCAmelCase__						=		image_processor.post_process_semantic_segmentation(outputs=lowerCAmelCase_     )
										UpperCAmelCase__						=		torch.Size((4_8_0, 4_8_0)     )
										self.assertEqual(segmentation[0].shape       ,    lowerCAmelCase_     )


"""simple docstring"""







import unittest

import numpy as np

from transformers import is_tf_available
from transformers.testing_utils import require_tf


if is_tf_available():
						import tensorflow as tf

						from transformers.activations_tf import get_tf_activation


@require_tf
class 			_lowercase		(   unittest.TestCase  ):

				def        A (     self       :    Any     ):


										'''simple docstring'''
										UpperCAmelCase__						=		tf.constant([-1_0_0, -1.0, -0.1, 0, 0.1, 1.0, 100.0]     )
										UpperCAmelCase__						=		get_tf_activation("""gelu"""     )
										UpperCAmelCase__						=		get_tf_activation("""gelu_10"""     )

										UpperCAmelCase__						=		gelu(_lowercase     )
										UpperCAmelCase__						=		geluaa(_lowercase     )

										UpperCAmelCase__						=		tf.where(y_gelu_aa < 10.0       ,    1.0       ,    0.0     )

										self.assertEqual(tf.math.reduce_max(_lowercase     ).numpy().item()       ,    10.0     )
										self.assertTrue(np.allclose(y_gelu * clipped_mask       ,    y_gelu_aa * clipped_mask     )     )

				def        A (     self       :    Optional[Any]     ):


										'''simple docstring'''
										get_tf_activation("""gelu"""     )
										get_tf_activation("""gelu_10"""     )
										get_tf_activation("""gelu_fast"""     )
										get_tf_activation("""gelu_new"""     )
										get_tf_activation("""glu"""     )
										get_tf_activation("""mish"""     )
										get_tf_activation("""quick_gelu"""     )
										get_tf_activation("""relu"""     )
										get_tf_activation("""sigmoid"""     )
										get_tf_activation("""silu"""     )
										get_tf_activation("""swish"""     )
										get_tf_activation("""tanh"""     )
										with self.assertRaises(_lowercase     ):
																get_tf_activation("""bogus"""     )
										with self.assertRaises(_lowercase     ):
																get_tf_activation(_lowercase     )

