

import copy

from ...configuration_utils import PretrainedConfig
from ...utils import logging
from ..bit import BitConfig


_UpperCamelCase 			=		logging.get_logger(__name__)

_UpperCamelCase 			=		{
    'Intel/dpt-large': 'https://huggingface.co/Intel/dpt-large/resolve/main/config.json',
    # See all DPT models at https://huggingface.co/models?filter=dpt
}







class   __lowercase      (_snake_case ):
 _UpperCamelCase			  =  """dpt"""
 def __init__(							self      ,							A_=768      ,							A_=12      ,							A_=12      ,							A_=3072      ,							A_="gelu"      ,							A_=0.0      ,							A_=0.0      ,							A_=0.02      ,							A_=1e-12      ,							A_=384      ,							A_=16      ,							A_=3      ,							A_=False      ,							A_=True      ,							A_=[2, 5, 8, 11]      ,							A_="project"      ,							A_=[4, 2, 1, 0.5]      ,							A_=[96, 192, 384, 768]      ,							A_=256      ,							A_=-1      ,							A_=False      ,							A_=True      ,							A_=0.4      ,							A_=255      ,							A_=0.1      ,							A_=[1, 1024, 24, 24]      ,							A_=[0, 1]      ,							A_=None      ,							**A_      ,							)					->Tuple:



       '''simple docstring'''





       super().__init__(**__snake_case					)

       __lowerCAmelCase					:						int					=					hidden_size
       __lowerCAmelCase					:						Union[str, Any]					=					is_hybrid

       if self.is_hybrid:
             if backbone_config is None:
                   logger.info('''Initializing the config with a `BiT` backbone.'''					)
                   __lowerCAmelCase					:						Optional[int]					=					{
                       """global_padding""": """same""",
                       """layer_type""": """bottleneck""",
                       """depths""": [3, 4, 9],
                       """out_features""": ["""stage1""", """stage2""", """stage3"""],
                       """embedding_dynamic_padding""": True,
                   }
                   __lowerCAmelCase					:						Any					=					BitConfig(**__snake_case					)
             elif isinstance(__snake_case      ,							__snake_case					):
                   logger.info('''Initializing the config with a `BiT` backbone.'''					)
                   __lowerCAmelCase					:						Tuple					=					BitConfig(**__snake_case					)
             elif isinstance(__snake_case      ,							__snake_case					):
                   __lowerCAmelCase					:						Optional[int]					=					backbone_config
             else:
                   raise ValueError(
                       f"""backbone_config must be a dictionary or a `PretrainedConfig`, got {backbone_config.__class__}."""					)

             __lowerCAmelCase					:						Optional[int]					=					backbone_featmap_shape
             __lowerCAmelCase					:						Optional[int]					=					neck_ignore_stages

             if readout_type != "project":
                   raise ValueError('''Readout type must be \'project\' when using `DPT-hybrid` mode.'''					)
       else:
             __lowerCAmelCase					:						List[str]					=					None
             __lowerCAmelCase					:						List[str]					=					None
             __lowerCAmelCase					:						List[Any]					=					[]

       __lowerCAmelCase					:						Any					=					num_hidden_layers
       __lowerCAmelCase					:						str					=					num_attention_heads
       __lowerCAmelCase					:						int					=					intermediate_size
       __lowerCAmelCase					:						int					=					hidden_act
       __lowerCAmelCase					:						int					=					hidden_dropout_prob
       __lowerCAmelCase					:						Optional[Any]					=					attention_probs_dropout_prob
       __lowerCAmelCase					:						Optional[Any]					=					initializer_range
       __lowerCAmelCase					:						int					=					layer_norm_eps
       __lowerCAmelCase					:						Optional[Any]					=					image_size
       __lowerCAmelCase					:						List[Any]					=					patch_size
       __lowerCAmelCase					:						Optional[int]					=					num_channels
       __lowerCAmelCase					:						str					=					qkv_bias
       __lowerCAmelCase					:						List[str]					=					backbone_out_indices
       if readout_type not in ["ignore", "add", "project"]:
             raise ValueError('''Readout_type must be one of [\'ignore\', \'add\', \'project\']'''					)
       __lowerCAmelCase					:						List[str]					=					readout_type
       __lowerCAmelCase					:						Union[str, Any]					=					reassemble_factors
       __lowerCAmelCase					:						List[Any]					=					neck_hidden_sizes
       __lowerCAmelCase					:						Dict					=					fusion_hidden_size
       __lowerCAmelCase					:						int					=					head_in_index
       __lowerCAmelCase					:						int					=					use_batch_norm_in_fusion_residual
       # auxiliary head attributes (semantic segmentation)
       __lowerCAmelCase					:						Optional[Any]					=					use_auxiliary_head
       __lowerCAmelCase					:						Optional[int]					=					auxiliary_loss_weight
       __lowerCAmelCase					:						Optional[Any]					=					semantic_loss_ignore_index
       __lowerCAmelCase					:						List[Any]					=					semantic_classifier_dropout





 def 	UpperCamelCase__  (							self					)					->Dict:



       '''simple docstring'''





       __lowerCAmelCase					:						Union[str, Any]					=					copy.deepcopy(self.__dict__					)

       if output["backbone_config"] is not None:
             __lowerCAmelCase					:						str					=					self.backbone_config.to_dict()

       __lowerCAmelCase					:						Dict					=					self.__class__.model_type
       return output






'''simple docstring'''


import copy
import inspect
import unittest

from transformers import AutoBackbone
from transformers.configuration_utils import PretrainedConfig
from transformers.testing_utils import require_timm, require_torch, torch_device
from transformers.utils.import_utils import is_torch_available

from ...test_backbone_common import BackboneTesterMixin
from ...test_configuration_common import ConfigTester
from ...test_modeling_common import ModelTesterMixin, floats_tensor


if is_torch_available():
				import torch

				from transformers import TimmBackbone, TimmBackboneConfig

from ...test_pipeline_mixin import PipelineTesterMixin





class     lowercase__  :





							'''simple docstring'''


							def __init__(    self    ,					__snake_case    ,					__snake_case=None    ,					__snake_case=None    ,					__snake_case=None    ,					__snake_case="resnet50"    ,					__snake_case=3    ,					__snake_case=32    ,					__snake_case=3    ,					__snake_case=True    ,					__snake_case=True    ,					):
											_SCREAMING_SNAKE_CASE :       Tuple     		=      parent
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      out_indices if out_indices is not None else [4]
											_SCREAMING_SNAKE_CASE :       str     		=      stage_names
											_SCREAMING_SNAKE_CASE :       List[str]     		=      out_features
											_SCREAMING_SNAKE_CASE :       int     		=      backbone
											_SCREAMING_SNAKE_CASE :       Any     		=      batch_size
											_SCREAMING_SNAKE_CASE :       List[str]     		=      image_size
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      num_channels
											_SCREAMING_SNAKE_CASE :       int     		=      use_pretrained_backbone
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      is_training






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       int     		=      floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]  )
											_SCREAMING_SNAKE_CASE :       List[Any]     		=      self.get_config()

											return config, pixel_values






							def UpperCAmelCase_	(    self  ):
											return TimmBackboneConfig(
											    image_size=self.image_size    ,					num_channels=self.num_channels    ,					out_features=self.out_features    ,					out_indices=self.out_indices    ,					stage_names=self.stage_names    ,					use_pretrained_backbone=self.use_pretrained_backbone    ,					backbone=self.backbone    ,					)






							def UpperCAmelCase_	(    self    ,					__snake_case    ,					__snake_case  ):
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      TimmBackbone(config=__snake_case  )
											model.to(__snake_case  )
											model.eval()
											with torch.no_grad():
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      model(__snake_case  )
											self.parent.assertEqual(
											    result.feature_map[-1].shape    ,					(self.batch_size, model.channels[-1], 14, 14)    ,					)






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Tuple     		=      self.prepare_config_and_inputs()
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       Any     		=      config_and_inputs
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      {"""pixel_values""": pixel_values}
											return config, inputs_dict





@require_torch
@require_timm
class     lowercase__  (						_snake_case     ,     _snake_case     ,     _snake_case     ,     unittest.TestCase					):





							'''simple docstring'''


							A_							:      Optional[Any]      	=  (TimmBackbone,) if is_torch_available() else ()
							A_							:      Tuple      	=  {"""feature-extraction""": TimmBackbone} if is_torch_available() else {}
							A_							:      Optional[Any]      	=  False
							A_							:      List[Any]      	=  False
							A_							:      Dict      	=  False
							A_							:      int      	=  False






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Any     		=      TimmBackboneModelTester(self  )
											_SCREAMING_SNAKE_CASE :       int     		=      ConfigTester(self    ,					config_class=__snake_case    ,					has_text_modality=__snake_case  )






							def UpperCAmelCase_	(    self  ):
											self.config_tester.create_and_test_config_to_json_string()
											self.config_tester.create_and_test_config_to_json_file()
											self.config_tester.create_and_test_config_from_and_save_pretrained()
											self.config_tester.create_and_test_config_with_num_labels()
											self.config_tester.check_config_can_be_init_without_params()
											self.config_tester.check_config_arguments_init()






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE :       Optional[int]     		=      """resnet18"""
											_SCREAMING_SNAKE_CASE :       Tuple     		=      """microsoft/resnet-18"""

											_SCREAMING_SNAKE_CASE :       List[str]     		=      AutoBackbone.from_pretrained(__snake_case    ,					use_timm_backbone=__snake_case  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      AutoBackbone.from_pretrained(__snake_case  )

											self.assertEqual(len(timm_model.out_features  )    ,					len(transformers_model.out_features  )  )
											self.assertEqual(len(timm_model.stage_names  )    ,					len(transformers_model.stage_names  )  )
											self.assertEqual(timm_model.channels    ,					transformers_model.channels  )
											# Out indices are set to the last layer by default. For timm models, we don't know
											# the number of layers in advance, so we set it to (-1,), whereas for transformers
											# models, we set it to [len(stage_names) - 1] (kept for backward compatibility).
											self.assertEqual(timm_model.out_indices    ,					(-1,)  )
											self.assertEqual(transformers_model.out_indices    ,					[len(timm_model.stage_names  ) - 1]  )

											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      AutoBackbone.from_pretrained(__snake_case    ,					use_timm_backbone=__snake_case    ,					out_indices=[1, 2, 3]  )
											_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      AutoBackbone.from_pretrained(__snake_case    ,					out_indices=[1, 2, 3]  )

											self.assertEqual(timm_model.out_indices    ,					transformers_model.out_indices  )
											self.assertEqual(len(timm_model.out_features  )    ,					len(transformers_model.out_features  )  )
											self.assertEqual(timm_model.channels    ,					transformers_model.channels  )






							@unittest.skip("""TimmBackbone doesn't support feed forward chunking"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't have num_hidden_layers attribute"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone initialization is managed on the timm side"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone models doesn't have inputs_embeds"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone model cannot be created without specifying a backbone checkpoint"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""model weights aren't tied in TimmBackbone."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""model weights aren't tied in TimmBackbone."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Only checkpoints on timm can be loaded into TimmBackbone"""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't have hidden size info in its configuration."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""TimmBackbone doesn't support output_attentions."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Safetensors is not supported by timm."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							@unittest.skip("""Will be fixed soon by reducing the size of the model used for common tests."""  )
							def UpperCAmelCase_	(    self  ):
											pass






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       List[Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE :       List[str]     		=      model_class(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Tuple     		=      inspect.signature(model.forward  )
															# signature.parameters is an OrderedDict => so arg_names order is deterministic
															_SCREAMING_SNAKE_CASE :       int     		=      [*signature.parameters.keys()]

															_SCREAMING_SNAKE_CASE :       List[Any]     		=      ["""pixel_values"""]
															self.assertListEqual(arg_names[:1]    ,					__snake_case  )






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       List[Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()
											_SCREAMING_SNAKE_CASE :       Tuple     		=      True
											_SCREAMING_SNAKE_CASE :       List[str]     		=      self.has_attentions

											# no need to test all models as different heads yield the same functionality
											_SCREAMING_SNAKE_CASE :       str     		=      self.all_model_classes[0]
											_SCREAMING_SNAKE_CASE :       str     		=      model_class(__snake_case  )
											model.to(__snake_case  )

											_SCREAMING_SNAKE_CASE :       Tuple     		=      self._prepare_for_class(__snake_case    ,					__snake_case  )
											_SCREAMING_SNAKE_CASE :       Tuple     		=      model(**__snake_case  )
											_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      outputs[0][-1]

											# Encoder-/Decoder-only models
											_SCREAMING_SNAKE_CASE :       str     		=      outputs.hidden_states[0]
											hidden_states.retain_grad()

											if self.has_attentions:
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      outputs.attentions[0]
															attentions.retain_grad()

											output.flatten()[0].backward(retain_graph=__snake_case  )

											self.assertIsNotNone(hidden_states.grad  )

											if self.has_attentions:
															self.assertIsNotNone(attentions.grad  )






							def UpperCAmelCase_	(    self  ):
											_SCREAMING_SNAKE_CASE		,       _SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      self.model_tester.prepare_config_and_inputs_for_common()

											for model_class in self.all_model_classes:
															_SCREAMING_SNAKE_CASE :       str     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       List[str]     		=      model(**__snake_case  )

															self.assertEqual(len(result.feature_maps  )    ,					len(config.out_indices  )  )
															self.assertEqual(len(model.channels  )    ,					len(config.out_indices  )  )

															# Check output of last stage is taken if out_features=None, out_indices=None
															_SCREAMING_SNAKE_CASE :       Union[str, Any]     		=      copy.deepcopy(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      None
															_SCREAMING_SNAKE_CASE :       Tuple     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       Optional[Any]     		=      model(**__snake_case  )

															self.assertEqual(len(result.feature_maps  )    ,					1  )
															self.assertEqual(len(model.channels  )    ,					1  )

															# Check backbone can be initialized with fresh weights
															_SCREAMING_SNAKE_CASE :       str     		=      copy.deepcopy(__snake_case  )
															_SCREAMING_SNAKE_CASE :       Tuple     		=      False
															_SCREAMING_SNAKE_CASE :       Optional[int]     		=      model_class(__snake_case  )
															model.to(__snake_case  )
															model.eval()
															_SCREAMING_SNAKE_CASE :       List[Any]     		=      model(**__snake_case  )




