


'''simple docstring'''




from typing import TYPE_CHECKING

from ...file_utils import _LazyModule, is_tokenizers_available, is_torch_available, is_vision_available
from ...utils import OptionalDependencyNotAvailable


_a   :   int												=   {"configuration_dpt": ["DPT_PRETRAINED_CONFIG_ARCHIVE_MAP", "DPTConfig"]}

try:
       if not is_vision_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _a   :   Union[str, Any]												=   ["DPTFeatureExtractor"]
       _a   :   List[str]												=   ["DPTImageProcessor"]

try:
       if not is_torch_available():
              raise OptionalDependencyNotAvailable()
except OptionalDependencyNotAvailable:
       pass
else:
       _a   :   List[str]												=   [
           "DPT_PRETRAINED_MODEL_ARCHIVE_LIST",
           "DPTForDepthEstimation",
           "DPTForSemanticSegmentation",
           "DPTModel",
           "DPTPreTrainedModel",
       ]


if TYPE_CHECKING:
       from .configuration_dpt import DPT_PRETRAINED_CONFIG_ARCHIVE_MAP, DPTConfig

       try:
              if not is_vision_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .feature_extraction_dpt import DPTFeatureExtractor
              from .image_processing_dpt import DPTImageProcessor

       try:
              if not is_torch_available():
                     raise OptionalDependencyNotAvailable()
       except OptionalDependencyNotAvailable:
              pass
       else:
              from .modeling_dpt import (
                  DPT_PRETRAINED_MODEL_ARCHIVE_LIST,
                  DPTForDepthEstimation,
                  DPTForSemanticSegmentation,
                  DPTModel,
                  DPTPreTrainedModel,
              )


else:
       import sys

       _a   :   List[str]												=   _LazyModule(__name__, globals()["__file__"], _import_structure, module_spec=__spec__)











import inspect
import unittest

from transformers import YolosConfig
from transformers.testing_utils import require_torch, require_vision, slow, torch_device
from transformers.utils import cached_property, is_torch_available, is_vision_available

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


if is_torch_available():
    import torch
    from torch import nn

    from transformers import YolosForObjectDetection, YolosModel
    from transformers.models.yolos.modeling_yolos import YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST


if is_vision_available():
    from PIL import Image

    from transformers import AutoImageProcessor

class     snake_case_		:






 '''simple docstring'''





 def __init__(  self,		A_,		A_=13,		A_=[30, 30],		A_=2,		A_=3,		A_=True,		A_=True,		A_=32,		A_=5,		A_=4,		A_=37,		A_="gelu",		A_=0.1,		A_=0.1,		A_=10,		A_=0.02,		A_=3,		A_=None,		A_=8,		A_=10,		)	->       List[str]:
    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__						=num_attention_heads
    UpperCAmelCase__						=intermediate_size
    UpperCAmelCase__						=hidden_act
    UpperCAmelCase__						=hidden_dropout_prob
    UpperCAmelCase__						=attention_probs_dropout_prob
    UpperCAmelCase__						=type_sequence_label_size
    UpperCAmelCase__						=initializer_range
    UpperCAmelCase__						=num_labels
    UpperCAmelCase__						=scope
    UpperCAmelCase__						=n_targets
    UpperCAmelCase__						=num_detection_tokens
    # we set the expected sequence length (which is used in several tests)
    # expected sequence length = num_patches + 1 (we add 1 for the [CLS] token) + num_detection_tokens
    UpperCAmelCase__						=(image_size[1] // patch_size) * (image_size[0] // patch_size)
    UpperCAmelCase__						=num_patches + 1 + self.num_detection_tokens

 def  __UpperCAmelCase						(  self		)	->       Dict:
    UpperCAmelCase__						=floats_tensor([self.batch_size, self.num_channels, self.image_size[0], self.image_size[1]]		)

    UpperCAmelCase__						=None
    if self.use_labels:
       # labels is a list of Dict (each Dict being the labels for a given example in the batch)
       UpperCAmelCase__						=[]
       for i in range(self.batch_size		):
          UpperCAmelCase__						={}
          UpperCAmelCase__						=torch.randint(
              high=self.num_labels,		size=(self.n_targets,),		device=A_		)
          UpperCAmelCase__						=torch.rand(self.n_targets,		4,		device=A_		)
          labels.append(A_		)

    UpperCAmelCase__						=self.get_config()

    return config, pixel_values, labels

 def  __UpperCAmelCase						(  self		)	->       Dict:
    return YolosConfig(
        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,		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=A_,		initializer_range=self.initializer_range,		num_detection_tokens=self.num_detection_tokens,		num_labels=self.num_labels,		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       Tuple:
    UpperCAmelCase__						=YolosModel(config=A_		)
    model.to(A_		)
    model.eval()
    UpperCAmelCase__						=model(A_		)
    self.parent.assertEqual(
        result.last_hidden_state.shape,		(self.batch_size, self.expected_seq_len, self.hidden_size)		)

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_		)	->       Union[str, Any]:
    UpperCAmelCase__						=YolosForObjectDetection(A_		)
    model.to(A_		)
    model.eval()

    UpperCAmelCase__						=model(pixel_values=A_		)
    UpperCAmelCase__						=model(A_		)

    self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
    self.parent.assertEqual(result.pred_boxes.shape,		(self.batch_size, self.num_detection_tokens, 4)		)

    UpperCAmelCase__						=model(pixel_values=A_,		labels=A_		)

    self.parent.assertEqual(result.loss.shape,		()		)
    self.parent.assertEqual(result.logits.shape,		(self.batch_size, self.num_detection_tokens, self.num_labels + 1)		)
    self.parent.assertEqual(result.pred_boxes.shape,		(self.batch_size, self.num_detection_tokens, 4)		)






 def  __UpperCAmelCase						(  self		)	->       Tuple:
    UpperCAmelCase__						=self.prepare_config_and_inputs()
    UpperCAmelCase__			,							UpperCAmelCase__			,							UpperCAmelCase__						=config_and_inputs
    UpperCAmelCase__						={"pixel_values": pixel_values}
    return config, inputs_dict

@require_torch
class     snake_case_		(   a,		a,		unittest.TestCase							):






 '''simple docstring'''





 __UpperCamelCase       =      (YolosModel, YolosForObjectDetection) if is_torch_available() else ()
 __UpperCamelCase       =      (
     {'feature-extraction': YolosModel, 'object-detection': YolosForObjectDetection} if is_torch_available() else {}
 )

 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False
 __UpperCamelCase       =      False

 def  __UpperCAmelCase						(  self,		A_,		A_,		A_=False		)	->       Dict:
    UpperCAmelCase__						=super()._prepare_for_class(A_,		A_,		return_labels=A_		)

    if return_labels:
       if model_class.__name__ == "YolosForObjectDetection":
          UpperCAmelCase__						=[]
          for i in range(self.model_tester.batch_size		):
             UpperCAmelCase__						={}
             UpperCAmelCase__						=torch.ones(
                 size=(self.model_tester.n_targets,),		device=A_,		dtype=torch.long		)
             UpperCAmelCase__						=torch.ones(
                 self.model_tester.n_targets,		4,		device=A_,		dtype=torch.float		)
             labels.append(A_		)
          UpperCAmelCase__						=labels

    return inputs_dict

 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						=YolosModelTester(self		)
    UpperCAmelCase__						=ConfigTester(self,		config_class=A_,		has_text_modality=A_,		hidden_size=37		)

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    self.config_tester.run_common_tests()

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    # YOLOS does not use inputs_embeds
    pass

 def  __UpperCAmelCase						(  self		)	->       Any:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

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

 def  __UpperCAmelCase						(  self		)	->       str:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=model_class(A_		)
       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],		A_		)

 def  __UpperCAmelCase						(  self		)	->       Optional[int]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_model(*A_		)

 def  __UpperCAmelCase						(  self		)	->       Dict:
    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()
    UpperCAmelCase__						=True

    # in YOLOS, the seq_len is different
    UpperCAmelCase__						=self.model_tester.expected_seq_len
    for model_class in self.all_model_classes:
       UpperCAmelCase__						=True
       UpperCAmelCase__						=False
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)
       UpperCAmelCase__						=outputs.attentions
       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)

       # check that output_attentions also work using config
       del inputs_dict["output_attentions"]
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)
       UpperCAmelCase__						=outputs.attentions
       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)

       self.assertListEqual(
           list(attentions[0].shape[-3:]		),		[self.model_tester.num_attention_heads, seq_len, seq_len],		)
       UpperCAmelCase__						=len(A_		)

       # Check attention is always last and order is fine
       UpperCAmelCase__						=True
       UpperCAmelCase__						=True
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()
       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)

       UpperCAmelCase__						=1
       self.assertEqual(out_len + added_hidden_states,		len(A_		)		)

       UpperCAmelCase__						=outputs.attentions

       self.assertEqual(len(A_		),		self.model_tester.num_hidden_layers		)
       self.assertListEqual(
           list(self_attentions[0].shape[-3:]		),		[self.model_tester.num_attention_heads, seq_len, seq_len],		)

 def  __UpperCAmelCase						(  self		)	->       List[str]:
    def check_hidden_states_output(A_,		A_,		A_		):
       UpperCAmelCase__						=model_class(A_		)
       model.to(A_		)
       model.eval()

       with torch.no_grad():
          UpperCAmelCase__						=model(**self._prepare_for_class(A_,		A_		)		)

       UpperCAmelCase__						=outputs.hidden_states

       UpperCAmelCase__						=getattr(
           self.model_tester,		"expected_num_hidden_layers",		self.model_tester.num_hidden_layers + 1		)
       self.assertEqual(len(A_		),		A_		)

       # YOLOS has a different seq_length
       UpperCAmelCase__						=self.model_tester.expected_seq_len

       self.assertListEqual(
           list(hidden_states[0].shape[-2:]		),		[seq_length, self.model_tester.hidden_size],		)

    UpperCAmelCase__			,							UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs_for_common()

    for model_class in self.all_model_classes:
       UpperCAmelCase__						=True
       check_hidden_states_output(A_,		A_,		A_		)

       # check that output_hidden_states also work using config
       del inputs_dict["output_hidden_states"]
       UpperCAmelCase__						=True

       check_hidden_states_output(A_,		A_,		A_		)

 def  __UpperCAmelCase						(  self		)	->       Union[str, Any]:
    UpperCAmelCase__						=self.model_tester.prepare_config_and_inputs()
    self.model_tester.create_and_check_for_object_detection(*A_		)






 @slow
 def  __UpperCAmelCase						(  self		)	->       Any:
    for model_name in YOLOS_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
       UpperCAmelCase__						=YolosModel.from_pretrained(A_		)
       self.assertIsNotNone(A_		)






def 				_UpperCAmelCase			(    ):




   '''simple docstring'''

   UpperCAmelCase__						=Image.open("./tests/fixtures/tests_samples/COCO/000000039769.png"     )
   return image




@require_torch
@require_vision
class     snake_case_		(   unittest.TestCase							):






 '''simple docstring'''





 @cached_property
 def  __UpperCAmelCase						(  self		)	->       Any:
    return AutoImageProcessor.from_pretrained("hustvl/yolos-small"		) if is_vision_available() else None






 @slow
 def  __UpperCAmelCase						(  self		)	->       List[Any]:
    UpperCAmelCase__						=YolosForObjectDetection.from_pretrained("hustvl/yolos-small"		).to(A_		)

    UpperCAmelCase__						=self.default_image_processor
    UpperCAmelCase__						=prepare_img()
    UpperCAmelCase__						=image_processor(images=A_,		return_tensors="pt"		).to(A_		)

    # forward pass
    with torch.no_grad():
       UpperCAmelCase__						=model(inputs.pixel_values		)

    # verify outputs
    UpperCAmelCase__						=torch.Size((1, 100, 92)		)
    self.assertEqual(outputs.logits.shape,		A_		)

    UpperCAmelCase__						=torch.tensor(
        [[-24.02_48, -10.30_24, -14.82_90], [-42.03_92, -16.82_00, -27.43_34], [-27.27_43, -11.81_54, -18.71_48]],		device=A_,		)
    UpperCAmelCase__						=torch.tensor(
        [[0.25_59, 0.54_55, 0.47_06], [0.29_89, 0.72_79, 0.18_75], [0.77_32, 0.40_17, 0.44_62]],		device=A_		)
    self.assertTrue(torch.allclose(outputs.logits[0, :3, :3],		A_,		atol=1E-4		)		)
    self.assertTrue(torch.allclose(outputs.pred_boxes[0, :3, :3],		A_,		atol=1E-4		)		)

    # verify postprocessing
    UpperCAmelCase__						=image_processor.post_process_object_detection(
        A_,		threshold=0.3,		target_sizes=[image.size[::-1]]		)[0]
    UpperCAmelCase__						=torch.tensor([0.99_94, 0.97_90, 0.99_64, 0.99_72, 0.98_61]		).to(A_		)
    UpperCAmelCase__						=[75, 75, 17, 63, 17]
    UpperCAmelCase__						=torch.tensor([3_35.06_09, 79.38_48, 3_75.42_16, 1_87.24_95]		).to(A_		)

    self.assertEqual(len(results["scores"]		),		5		)
    self.assertTrue(torch.allclose(results["scores"],		A_,		atol=1E-4		)		)
    self.assertSequenceEqual(results["labels"].tolist(),		A_		)
    self.assertTrue(torch.allclose(results["boxes"][0, :],		A_		)		)



