






'''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      __SCREAMING_SNAKE_CASE					:


  """simple docstring"""


  def __init__( self      ,  UpperCamelCase__      ,  UpperCamelCase__=2      ,  UpperCamelCase__=32      ,  UpperCamelCase__=16      ,  UpperCamelCase__=3      ,  UpperCamelCase__=True      ,  UpperCamelCase__=True      ,  UpperCamelCase__=32      ,  UpperCamelCase__=4      ,  UpperCamelCase__=[0, 1, 2, 3]      ,  UpperCamelCase__=4      ,  UpperCamelCase__=37      ,  UpperCamelCase__="gelu"      ,  UpperCamelCase__=0.1      ,  UpperCamelCase__=0.1      ,  UpperCamelCase__=0.02      ,  UpperCamelCase__=3      ,  UpperCamelCase__=False      ,  UpperCamelCase__=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       _a					( self  ):






         """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       _a					( self  ):






         """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=UpperCamelCase__      ,  initializer_range=self.initializer_range      ,  is_hybrid=self.is_hybrid      ,  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = DPTModel(config=UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(UpperCamelCase__  )
         self.parent.assertEqual(result.last_hidden_state.shape      ,  (self.batch_size, self.seq_length, self.hidden_size)  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = self.num_labels
         a_	    = DPTForDepthEstimation(UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(UpperCamelCase__  )
         self.parent.assertEqual(result.predicted_depth.shape      ,  (self.batch_size, self.image_size, self.image_size)  )







  def       _a					( self      ,  UpperCamelCase__      ,  UpperCamelCase__      ,  UpperCamelCase__  ):






         """simple docstring"""


         a_	    = self.num_labels
         a_	    = DPTForSemanticSegmentation(UpperCamelCase__  )
         model.to(UpperCamelCase__  )
         model.eval()
         a_	    = model(UpperCamelCase__      ,  labels=UpperCamelCase__  )
         self.parent.assertEqual(
             result.logits.shape      ,  (self.batch_size, self.num_labels, self.image_size, self.image_size)  )







  def       _a					( self  ):






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


  """simple docstring"""


  _a     :   List[str]				 =    (DPTModel, DPTForDepthEstimation, DPTForSemanticSegmentation) if is_torch_available() else ()
  _a     :   Tuple				 =    (
      {
          '''depth-estimation''': DPTForDepthEstimation,
          '''feature-extraction''': DPTModel,
          '''image-segmentation''': DPTForSemanticSegmentation,
      }
      if is_torch_available()
      else {}
  )

  _a     :   Any				 =    False
  _a     :   int				 =    False
  _a     :   List[Any]				 =    False







  def       _a					( self  ):






         """simple docstring"""


         a_	    = DPTModelTester(self  )
         a_	    = ConfigTester(self      ,  config_class=UpperCamelCase__      ,  has_text_modality=UpperCamelCase__      ,  hidden_size=37  )







  def       _a					( self  ):






         """simple docstring"""


         self.config_tester.run_common_tests()







  @unittest.skip(reason='DPT does not use inputs_embeds'  )
  def       _a					( self  ):






         """simple docstring"""


         pass







  def       _a					( self  ):






         """simple docstring"""


         a_    ,  a_	    = self.model_tester.prepare_config_and_inputs_for_common()

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







  def       _a					( self  ):






         """simple docstring"""


         a_    ,  a_	    = self.model_tester.prepare_config_and_inputs_for_common()

         for model_class in self.all_model_classes:
                a_	    = model_class(UpperCamelCase__  )
                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]      ,  UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_model(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_depth_estimation(*UpperCamelCase__  )







  def       _a					( self  ):






         """simple docstring"""


         a_	    = self.model_tester.prepare_config_and_inputs()
         self.model_tester.create_and_check_for_semantic_segmentation(*UpperCamelCase__  )







  def       _a					( self  ):






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

                a_	    = model_class(UpperCamelCase__  )
                model.to(UpperCamelCase__  )
                model.train()
                a_	    = self._prepare_for_class(UpperCamelCase__      ,  UpperCamelCase__      ,  return_labels=UpperCamelCase__  )
                a_	    = model(**UpperCamelCase__  ).loss
                loss.backward()







  def       _a					( self  ):






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







  def       _a					( self  ):






         """simple docstring"""


         a_    ,  a_	    = self.model_tester.prepare_config_and_inputs_for_common()

         a_	    = _config_zero_init(UpperCamelCase__  )
         for model_class in self.all_model_classes:
                a_	    = model_class(config=UpperCamelCase__  )
                # 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       _a					( self  ):






         """simple docstring"""


         pass







  @slow
  def       _a					( self  ):






         """simple docstring"""


         for model_name in DPT_PRETRAINED_MODEL_ARCHIVE_LIST[:1]:
                a_	    = DPTModel.from_pretrained(UpperCamelCase__  )
                self.assertIsNotNone(UpperCamelCase__  )





def 			__UpperCamelCase				(			):
       """simple docstring"""




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




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


  """simple docstring"""


  def       _a					( self  ):






         """simple docstring"""


         a_	    = DPTImageProcessor.from_pretrained('Intel/dpt-large'  )
         a_	    = DPTForDepthEstimation.from_pretrained('Intel/dpt-large'  ).to(UpperCamelCase__  )

         a_	    = prepare_img()
         a_	    = image_processor(images=UpperCamelCase__      ,  return_tensors='pt'  ).to(UpperCamelCase__  )

         # forward pass
         with torch.no_grad():
                a_	    = model(**UpperCamelCase__  )
                a_	    = outputs.predicted_depth

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

         a_	    = 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(UpperCamelCase__  )

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







  def       _a					( self  ):






         """simple docstring"""


         a_	    = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'  )
         a_	    = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'  ).to(UpperCamelCase__  )

         a_	    = prepare_img()
         a_	    = image_processor(images=UpperCamelCase__      ,  return_tensors='pt'  ).to(UpperCamelCase__  )

         # forward pass
         with torch.no_grad():
                a_	    = model(**UpperCamelCase__  )

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

         a_	    = 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(UpperCamelCase__  )

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







  def       _a					( self  ):






         """simple docstring"""


         a_	    = DPTImageProcessor.from_pretrained('Intel/dpt-large-ade'  )
         a_	    = DPTForSemanticSegmentation.from_pretrained('Intel/dpt-large-ade'  ).to(UpperCamelCase__  )

         a_	    = prepare_img()
         a_	    = image_processor(images=UpperCamelCase__      ,  return_tensors='pt'  ).to(UpperCamelCase__  )

         # forward pass
         with torch.no_grad():
                a_	    = model(**UpperCamelCase__  )

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

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

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












'''simple docstring'''







from typing import Dict, Tuple, overload

import torch
import torch.types
from torch import nn

from . import residue_constants as rc
from .rigid_utils import Rigid, Rotation
from .tensor_utils import batched_gather


@overload
def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     None      ):
       """simple docstring"""




       ...


@overload
def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ):
       """simple docstring"""




       ...


def 			__UpperCamelCase				(			lowercase_					:     Tuple      ,					lowercase_					:     Tuple      ,					lowercase_					:     List[Any]      ):
       """simple docstring"""




       a_	    = aatype == rc.restype_order['G']
       a_	    = rc.atom_order['CA']
       a_	    = rc.atom_order['CB']
       a_	    = torch.where(
           is_gly[..., None].expand(*((-1,) * len(is_gly.shape      ))      ,					3      )      ,					all_atom_positions[..., ca_idx, :]      ,					all_atom_positions[..., cb_idx, :]      ,					)

       if all_atom_masks is not None:
              a_	    = torch.where(
                  lowercase_      ,					all_atom_masks[..., ca_idx]      ,					all_atom_masks[..., cb_idx]      ,					)
              return pseudo_beta, pseudo_beta_mask
       else:
              return pseudo_beta


def 			__UpperCamelCase				(			lowercase_					:     torch.Tensor      ,					lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = batched_gather(
           lowercase_      ,					batch['residx_atom37_to_atom14']      ,					dim=-2      ,					no_batch_dims=len(atomaa.shape[:-2]      )      ,					)

       a_	    = atomaa_data * batch['atom37_atom_exists'][..., None]

       return atomaa_data


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = template_feats['template_aatype']
       a_	    = template_feats['template_torsion_angles_sin_cos']
       a_	    = template_feats['template_alt_torsion_angles_sin_cos']
       a_	    = template_feats['template_torsion_angles_mask']
       a_	    = torch.cat(
           [
               nn.functional.one_hot(lowercase_      ,					22      ),
               torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2]      ,					14      ),
               alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2]      ,					14      ),
               torsion_angles_mask,
           ]      ,					dim=-1      ,					)

       return template_angle_feat


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ,					lowercase_					:     torch.types.Number      ,					lowercase_					:     torch.types.Number      ,					lowercase_					:     int      ,					lowercase_					:     bool = False      ,					lowercase_					:     float = 1E-20      ,					lowercase_					:     float = 1E8      ,					):
       """simple docstring"""




       a_	    = batch['template_pseudo_beta_mask']
       a_	    = template_mask[..., None] * template_mask[..., None, :]

       # Compute distogram (this seems to differ slightly from Alg. 5)
       a_	    = batch['template_pseudo_beta']
       a_	    = torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2      ,					dim=-1      ,					keepdim=lowercase_      )
       a_	    = torch.linspace(lowercase_      ,					lowercase_      ,					lowercase_      ,					device=tpb.device      ) ** 2
       a_	    = torch.cat([lower[1:], lower.new_tensor([inf]      )]      ,					dim=-1      )
       a_	    = ((dgram > lower) * (dgram < upper)).type(dgram.dtype      )

       a_	    = [dgram, template_mask_ad[..., None]]

       a_	    = nn.functional.one_hot(
           batch['template_aatype']      ,					rc.restype_num + 2      ,					)

       a_	    = batch['template_aatype'].shape[-1]
       to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]      ,					lowercase_      ,					-1      ,					-1      )      )
       to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]      ,					-1      ,					lowercase_      ,					-1      )      )

       a_    ,  a_    ,  a_	    = [rc.atom_order[a] for a in ['N', 'CA', 'C']]
       a_	    = Rigid.make_transform_from_reference(
           n_xyz=batch['template_all_atom_positions'][..., n, :]      ,					ca_xyz=batch['template_all_atom_positions'][..., ca, :]      ,					c_xyz=batch['template_all_atom_positions'][..., c, :]      ,					eps=lowercase_      ,					)
       a_	    = rigids.get_trans()[..., None, :, :]
       a_	    = rigids[..., None].invert_apply(lowercase_      )

       a_	    = torch.rsqrt(eps + torch.sum(rigid_vec**2      ,					dim=-1      )      )

       a_	    = batch['template_all_atom_mask']
       a_	    = t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
       a_	    = template_mask[..., None] * template_mask[..., None, :]

       a_	    = inv_distance_scalar * template_mask_ad
       a_	    = rigid_vec * inv_distance_scalar[..., None]

       if not use_unit_vector:
              a_	    = unit_vector * 0.0

       to_concat.extend(torch.unbind(unit_vector[..., None, :]      ,					dim=-1      )      )
       to_concat.append(template_mask_ad[..., None]      )

       a_	    = torch.cat(lowercase_      ,					dim=-1      )
       a_	    = act * template_mask_ad[..., None]

       return act


def 			__UpperCamelCase				(			lowercase_					:     Dict[str, torch.Tensor]      ):
       """simple docstring"""




       a_	    = nn.functional.one_hot(batch['extra_msa']      ,					23      )
       a_	    = [
           msa_ahot,
           batch['extra_has_deletion'].unsqueeze(-1      ),
           batch['extra_deletion_value'].unsqueeze(-1      ),
       ]
       return torch.cat(lowercase_      ,					dim=-1      )


def 			__UpperCamelCase				(			lowercase_					:     Rigid      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					):
       """simple docstring"""




       a_	    = rrgdf[aatype, ...]

       # [*, N, 8] transformations, i.e.
       #   One [*, N, 8, 3, 3] rotation matrix and
       #   One [*, N, 8, 3]    translation matrix
       a_	    = r.from_tensor_axa(lowercase_      )

       a_	    = alpha.new_zeros((*((1,) * len(alpha.shape[:-1]      )), 2)      )
       a_	    = 1

       # [*, N, 8, 2]
       a_	    = torch.cat([bb_rot.expand(*alpha.shape[:-2]      ,					-1      ,					-1      ), alpha]      ,					dim=-2      )

       # [*, N, 8, 3, 3]
       # Produces rotation matrices of the form:
       # [
       #   [1, 0  , 0  ],
       #   [0, a_2,-a_1],
       #   [0, a_1, a_2]
       # ]
       # This follows the original code rather than the supplement, which uses
       # different indices.

       a_	    = alpha.new_zeros(default_r.get_rots().get_rot_mats().shape      )
       a_	    = 1
       a_	    = alpha[..., 1]
       a_	    = -alpha[..., 0]
       a_	    = alpha

       a_	    = default_r.compose(Rigid(Rotation(rot_mats=lowercase_      )      ,					lowercase_      )      )

       a_	    = all_frames[..., 5]
       a_	    = all_frames[..., 6]
       a_	    = all_frames[..., 7]

       a_	    = all_frames[..., 4]
       a_	    = chia_frame_to_bb.compose(lowercase_      )
       a_	    = chia_frame_to_bb.compose(lowercase_      )
       a_	    = chia_frame_to_bb.compose(lowercase_      )

       a_	    = Rigid.cat(
           [
               all_frames[..., :5],
               chia_frame_to_bb.unsqueeze(-1      ),
               chia_frame_to_bb.unsqueeze(-1      ),
               chia_frame_to_bb.unsqueeze(-1      ),
           ]      ,					dim=-1      ,					)

       a_	    = r[..., None].compose(lowercase_      )

       return all_frames_to_global


def 			__UpperCamelCase				(			lowercase_					:     Rigid      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					lowercase_					:     torch.Tensor      ,					):
       """simple docstring"""




       a_	    = group_idx[aatype, ...]

       # [*, N, 14, 8]
       a_	    = nn.functional.one_hot(
           lowercase_      ,					num_classes=default_frames.shape[-3]      ,					)

       # [*, N, 14, 8]
       a_	    = r[..., None, :] * group_mask_one_hot

       # [*, N, 14]
       a_	    = t_atoms_to_global.map_tensor_fn(lambda lowercase_      : torch.sum(lowercase_      ,					dim=-1      )      )

       # [*, N, 14, 1]
       a_	    = atom_mask[aatype, ...].unsqueeze(-1      )

       # [*, N, 14, 3]
       a_	    = lit_positions[aatype, ...]
       a_	    = t_atoms_to_global.apply(lowercase_      )
       a_	    = pred_positions * atom_mask

       return pred_positions




