






"""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    snake_case						:


   '''simple docstring'''

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

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict    ):

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

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

     __A		     =					self.get_config()

     return config, pixel_values, labels


   def 							_SCREAMING_SNAKE_CASE							(      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 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any],			_lowerCamelCase					:	Dict,			_lowerCamelCase					:	List[str],			_lowerCamelCase					:	Any    ):

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict,			_lowerCamelCase					:	int,			_lowerCamelCase					:	int,			_lowerCamelCase					:	List[str]    ):

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple,			_lowerCamelCase					:	Optional[Any],			_lowerCamelCase					:	Any,			_lowerCamelCase					:	List[Any]    ):

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






   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

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





@require_torch
class    snake_case						(				_lowerCAmelCase  ,      _lowerCAmelCase  ,      unittest.TestCase		):


   '''simple docstring'''

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

   A_		:      Optional[Any]							=					False
   A_		:      str							=					False
   A_		:      Tuple							=					False


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     __A		     =					DPTModelTester(self    )
     __A		     =					ConfigTester(self,			config_class=_lowerCamelCase,			has_text_modality=_lowerCamelCase,			hidden_size=37    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str]    ):

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


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

     '''simple docstring'''
     pass


   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str]    ):

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

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

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

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

       __A		     =					['''pixel_values''']
       self.assertListEqual(arg_names[:1],			_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

     '''simple docstring'''
     __A		     =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_model(*_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[int]    ):

     '''simple docstring'''
     __A		     =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_depth_estimation(*_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

     '''simple docstring'''
     __A		     =					self.model_tester.prepare_config_and_inputs()
     self.model_tester.create_and_check_for_semantic_segmentation(*_lowerCamelCase    )


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Tuple    ):

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

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

       if model_class in get_values(_lowerCamelCase    ):
         continue

       __A		     =					model_class(_lowerCamelCase    )
       model.to(_lowerCamelCase    )
       model.train()
       __A		     =					self._prepare_for_class(_lowerCamelCase,			_lowerCamelCase,			return_labels=_lowerCamelCase    )
       __A		     =					model(**_lowerCamelCase    ).loss
       loss.backward()


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Optional[Any]    ):

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

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

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	str    ):

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

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

     '''simple docstring'''
     pass






   @slow
   def 							_SCREAMING_SNAKE_CASE							(      self					:	int    ):

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





def    lowerCAmelCase							(       ):




  """simple docstring"""







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





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


   '''simple docstring'''

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

     '''simple docstring'''
     __A		     =					DPTImageProcessor.from_pretrained('''Intel/dpt-large'''    )
     __A		     =					DPTForDepthEstimation.from_pretrained('''Intel/dpt-large'''    ).to(_lowerCamelCase    )

     __A		     =					prepare_img()
     __A		     =					image_processor(images=_lowerCamelCase,			return_tensors='''pt'''    ).to(_lowerCamelCase    )

     # forward pass
     with torch.no_grad():
       __A		     =					model(**_lowerCamelCase    )
       __A		     =					outputs.predicted_depth

     # verify the predicted depth
     __A		     =					torch.Size((1, 3_84, 3_84)    )
     self.assertEqual(predicted_depth.shape,			_lowerCamelCase    )

     __A		     =					torch.tensor(
         [[6.31_99, 6.36_29, 6.41_48], [6.38_50, 6.36_15, 6.41_66], [6.35_19, 6.31_76, 6.35_75]]    ).to(_lowerCamelCase    )

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


   def 							_SCREAMING_SNAKE_CASE							(      self					:	Dict    ):

     '''simple docstring'''
     __A		     =					DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''    )
     __A		     =					DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''    ).to(_lowerCamelCase    )

     __A		     =					prepare_img()
     __A		     =					image_processor(images=_lowerCamelCase,			return_tensors='''pt'''    ).to(_lowerCamelCase    )

     # forward pass
     with torch.no_grad():
       __A		     =					model(**_lowerCamelCase    )

     # verify the logits
     __A		     =					torch.Size((1, 1_50, 4_80, 4_80)    )
     self.assertEqual(outputs.logits.shape,			_lowerCamelCase    )

     __A		     =					torch.tensor(
         [[4.04_80, 4.24_20, 4.43_60], [4.31_24, 4.56_93, 4.82_61], [4.57_68, 4.89_65, 5.21_63]]    ).to(_lowerCamelCase    )

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






   def 							_SCREAMING_SNAKE_CASE							(      self					:	List[str]    ):

     '''simple docstring'''
     __A		     =					DPTImageProcessor.from_pretrained('''Intel/dpt-large-ade'''    )
     __A		     =					DPTForSemanticSegmentation.from_pretrained('''Intel/dpt-large-ade'''    ).to(_lowerCamelCase    )

     __A		     =					prepare_img()
     __A		     =					image_processor(images=_lowerCamelCase,			return_tensors='''pt'''    ).to(_lowerCamelCase    )

     # forward pass
     with torch.no_grad():
       __A		     =					model(**_lowerCamelCase    )

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

     __A		     =					image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase,			target_sizes=[(5_00, 3_00)]    )
     __A		     =					torch.Size((5_00, 3_00)    )
     self.assertEqual(segmentation[0].shape,			_lowerCamelCase    )

     __A		     =					image_processor.post_process_semantic_segmentation(outputs=_lowerCamelCase    )
     __A		     =					torch.Size((4_80, 4_80)    )
     self.assertEqual(segmentation[0].shape,			_lowerCamelCase    )











"""simple docstring"""




def 		UpperCAmelCase__						(	_UpperCAmelCase					,   _UpperCAmelCase   ):






  """simple docstring"""





  A_    :			List[str]									=    (boundary[1] - boundary[0]) / steps
  A_    :			Optional[int]									=    boundary[0]
  A_    :			Optional[int]									=    boundary[1]
  A_    :			Any									=    make_points(_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase   )
  A_    :			Dict									=    0.0
  y += (h / 3.0) * f(_UpperCAmelCase   )
  A_    :			Optional[int]									=    2
  for i in x_i:
    y += (h / 3) * (4 - 2 * (cnt % 2)) * f(_UpperCAmelCase   )
    cnt += 1
  y += (h / 3.0) * f(_UpperCAmelCase   )
  return y





def 		UpperCAmelCase__						(	_UpperCAmelCase					,   _UpperCAmelCase					,   _UpperCAmelCase   ):






  """simple docstring"""





  A_    :			Optional[Any]									=    a + h
  while x < (b - h):
    yield x
    A_    :			Dict									=    x + h





def 		UpperCAmelCase__						(	_UpperCAmelCase   ):  # enter your function here






  """simple docstring"""





  A_    :			List[Any]									=    (x - 0) * (x - 0)
  return y





def 		UpperCAmelCase__						(	):






  """simple docstring"""





  A_    :			int									=    0.0  # Lower bound of integration
  A_    :			int									=    1.0  # Upper bound of integration
  A_    :			Tuple									=    10.0  # define number of steps or resolution
  A_    :			List[str]									=    [a, b]  # define boundary of integration
  A_    :			Optional[Any]									=    method_a(_UpperCAmelCase					,   _UpperCAmelCase   )
  print(f"""y = {y}"""   )


if __name__ == "__main__":
   main()