code: 
  
  
  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   __lowerCamelCase :
  
  
  
  
  
  
  
         def __init__( self:   Union[str, Any],A_:   Any,A_:   Optional[int]=2,A_:   Optional[Any]=32,A_:   Optional[Any]=16,A_:   Tuple=3,A_:   str=True,A_:   int=True,A_:   Optional[Any]=32,A_:   Union[str, Any]=4,A_:   int=[0, 1, 2, 3],A_:   Optional[int]=4,A_:   List[Any]=37,A_:   Any="gelu",A_:   Optional[int]=0.1,A_:   int=0.1,A_:   Any=0.0_2,A_:   str=3,A_:   Union[str, Any]=False,A_:   Optional[Any]=None,):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __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   = backbone_out_indices
              __UpperCamelCase   = num_attention_heads
              __UpperCamelCase   = intermediate_size
              __UpperCamelCase   = hidden_act
              __UpperCamelCase   = hidden_dropout_prob
              __UpperCamelCase   = attention_probs_dropout_prob
              __UpperCamelCase   = initializer_range
              __UpperCamelCase   = num_labels
              __UpperCamelCase   = scope
              __UpperCamelCase   = is_hybrid
              # sequence length of DPT = num_patches + 1 (we add 1 for the [CLS] token)
              __UpperCamelCase   = (image_size // patch_size) ** 2
              __UpperCamelCase   = num_patches + 1
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = floats_tensor([self.batch_size, self.num_channels, self.image_size, self.image_size]				)
  
              __UpperCamelCase   = None
              if self.use_labels:
                   __UpperCamelCase   = ids_tensor([self.batch_size, self.image_size, self.image_size],self.num_labels				)
  
              __UpperCamelCase   = self.get_config()
  
              return config, pixel_values, labels
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''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 		snake_case_  ( self:   Optional[Any],A_:   Union[str, Any],A_:   Dict,A_:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DPTModel(config=A_				)
              model.to(A_				)
              model.eval()
              __UpperCamelCase   = model(A_				)
              self.parent.assertEqual(result.last_hidden_state.shape,(self.batch_size, self.seq_length, self.hidden_size)				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any],A_:   Dict,A_:   Union[str, Any],A_:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.num_labels
              __UpperCamelCase   = DPTForDepthEstimation(A_				)
              model.to(A_				)
              model.eval()
              __UpperCamelCase   = model(A_				)
              self.parent.assertEqual(result.predicted_depth.shape,(self.batch_size, self.image_size, self.image_size)				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   str,A_:   str,A_:   Any,A_:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.num_labels
              __UpperCamelCase   = DPTForSemanticSegmentation(A_				)
              model.to(A_				)
              model.eval()
              __UpperCamelCase   = model(A_,labels=A_				)
              self.parent.assertEqual(
                  result.logits.shape,(self.batch_size, self.num_labels, self.image_size, self.image_size)				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.prepare_config_and_inputs()
              __UpperCamelCase,						__UpperCamelCase,						__UpperCamelCase   = config_and_inputs
              __UpperCamelCase   = {'pixel_values': pixel_values}
              return config, inputs_dict
  
  
  
  @require_torch
  class   __lowerCamelCase (_a							,			_a							,			unittest.TestCase	):
         _lowercase       							=    (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
         _lowercase       							=    (
             {
                 """depth-estimation""": DPTForDepthEstimation,
                 """feature-extraction""": DPTModel,
                 """image-segmentation""": DPTForSemanticSegmentation,
             }
             if is_torch_available()
             else {}
         )
  
         _lowercase       							=    False
         _lowercase       							=    False
         _lowercase       							=    False
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DPTModelTester(self				)
              __UpperCamelCase   = ConfigTester(self,config_class=A_,has_text_modality=A_,hidden_size=37				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              self.config_tester.run_common_tests()
  
  
  
  
  
  
  
         @unittest.skip(reason='DPT does not use inputs_embeds'				)
         def 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              pass
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __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 		snake_case_  ( self:   str				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __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 		snake_case_  ( self:   Tuple				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_model(*A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_depth_estimation(*A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = self.model_tester.prepare_config_and_inputs()
              self.model_tester.create_and_check_for_semantic_segmentation(*A_				)
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[int]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              for model_class in self.all_model_classes:
                   if model_class.__name__ == "DPTForDepthEstimation":
                        continue
  
                   __UpperCamelCase,						__UpperCamelCase   = self.model_tester.prepare_config_and_inputs_for_common()
                   __UpperCamelCase   = True
  
                   if model_class in get_values(A_				):
                        continue
  
                   __UpperCamelCase   = model_class(A_				)
                   model.to(A_				)
                   model.train()
                   __UpperCamelCase   = self._prepare_for_class(A_,A_,return_labels=A_				)
                   __UpperCamelCase   = model(**A_				).loss
                   loss.backward()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Optional[Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              for model_class in self.all_model_classes:
                   if model_class.__name__ == "DPTForDepthEstimation":
                        continue
  
                   __UpperCamelCase,						__UpperCamelCase   = self.model_tester.prepare_config_and_inputs_for_common()
                   __UpperCamelCase   = False
                   __UpperCamelCase   = True
  
                   if model_class in get_values(A_				) or not model_class.supports_gradient_checkpointing:
                        continue
                   __UpperCamelCase   = model_class(A_				)
                   model.to(A_				)
                   model.gradient_checkpointing_enable()
                   model.train()
                   __UpperCamelCase   = self._prepare_for_class(A_,A_,return_labels=A_				)
                   __UpperCamelCase   = model(**A_				).loss
                   loss.backward()
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   List[str]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase,						__UpperCamelCase   = self.model_tester.prepare_config_and_inputs_for_common()
  
              __UpperCamelCase   = _config_zero_init(A_				)
              for model_class in self.all_model_classes:
                   __UpperCamelCase   = model_class(config=A_				)
                   # Skip the check for the backbone
                   __UpperCamelCase   = []
                   for name, module in model.named_modules():
                        if module.__class__.__name__ == "DPTViTHybridEmbeddings":
                             __UpperCamelCase   = [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 		snake_case_  ( self:   int				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              pass
  
  
  
  
  
  
  
         @slow
         def 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                   __UpperCamelCase   = DPTModel.from_pretrained(A_				)
                   self.assertIsNotNone(A_				)
  
  
  
  
  
  
  def 		_A		(		)				->   List[str]:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = Image.open('./tests/fixtures/tests_samples/COCO/000000039769.png'   )
       return image
  
  
  
  @require_torch
  @require_vision
  @slow
  class   __lowerCamelCase (unittest.TestCase	):
  
  
  
  
  
  
  
         def 		snake_case_  ( self:   Any				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DPTImageProcessor.from_pretrained('Intel/dpt-large'				)
              __UpperCamelCase   = DPTForDepthEstimation.from_pretrained('Intel/dpt-large'				).to(A_				)
  
              __UpperCamelCase   = prepare_img()
              __UpperCamelCase   = image_processor(images=A_,return_tensors='pt'				).to(A_				)
  
              # forward pass
              with torch.no_grad():
                   __UpperCamelCase   = model(**A_				)
                   __UpperCamelCase   = outputs.predicted_depth
  
              # verify the predicted depth
              __UpperCamelCase   = torch.Size((1, 384, 384)				)
              self.assertEqual(predicted_depth.shape,A_				)
  
              __UpperCamelCase   = 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 		snake_case_  ( self:   Dict				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'				)
              __UpperCamelCase   = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'				).to(A_				)
  
              __UpperCamelCase   = prepare_img()
              __UpperCamelCase   = image_processor(images=A_,return_tensors='pt'				).to(A_				)
  
              # forward pass
              with torch.no_grad():
                   __UpperCamelCase   = model(**A_				)
  
              # verify the logits
              __UpperCamelCase   = torch.Size((1, 150, 480, 480)				)
              self.assertEqual(outputs.logits.shape,A_				)
  
              __UpperCamelCase   = 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 		snake_case_  ( self:   Union[str, Any]				):
  
  
  
  
  
  
              '''simple docstring'''
  
  
  
  
              __UpperCamelCase   = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'				)
              __UpperCamelCase   = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'				).to(A_				)
  
              __UpperCamelCase   = prepare_img()
              __UpperCamelCase   = image_processor(images=A_,return_tensors='pt'				).to(A_				)
  
              # forward pass
              with torch.no_grad():
                   __UpperCamelCase   = model(**A_				)
  
              __UpperCamelCase   = outputs.logits.detach().cpu()
  
              __UpperCamelCase   = image_processor.post_process_semantic_segmentation(outputs=A_,target_sizes=[(500, 300)]				)
              __UpperCamelCase   = torch.Size((500, 300)				)
              self.assertEqual(segmentation[0].shape,A_				)
  
              __UpperCamelCase   = image_processor.post_process_semantic_segmentation(outputs=A_				)
              __UpperCamelCase   = torch.Size((480, 480)				)
              self.assertEqual(segmentation[0].shape,A_				)
  
  
  
style_context: 
  
  
  import argparse
  import json
  
  from transformers import GPTNeoConfig, GPTNeoForCausalLM, load_tf_weights_in_gpt_neo
  from transformers.utils import logging
  
  
  logging.set_verbosity_info()
  
  
  
  
  
  
  def 		_A		(		_lowercase				,     _lowercase				,     _lowercase   )				->   List[str]:
  
  
       """simple docstring"""
  
  
       __UpperCamelCase   = json.load(open(_lowercase				,     'r'   )   )
       __UpperCamelCase   = GPTNeoConfig(
           hidden_size=config_json['n_embd']				,     num_layers=config_json['n_layer']				,     num_heads=config_json['n_head']				,     attention_types=config_json['attention_types']				,     max_position_embeddings=config_json['n_positions']				,     resid_dropout=config_json['res_dropout']				,     embed_dropout=config_json['embed_dropout']				,     attention_dropout=config_json['attn_dropout']				,     )
       print(f'''Building PyTorch model from configuration: {config}'''   )
       __UpperCamelCase   = GPTNeoForCausalLM(_lowercase   )
  
       # Load weights from tf checkpoint
       load_tf_weights_in_gpt_neo(_lowercase				,     _lowercase				,     _lowercase   )
  
       # Save pytorch-model
       print(f'''Save PyTorch model to {pytorch_dump_path}'''   )
       model.save_pretrained(_lowercase   )
  
  
  if __name__ == "__main__":
      __snake_case             =	argparse.ArgumentParser()
      # Required parameters
      parser.add_argument(
          '''--tf_checkpoint_path''', default=None, type=str, required=True, help='''Path to the TensorFlow checkpoint path.'''
      )
      parser.add_argument(
          '''--config_file''',
          default=None,
          type=str,
          required=True,
          help=(
              '''The config json file corresponding to the pre-trained mesh-tf model. \n'''
              '''This specifies the model architecture.'''
          ),
      )
      parser.add_argument(
          '''--pytorch_dump_path''', default=None, type=str, required=True, help='''Path to the output PyTorch model.'''
      )
      __snake_case             =	parser.parse_args()
      convert_tf_checkpoint_to_pytorch(args.tf_checkpoint_path, args.config_file, args.pytorch_dump_path)
  
  
  