code: 
  
  
  '''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 _SCREAMING_SNAKE_CASE   (A						,				A						,				A ) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         ...
  
  @overload
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A ) -> Tuple[torch.Tensor, torch.Tensor]:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         ...
  
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A ) -> Any:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				aatype == rc.restype_order['''G''']
         lowercase__       =				rc.atom_order['''CA''']
         lowercase__       =				rc.atom_order['''CB''']
         lowercase__       =				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:
                lowercase__       =				torch.where(
                    A						,				all_atom_masks[..., ca_idx]						,				all_atom_masks[..., cb_idx]						,				)
                return pseudo_beta, pseudo_beta_mask
         else:
                return pseudo_beta
  
  def _SCREAMING_SNAKE_CASE   (A						,				A ) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				batched_gather(
             A						,				batch['''residx_atom37_to_atom14''']						,				dim=-2						,				no_batch_dims=len(atomaa.shape[:-2] )						,				)
  
         lowercase__       =				atomaa_data * batch['''atom37_atom_exists'''][..., None]
  
         return atomaa_data
  
  def _SCREAMING_SNAKE_CASE   (A ) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				template_feats['''template_aatype''']
         lowercase__       =				template_feats['''template_torsion_angles_sin_cos''']
         lowercase__       =				template_feats['''template_alt_torsion_angles_sin_cos''']
         lowercase__       =				template_feats['''template_torsion_angles_mask''']
         lowercase__       =				torch.cat(
             [
                 nn.functional.one_hot(A						,				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 _SCREAMING_SNAKE_CASE   (A						,				A						,				A						,				A						,				A = False						,				A = 1E-20						,				A = 1E8						,				) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				batch['''template_pseudo_beta_mask''']
         lowercase__       =				template_mask[..., None] * template_mask[..., None, :]
  
         # Compute distogram (this seems to differ slightly from Alg. 5)
         lowercase__       =				batch['''template_pseudo_beta''']
         lowercase__       =				torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2						,				dim=-1						,				keepdim=A )
         lowercase__       =				torch.linspace(A						,				A						,				A						,				device=tpb.device ) ** 2
         lowercase__       =				torch.cat([lower[1:], lower.new_tensor([inf] )]						,				dim=-1 )
         lowercase__       =				((dgram > lower) * (dgram < upper)).type(dgram.dtype )
  
         lowercase__       =				[dgram, template_mask_ad[..., None]]
  
         lowercase__       =				nn.functional.one_hot(
             batch['''template_aatype''']						,				rc.restype_num + 2						,				)
  
         lowercase__       =				batch['''template_aatype'''].shape[-1]
         to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]						,				A						,				-1						,				-1 ) )
         to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]						,				-1						,				A						,				-1 ) )
  
         lowercase__    ,lowercase__    ,lowercase__       =				[rc.atom_order[a] for a in ['''N''', '''CA''', '''C''']]
         lowercase__       =				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=A						,				)
         lowercase__       =				rigids.get_trans()[..., None, :, :]
         lowercase__       =				rigids[..., None].invert_apply(A )
  
         lowercase__       =				torch.rsqrt(eps + torch.sum(rigid_vec**2						,				dim=-1 ) )
  
         lowercase__       =				batch['''template_all_atom_mask''']
         lowercase__       =				t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
         lowercase__       =				template_mask[..., None] * template_mask[..., None, :]
  
         lowercase__       =				inv_distance_scalar * template_mask_ad
         lowercase__       =				rigid_vec * inv_distance_scalar[..., None]
  
         if not use_unit_vector:
                lowercase__       =				unit_vector * 0.0
  
         to_concat.extend(torch.unbind(unit_vector[..., None, :]						,				dim=-1 ) )
         to_concat.append(template_mask_ad[..., None] )
  
         lowercase__       =				torch.cat(A						,				dim=-1 )
         lowercase__       =				act * template_mask_ad[..., None]
  
         return act
  
  def _SCREAMING_SNAKE_CASE   (A ) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				nn.functional.one_hot(batch['''extra_msa''']						,				23 )
         lowercase__       =				[
             msa_ahot,
             batch['''extra_has_deletion'''].unsqueeze(-1 ),
             batch['''extra_deletion_value'''].unsqueeze(-1 ),
         ]
         return torch.cat(A						,				dim=-1 )
  
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A						,				A						,				) -> Rigid:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				rrgdf[aatype, ...]
  
         # [*, N, 8] transformations, i.e.
         #   One [*, N, 8, 3, 3] rotation matrix and
         #   One [*, N, 8, 3]    translation matrix
         lowercase__       =				r.from_tensor_axa(A )
  
         lowercase__       =				alpha.new_zeros((*((1,) * len(alpha.shape[:-1] )), 2) )
         lowercase__       =				1
  
         # [*, N, 8, 2]
         lowercase__       =				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.
  
         lowercase__       =				alpha.new_zeros(default_r.get_rots().get_rot_mats().shape )
         lowercase__       =				1
         lowercase__       =				alpha[..., 1]
         lowercase__       =				-alpha[..., 0]
         lowercase__       =				alpha
  
         lowercase__       =				default_r.compose(Rigid(Rotation(rot_mats=A )						,				A ) )
  
         lowercase__       =				all_frames[..., 5]
         lowercase__       =				all_frames[..., 6]
         lowercase__       =				all_frames[..., 7]
  
         lowercase__       =				all_frames[..., 4]
         lowercase__       =				chia_frame_to_bb.compose(A )
         lowercase__       =				chia_frame_to_bb.compose(A )
         lowercase__       =				chia_frame_to_bb.compose(A )
  
         lowercase__       =				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						,				)
  
         lowercase__       =				r[..., None].compose(A )
  
         return all_frames_to_global
  
  def _SCREAMING_SNAKE_CASE   (A						,				A						,				A						,				A						,				A						,				A						,				) -> torch.Tensor:
  
  
  
  
  
  
         """simple docstring"""
  
  
  
  
  
  
  
         lowercase__       =				group_idx[aatype, ...]
  
         # [*, N, 14, 8]
         lowercase__       =				nn.functional.one_hot(
             A						,				num_classes=default_frames.shape[-3]						,				)
  
         # [*, N, 14, 8]
         lowercase__       =				r[..., None, :] * group_mask_one_hot
  
         # [*, N, 14]
         lowercase__       =				t_atoms_to_global.map_tensor_fn(lambda A : torch.sum(A						,				dim=-1 ) )
  
         # [*, N, 14, 1]
         lowercase__       =				atom_mask[aatype, ...].unsqueeze(-1 )
  
         # [*, N, 14, 3]
         lowercase__       =				lit_positions[aatype, ...]
         lowercase__       =				t_atoms_to_global.apply(A )
         lowercase__       =				pred_positions * atom_mask
  
         return pred_positions
  
  
  
  
  
style_context: 
  
  
  '''simple docstring'''
  
  from typing import TYPE_CHECKING
  
  from ...utils import (
      OptionalDependencyNotAvailable,
      _LazyModule,
      is_torch_available,
      is_vision_available,
  )
  
  
  lowerCamelCase							:     Optional[Any]								=			{
      'configuration_mobilevitv2': [
          'MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP',
          'MobileViTV2Config',
          'MobileViTV2OnnxConfig',
      ],
  }
  
  
  try:
   if not is_torch_available():
    raise OptionalDependencyNotAvailable()
  except OptionalDependencyNotAvailable:
   pass
  else:
   lowerCamelCase							:     Optional[int]								=			[
       'MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST',
       'MobileViTV2ForImageClassification',
       'MobileViTV2ForSemanticSegmentation',
       'MobileViTV2Model',
       'MobileViTV2PreTrainedModel',
   ]
  
  if TYPE_CHECKING:
   from .configuration_mobilevitva import (
       MOBILEVITV2_PRETRAINED_CONFIG_ARCHIVE_MAP,
       MobileViTVaConfig,
       MobileViTVaOnnxConfig,
   )
  
   try:
    if not is_torch_available():
     raise OptionalDependencyNotAvailable()
   except OptionalDependencyNotAvailable:
    pass
   else:
    from .modeling_mobilevitva import (
        MOBILEVITV2_PRETRAINED_MODEL_ARCHIVE_LIST,
        MobileViTVaForImageClassification,
        MobileViTVaForSemanticSegmentation,
        MobileViTVaModel,
        MobileViTVaPreTrainedModel,
    )
  
  else:
   import sys
  
   lowerCamelCase							:     Dict								=			_LazyModule(__name__, globals()['__file__'], _import_structure, module_spec=__spec__)
  
  
  
  
  