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