




'''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       _a  :
       def __init__(     self						:     Any       ,    lowercase						:     str       ,    lowercase						:     List[str]=2       ,    lowercase						:     Tuple=32       ,    lowercase						:     Any=16       ,    lowercase						:     List[str]=3       ,    lowercase						:     Optional[Any]=True       ,    lowercase						:     Optional[int]=True       ,    lowercase						:     Optional[int]=32       ,    lowercase						:     List[str]=4       ,    lowercase						:     Tuple=[0, 1, 2, 3]       ,    lowercase						:     Any=4       ,    lowercase						:     List[str]=37       ,    lowercase						:     Union[str, Any]="gelu"       ,    lowercase						:     int=0.1       ,    lowercase						:     List[Any]=0.1       ,    lowercase						:     Union[str, Any]=0.02       ,    lowercase						:     Optional[int]=3       ,    lowercase						:     str=False       ,    lowercase						:     Tuple=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						:     str    ):



           '''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[str]    ):



           '''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=lowercase       ,    initializer_range=self.initializer_range       ,    is_hybrid=self.is_hybrid       ,    )
       def    A				(     self						:     List[str]       ,    lowercase						:     Dict       ,    lowercase						:     Tuple       ,    lowercase						:     Union[str, Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		DPTModel(config=lowercase    )
           model.to(lowercase    )
           model.eval()
           UpperCAmelCase      	=		model(lowercase    )
           self.parent.assertEqual(result.last_hidden_state.shape       ,    (self.batch_size, self.seq_length, self.hidden_size)    )
       def    A				(     self						:     Union[str, Any]       ,    lowercase						:     Optional[Any]       ,    lowercase						:     Optional[int]       ,    lowercase						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.num_labels
           UpperCAmelCase      	=		DPTForDepthEstimation(lowercase    )
           model.to(lowercase    )
           model.eval()
           UpperCAmelCase      	=		model(lowercase    )
           self.parent.assertEqual(result.predicted_depth.shape       ,    (self.batch_size, self.image_size, self.image_size)    )
       def    A				(     self						:     Dict       ,    lowercase						:     str       ,    lowercase						:     Optional[int]       ,    lowercase						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.num_labels
           UpperCAmelCase      	=		DPTForSemanticSegmentation(lowercase    )
           model.to(lowercase    )
           model.eval()
           UpperCAmelCase      	=		model(lowercase       ,    labels=lowercase    )
           self.parent.assertEqual(
               result.logits.shape       ,    (self.batch_size, self.num_labels, self.image_size, self.image_size)    )







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



           '''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       _a  (     __a							,							__a							,							unittest.TestCase			):
       __a    :					List[str]           = (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
       __a    :					List[str]           = (
           {
               """depth-estimation""": DPTForDepthEstimation,
               """feature-extraction""": DPTModel,
               """image-segmentation""": DPTForSemanticSegmentation,
           }
           if is_torch_available()
           else {}
       )

       __a    :					Optional[int]           = False
       __a    :					Union[str, Any]           = False
       __a    :					List[str]           = False
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           UpperCAmelCase      	=		DPTModelTester(self    )
           UpperCAmelCase      	=		ConfigTester(self       ,    config_class=lowercase       ,    has_text_modality=lowercase       ,    hidden_size=37    )
       def    A				(     self						:     Tuple    ):



           '''simple docstring'''

           self.config_tester.run_common_tests()
       @unittest.skip(reason='''DPT does not use inputs_embeds'''    )
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           pass
       def    A				(     self						:     Optional[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(lowercase    )
               self.assertIsInstance(model.get_input_embeddings()       ,    (nn.Module)    )
               UpperCAmelCase      	=		model.get_output_embeddings()
               self.assertTrue(x is None or isinstance(lowercase       ,    nn.Linear    )    )
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase	,					UpperCAmelCase      	=		self.model_tester.prepare_config_and_inputs_for_common()

           for model_class in self.all_model_classes:
               UpperCAmelCase      	=		model_class(lowercase    )
               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]       ,    lowercase    )
       def    A				(     self						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_model(*lowercase    )
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_depth_estimation(*lowercase    )
       def    A				(     self						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.model_tester.prepare_config_and_inputs()
           self.model_tester.create_and_check_for_semantic_segmentation(*lowercase    )
       def    A				(     self						:     List[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      	=		True

               if model_class in get_values(lowercase    ):
                   continue

               UpperCAmelCase      	=		model_class(lowercase    )
               model.to(lowercase    )
               model.train()
               UpperCAmelCase      	=		self._prepare_for_class(lowercase       ,    lowercase       ,    return_labels=lowercase    )
               UpperCAmelCase      	=		model(**lowercase    ).loss
               loss.backward()
       def    A				(     self						:     Tuple    ):



           '''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(lowercase    ) or not model_class.supports_gradient_checkpointing:
                   continue
               UpperCAmelCase      	=		model_class(lowercase    )
               model.to(lowercase    )
               model.gradient_checkpointing_enable()
               model.train()
               UpperCAmelCase      	=		self._prepare_for_class(lowercase       ,    lowercase       ,    return_labels=lowercase    )
               UpperCAmelCase      	=		model(**lowercase    ).loss
               loss.backward()
       def    A				(     self						:     Union[str, Any]    ):



           '''simple docstring'''

           UpperCAmelCase	,					UpperCAmelCase      	=		self.model_tester.prepare_config_and_inputs_for_common()

           UpperCAmelCase      	=		_config_zero_init(lowercase    )
           for model_class in self.all_model_classes:
               UpperCAmelCase      	=		model_class(config=lowercase    )
               # 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						:     List[Any]    ):



           '''simple docstring'''

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






def 						snake_case_							():
    UpperCAmelCase      	=		Image.open('''./tests/fixtures/tests_samples/COCO/000000039769.png'''					)
    return image







@require_torch
@require_vision
@slow
class       _a  (     unittest.TestCase			):
       def    A				(     self						:     Optional[int]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		DPTImageProcessor.from_pretrained('''Intel/dpt-large'''    )
           UpperCAmelCase      	=		DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''    ).to(lowercase    )

           UpperCAmelCase      	=		prepare_img()
           UpperCAmelCase      	=		image_processor(images=lowercase       ,    return_tensors='''pt'''    ).to(lowercase    )

           # forward pass
           with torch.no_grad():
               UpperCAmelCase      	=		model(**lowercase    )
               UpperCAmelCase      	=		outputs.predicted_depth

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

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

           self.assertTrue(torch.allclose(outputs.predicted_depth[0, :3, :3]       ,    lowercase       ,    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(lowercase    )

           UpperCAmelCase      	=		prepare_img()
           UpperCAmelCase      	=		image_processor(images=lowercase       ,    return_tensors='''pt'''    ).to(lowercase    )

           # forward pass
           with torch.no_grad():
               UpperCAmelCase      	=		model(**lowercase    )

           # verify the logits
           UpperCAmelCase      	=		torch.Size((1, 150, 480, 480)    )
           self.assertEqual(outputs.logits.shape       ,    lowercase    )

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

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







       def    A				(     self						:     List[Any]    ):



           '''simple docstring'''

           UpperCAmelCase      	=		DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''    )
           UpperCAmelCase      	=		DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''    ).to(lowercase    )

           UpperCAmelCase      	=		prepare_img()
           UpperCAmelCase      	=		image_processor(images=lowercase       ,    return_tensors='''pt'''    ).to(lowercase    )

           # forward pass
           with torch.no_grad():
               UpperCAmelCase      	=		model(**lowercase    )

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

           UpperCAmelCase      	=		image_processor.post_process_semantic_segmentation(outputs=lowercase       ,    target_sizes=[(500, 300)]    )
           UpperCAmelCase      	=		torch.Size((500, 300)    )
           self.assertEqual(segmentation[0].shape       ,    lowercase    )

           UpperCAmelCase      	=		image_processor.post_process_semantic_segmentation(outputs=lowercase    )
           UpperCAmelCase      	=		torch.Size((480, 480)    )
           self.assertEqual(segmentation[0].shape       ,    lowercase    )










'''simple docstring'''







import unittest

from transformers import is_torch_available, load_tool

from .test_tools_common import ToolTesterMixin


if is_torch_available():
   import torch


class       _a  (     unittest.TestCase							,							__a			):
       def    A				(     self						:     str    ):



           '''simple docstring'''

           UpperCAmelCase      	=		load_tool('''speech-to-text'''    )
           self.tool.setup()
       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tool(torch.ones(3_000    )    )
           self.assertEqual(lowercase       ,    ''' you'''    )







       def    A				(     self						:     Dict    ):



           '''simple docstring'''

           UpperCAmelCase      	=		self.tool(audio=torch.ones(3_000    )    )
           self.assertEqual(lowercase       ,    ''' you'''    )




