




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





     """simple docstring"""



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






         """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			:							List[str]     )      ->      Optional[int]:






         """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			:							Optional[int]     )      ->      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=A    ,					initializer_range=self.initializer_range    ,					is_hybrid=self.is_hybrid    ,					)

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]    ,					A			:							Tuple    ,					A			:							Dict    ,					A			:							List[Any]     )      ->      List[str]:






         """simple docstring"""
         a__  			=							DPTModel(config=A     )
         model.to(A     )
         model.eval()
         a__  			=							model(A     )
         self.parent.assertEqual(result.last_hidden_state.shape    ,					(self.batch_size, self.seq_length, self.hidden_size)     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Dict    ,					A			:							int    ,					A			:							Optional[Any]    ,					A			:							List[Any]     )      ->      List[str]:






         """simple docstring"""
         a__  			=							self.num_labels
         a__  			=							DPTForDepthEstimation(A     )
         model.to(A     )
         model.eval()
         a__  			=							model(A     )
         self.parent.assertEqual(result.predicted_depth.shape    ,					(self.batch_size, self.image_size, self.image_size)     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]    ,					A			:							Optional[Any]    ,					A			:							str    ,					A			:							List[Any]     )      ->      Optional[Any]:






         """simple docstring"""
         a__  			=							self.num_labels
         a__  			=							DPTForSemanticSegmentation(A     )
         model.to(A     )
         model.eval()
         a__  			=							model(A    ,					labels=A     )
         self.parent.assertEqual(
             result.logits.shape    ,					(self.batch_size, self.num_labels, self.image_size, self.image_size)     )






     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Dict:






         """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 		__UpperCAmelCase(		lowercase__							,						lowercase__							,						unittest.TestCase			):





     """simple docstring"""



     __UpperCAmelCase						:			Optional[Any]							=     (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
     __UpperCAmelCase						:			int							=     (
         {
             """depth-estimation""": DPTForDepthEstimation,
             """feature-extraction""": DPTModel,
             """image-segmentation""": DPTForSemanticSegmentation,
         }
         if is_torch_available()
         else {}
     )

     __UpperCAmelCase						:			int							=     False
     __UpperCAmelCase						:			Optional[int]							=     False
     __UpperCAmelCase						:			List[str]							=     False

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Tuple:






         """simple docstring"""
         a__  			=							DPTModelTester(self     )
         a__  			=							ConfigTester(self    ,					config_class=A    ,					has_text_modality=A    ,					hidden_size=37     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							int     )      ->      Dict:






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

     @unittest.skip(reason="""DPT does not use inputs_embeds"""     )
     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      Union[str, Any]:






         """simple docstring"""
         pass

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      Tuple:






         """simple docstring"""
         a__			,		a__  			=							self.model_tester.prepare_config_and_inputs_for_common()

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

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Union[str, Any]     )      ->      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(A     )
             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]    ,					A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Any     )      ->      str:






         """simple docstring"""
         a__  			=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]     )      ->      Any:






         """simple docstring"""
         a__  			=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_depth_estimation(*A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      int:






         """simple docstring"""
         a__  			=							self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*A     )

     def 					__SCREAMING_SNAKE_CASE		(   self			:							List[str]     )      ->      Optional[int]:






         """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(A     ):
                 continue

             a__  			=							model_class(A     )
             model.to(A     )
             model.train()
             a__  			=							self._prepare_for_class(A    ,					A    ,					return_labels=A     )
             a__  			=							model(**A     ).loss
             loss.backward()

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      Optional[int]:






         """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(A     ) or not model_class.supports_gradient_checkpointing:
                 continue
             a__  			=							model_class(A     )
             model.to(A     )
             model.gradient_checkpointing_enable()
             model.train()
             a__  			=							self._prepare_for_class(A    ,					A    ,					return_labels=A     )
             a__  			=							model(**A     ).loss
             loss.backward()

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      Any:






         """simple docstring"""
         a__			,		a__  			=							self.model_tester.prepare_config_and_inputs_for_common()

         a__  			=							_config_zero_init(A     )
         for model_class in self.all_model_classes:
             a__  			=							model_class(config=A     )
             # 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			:							Optional[Any]     )      ->      str:






         """simple docstring"""
         pass






     @slow
     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]     )      ->      Union[str, Any]:






         """simple docstring"""
         for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
             a__  			=							DPTModel.from_pretrained(A     )
             self.assertIsNotNone(A     )






def 							__lowerCAmelCase			():
    a__  			=							Image.open("""./tests/fixtures/tests_samples/COCO/000000039769.png"""		)
    return image







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





     """simple docstring"""



     def 					__SCREAMING_SNAKE_CASE		(   self			:							Any     )      ->      Any:






         """simple docstring"""
         a__  			=							DPTImageProcessor.from_pretrained("""Intel/dpt-large"""     )
         a__  			=							DPTForDepthEstimation.from_pretrained("""Intel/dpt-large"""     ).to(A     )

         a__  			=							prepare_img()
         a__  			=							image_processor(images=A    ,					return_tensors="""pt"""     ).to(A     )

         # forward pass
         with torch.no_grad():
             a__  			=							model(**A     )
             a__  			=							outputs.predicted_depth

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

         a__  			=							torch.tensor(
             [[6.3_1_9_9, 6.3_6_2_9, 6.4_1_4_8], [6.3_8_5_0, 6.3_6_1_5, 6.4_1_6_6], [6.3_5_1_9, 6.3_1_7_6, 6.3_5_7_5]]     ).to(A     )

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

     def 					__SCREAMING_SNAKE_CASE		(   self			:							Optional[Any]     )      ->      Union[str, Any]:






         """simple docstring"""
         a__  			=							DPTImageProcessor.from_pretrained("""Intel/dpt-large-ade"""     )
         a__  			=							DPTForSemanticSegmentation.from_pretrained("""Intel/dpt-large-ade"""     ).to(A     )

         a__  			=							prepare_img()
         a__  			=							image_processor(images=A    ,					return_tensors="""pt"""     ).to(A     )

         # forward pass
         with torch.no_grad():
             a__  			=							model(**A     )

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

         a__  			=							torch.tensor(
             [[4.0_4_8_0, 4.2_4_2_0, 4.4_3_6_0], [4.3_1_2_4, 4.5_6_9_3, 4.8_2_6_1], [4.5_7_6_8, 4.8_9_6_5, 5.2_1_6_3]]     ).to(A     )

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






     def 					__SCREAMING_SNAKE_CASE		(   self			:							Tuple     )      ->      Dict:






         """simple docstring"""
         a__  			=							DPTImageProcessor.from_pretrained("""Intel/dpt-large-ade"""     )
         a__  			=							DPTForSemanticSegmentation.from_pretrained("""Intel/dpt-large-ade"""     ).to(A     )

         a__  			=							prepare_img()
         a__  			=							image_processor(images=A    ,					return_tensors="""pt"""     ).to(A     )

         # forward pass
         with torch.no_grad():
             a__  			=							model(**A     )

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

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

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












def 							__lowerCAmelCase			(UpperCAmelCase_		):
    return n * (2 * n - 1)
def 							__lowerCAmelCase			(UpperCAmelCase_		):
    a__  			=							(1 + 24 * n) ** 0.5
    return ((1 + root) / 6) % 1 == 0
def 							__lowerCAmelCase			(UpperCAmelCase_ = 144		):
    a__  			=							start
    a__  			=							hexagonal_num(UpperCAmelCase_		)
    while not is_pentagonal(UpperCAmelCase_		):
        n += 1
        a__  			=							hexagonal_num(UpperCAmelCase_		)
    return num


if __name__ == "__main__":
 print(F"{solution()} = ")






