






"""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					:							List[str]	,						__SCREAMING_SNAKE_CASE					:							Dict	,						__SCREAMING_SNAKE_CASE					:							Optional[int]=2	,						__SCREAMING_SNAKE_CASE					:							Dict=32	,						__SCREAMING_SNAKE_CASE					:							Union[str, Any]=16	,						__SCREAMING_SNAKE_CASE					:							List[str]=3	,						__SCREAMING_SNAKE_CASE					:							Dict=True	,						__SCREAMING_SNAKE_CASE					:							List[str]=True	,						__SCREAMING_SNAKE_CASE					:							str=32	,						__SCREAMING_SNAKE_CASE					:							Dict=4	,						__SCREAMING_SNAKE_CASE					:							Dict=[0, 1, 2, 3]	,						__SCREAMING_SNAKE_CASE					:							List[str]=4	,						__SCREAMING_SNAKE_CASE					:							List[Any]=37	,						__SCREAMING_SNAKE_CASE					:							int="gelu"	,						__SCREAMING_SNAKE_CASE					:							Dict=0.1	,						__SCREAMING_SNAKE_CASE					:							Dict=0.1	,						__SCREAMING_SNAKE_CASE					:							Tuple=0.02	,						__SCREAMING_SNAKE_CASE					:							Optional[int]=3	,						__SCREAMING_SNAKE_CASE					:							Any=False	,						__SCREAMING_SNAKE_CASE					:							Any=None	,						)					->		Union[str, Any]:
      lowerCamelCase_   					=						parent
      lowerCamelCase_   					=						batch_size
      lowerCamelCase_   					=						image_size
      lowerCamelCase_   					=						patch_size
      lowerCamelCase_   					=						num_channels
      lowerCamelCase_   					=						is_training
      lowerCamelCase_   					=						use_labels
      lowerCamelCase_   					=						hidden_size
      lowerCamelCase_   					=						num_hidden_layers
      lowerCamelCase_   					=						backbone_out_indices
      lowerCamelCase_   					=						num_attention_heads
      lowerCamelCase_   					=						intermediate_size
      lowerCamelCase_   					=						hidden_act
      lowerCamelCase_   					=						hidden_dropout_prob
      lowerCamelCase_   					=						attention_probs_dropout_prob
      lowerCamelCase_   					=						initializer_range
      lowerCamelCase_   					=						num_labels
      lowerCamelCase_   					=						scope
      lowerCamelCase_   					=						is_hybrid
      # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
      lowerCamelCase_   					=						(image_size // patch_size) ** 2
      lowerCamelCase_   					=						num_patches + 1






    def        UpperCamelCase	(	self					:							Optional[Any] )					->		Optional[Any]:
      lowerCamelCase_   					=						floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size] )

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

      lowerCamelCase_   					=						self.get_config()

      return config, pixel_values, labels






    def        UpperCamelCase	(	self					:							int )					->		Dict:
      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=__SCREAMING_SNAKE_CASE	,						initializer_range=self.initializer_range	,						is_hybrid=self.is_hybrid	,						)






    def        UpperCamelCase	(	self					:							Union[str, Any]	,						__SCREAMING_SNAKE_CASE					:							Any	,						__SCREAMING_SNAKE_CASE					:							Union[str, Any]	,						__SCREAMING_SNAKE_CASE					:							Tuple )					->		Optional[Any]:
      lowerCamelCase_   					=						DPTModel(config=__SCREAMING_SNAKE_CASE )
      model.to(__SCREAMING_SNAKE_CASE )
      model.eval()
      lowerCamelCase_   					=						model(__SCREAMING_SNAKE_CASE )
      self.parent.assertEqual(result.last_hidden_state.shape	,						(self.batch_size, self.seq_length, self.hidden_size) )






    def        UpperCamelCase	(	self					:							Dict	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							Dict	,						__SCREAMING_SNAKE_CASE					:							int )					->		Any:
      lowerCamelCase_   					=						self.num_labels
      lowerCamelCase_   					=						DPTForDepthEstimation(__SCREAMING_SNAKE_CASE )
      model.to(__SCREAMING_SNAKE_CASE )
      model.eval()
      lowerCamelCase_   					=						model(__SCREAMING_SNAKE_CASE )
      self.parent.assertEqual(result.predicted_depth.shape	,						(self.batch_size, self.image_size, self.image_size) )






    def        UpperCamelCase	(	self					:							Tuple	,						__SCREAMING_SNAKE_CASE					:							Tuple	,						__SCREAMING_SNAKE_CASE					:							str	,						__SCREAMING_SNAKE_CASE					:							Tuple )					->		Optional[int]:
      lowerCamelCase_   					=						self.num_labels
      lowerCamelCase_   					=						DPTForSemanticSegmentation(__SCREAMING_SNAKE_CASE )
      model.to(__SCREAMING_SNAKE_CASE )
      model.eval()
      lowerCamelCase_   					=						model(__SCREAMING_SNAKE_CASE	,						labels=__SCREAMING_SNAKE_CASE )
      self.parent.assertEqual(
          result.logits.shape	,						(self.batch_size, self.num_labels, self.image_size, self.image_size) )






    def        UpperCamelCase	(	self					:							Dict )					->		Optional[int]:
      lowerCamelCase_   					=						self.prepare_config_and_inputs()
      lowerCamelCase_					,     lowerCamelCase_					,     lowerCamelCase_   					=						config_and_inputs
      lowerCamelCase_   					=						{'pixel_values': pixel_values}
      return config, inputs_dict






@require_torch
class 					a						( __snake_case  ,				__snake_case  ,				unittest.TestCase		):
    SCREAMING_SNAKE_CASE						:					Dict						=			(DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
    SCREAMING_SNAKE_CASE						:					List[Any]						=			(
        {
            """depth-estimation""": DPTForDepthEstimation,
            """feature-extraction""": DPTModel,
            """image-segmentation""": DPTForSemanticSegmentation,
        }
        if is_torch_available()
        else {}
    )

    SCREAMING_SNAKE_CASE						:					Optional[Any]						=			False
    SCREAMING_SNAKE_CASE						:					List[str]						=			False
    SCREAMING_SNAKE_CASE						:					str						=			False






    def        UpperCamelCase	(	self					:							int )					->		List[Any]:
      lowerCamelCase_   					=						DPTModelTester(self )
      lowerCamelCase_   					=						ConfigTester(self	,						config_class=__SCREAMING_SNAKE_CASE	,						has_text_modality=__SCREAMING_SNAKE_CASE	,						hidden_size=37 )






    def        UpperCamelCase	(	self					:							Dict )					->		List[Any]:
      self.config_tester.run_common_tests()






    @unittest.skip(reason='DPT does not use inputs_embeds' )
    def        UpperCamelCase	(	self					:							Union[str, Any] )					->		Optional[int]:
      pass






    def        UpperCamelCase	(	self					:							str )					->		Tuple:
      lowerCamelCase_					,     lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs_for_common()

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






    def        UpperCamelCase	(	self					:							Optional[Any] )					->		Any:
      lowerCamelCase_					,     lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs_for_common()

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

        lowerCamelCase_   					=						['pixel_values']
        self.assertListEqual(arg_names[:1]	,						__SCREAMING_SNAKE_CASE )






    def        UpperCamelCase	(	self					:							Union[str, Any] )					->		List[str]:
      lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_model(*__SCREAMING_SNAKE_CASE )






    def        UpperCamelCase	(	self					:							Tuple )					->		Dict:
      lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_depth_estimation(*__SCREAMING_SNAKE_CASE )






    def        UpperCamelCase	(	self					:							Any )					->		str:
      lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs()
      self.model_tester.create_and_check_for_semantic_segmentation(*__SCREAMING_SNAKE_CASE )






    def        UpperCamelCase	(	self					:							int )					->		Optional[Any]:
      for model_class in self.all_model_classes:
        if model_class.__name__ == "DPTForDepthEstimation":
          continue

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

        if model_class in get_values(__SCREAMING_SNAKE_CASE ):
          continue

        lowerCamelCase_   					=						model_class(__SCREAMING_SNAKE_CASE )
        model.to(__SCREAMING_SNAKE_CASE )
        model.train()
        lowerCamelCase_   					=						self._prepare_for_class(__SCREAMING_SNAKE_CASE	,						__SCREAMING_SNAKE_CASE	,						return_labels=__SCREAMING_SNAKE_CASE )
        lowerCamelCase_   					=						model(**__SCREAMING_SNAKE_CASE ).loss
        loss.backward()






    def        UpperCamelCase	(	self					:							List[Any] )					->		Union[str, Any]:
      for model_class in self.all_model_classes:
        if model_class.__name__ == "DPTForDepthEstimation":
          continue

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

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






    def        UpperCamelCase	(	self					:							Dict )					->		Optional[int]:
      lowerCamelCase_					,     lowerCamelCase_   					=						self.model_tester.prepare_config_and_inputs_for_common()

      lowerCamelCase_   					=						_config_zero_init(__SCREAMING_SNAKE_CASE )
      for model_class in self.all_model_classes:
        lowerCamelCase_   					=						model_class(config=__SCREAMING_SNAKE_CASE )
        # Skip the check for the backbone
        lowerCamelCase_   					=						[]
        for name, module in model.named_modules():
          if module.__class__.__name__ == "DPTViTHybridEmbeddings":
            lowerCamelCase_   					=						[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        UpperCamelCase	(	self					:							Any )					->		List[Any]:
      pass






    @slow
    def        UpperCamelCase	(	self					:							Optional[int] )					->		str:
      for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
        lowerCamelCase_   					=						DPTModel.from_pretrained(__SCREAMING_SNAKE_CASE )
        self.assertIsNotNone(__SCREAMING_SNAKE_CASE )







def 					lowerCamelCase__	(							)				->    List[str]:
  lowerCamelCase_   					=						Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'			)
  return image






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






    def        UpperCamelCase	(	self					:							Tuple )					->		int:
      lowerCamelCase_   					=						DPTImageProcessor.from_pretrained('Intel/dpt-large' )
      lowerCamelCase_   					=						DPTForDepthEstimation.from_pretrained('Intel/dpt-large' ).to(__SCREAMING_SNAKE_CASE )

      lowerCamelCase_   					=						prepare_img()
      lowerCamelCase_   					=						image_processor(images=__SCREAMING_SNAKE_CASE	,						return_tensors='pt' ).to(__SCREAMING_SNAKE_CASE )

      # forward pass
      with torch.no_grad():
        lowerCamelCase_   					=						model(**__SCREAMING_SNAKE_CASE )
        lowerCamelCase_   					=						outputs.predicted_depth

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

      lowerCamelCase_   					=						torch.tensor(
          [[6.3_199, 6.3_629, 6.4_148], [6.3_850, 6.3_615, 6.4_166], [6.3_519, 6.3_176, 6.3_575]] ).to(__SCREAMING_SNAKE_CASE )

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






    def        UpperCamelCase	(	self					:							Union[str, Any] )					->		Tuple:
      lowerCamelCase_   					=						DPTImageProcessor.from_pretrained('Intel/dpt-large-ade' )
      lowerCamelCase_   					=						DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade' ).to(__SCREAMING_SNAKE_CASE )

      lowerCamelCase_   					=						prepare_img()
      lowerCamelCase_   					=						image_processor(images=__SCREAMING_SNAKE_CASE	,						return_tensors='pt' ).to(__SCREAMING_SNAKE_CASE )

      # forward pass
      with torch.no_grad():
        lowerCamelCase_   					=						model(**__SCREAMING_SNAKE_CASE )

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

      lowerCamelCase_   					=						torch.tensor(
          [[4.0_480, 4.2_420, 4.4_360], [4.3_124, 4.5_693, 4.8_261], [4.5_768, 4.8_965, 5.2_163]] ).to(__SCREAMING_SNAKE_CASE )

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






    def        UpperCamelCase	(	self					:							str )					->		int:
      lowerCamelCase_   					=						DPTImageProcessor.from_pretrained('Intel/dpt-large-ade' )
      lowerCamelCase_   					=						DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade' ).to(__SCREAMING_SNAKE_CASE )

      lowerCamelCase_   					=						prepare_img()
      lowerCamelCase_   					=						image_processor(images=__SCREAMING_SNAKE_CASE	,						return_tensors='pt' ).to(__SCREAMING_SNAKE_CASE )

      # forward pass
      with torch.no_grad():
        lowerCamelCase_   					=						model(**__SCREAMING_SNAKE_CASE )

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

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

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












"""simple docstring"""





from __future__ import annotations







def 					lowerCamelCase__	(							_lowerCamelCase	:		list[int]		,    _lowerCamelCase	:		int			)				->    int:
  lowerCamelCase_					,     lowerCamelCase_   					=						0, len(_lowerCamelCase			) - 1
  while start_ind <= end_ind:
    if array[start_ind] == search_item:
      return start_ind
    elif array[end_ind] == search_item:
      return end_ind
    else:
      start_ind += 1
      end_ind -= 1
    # returns -1 if search_item is not found in array
  return -1


if __name__ == "__main__":
  print(double_linear_search(list(range(100)), 40))




