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        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   None     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         ...
  
  
  @overload
  def        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor     )						->		Tuple[torch.Tensor, torch.Tensor]:
  
         """simple docstring"""
  
  
  
  
  
         ...
  
  
  def        A	(							__snake_case:   List[Any]   ,    __snake_case:   Any   ,    __snake_case:   List[Any]     )						->		Union[str, Any]:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						aatype == rc.restype_order['G']
         __magic_name__										=						rc.atom_order['CA']
         __magic_name__										=						rc.atom_order['CB']
         __magic_name__										=						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:
                __magic_name__										=						torch.where(
                    __snake_case   ,    all_atom_masks[..., ca_idx]   ,    all_atom_masks[..., cb_idx]   ,    )
                return pseudo_beta, pseudo_beta_mask
         else:
                return pseudo_beta
  
  
  def        A	(							__snake_case:   torch.Tensor   ,    __snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						batched_gather(
             __snake_case   ,    batch['residx_atom37_to_atom14']   ,    dim=-2   ,    no_batch_dims=len(atomaa.shape[:-2]     )   ,    )
  
         __magic_name__										=						atomaa_data * batch['atom37_atom_exists'][..., None]
  
         return atomaa_data
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						template_feats['template_aatype']
         __magic_name__										=						template_feats['template_torsion_angles_sin_cos']
         __magic_name__										=						template_feats['template_alt_torsion_angles_sin_cos']
         __magic_name__										=						template_feats['template_torsion_angles_mask']
         __magic_name__										=						torch.cat(
             [
                 nn.functional.one_hot(__snake_case   ,    2_2     ),
                 torsion_angles_sin_cos.reshape(*torsion_angles_sin_cos.shape[:-2]   ,    1_4     ),
                 alt_torsion_angles_sin_cos.reshape(*alt_torsion_angles_sin_cos.shape[:-2]   ,    1_4     ),
                 torsion_angles_mask,
             ]   ,    dim=-1   ,    )
  
         return template_angle_feat
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]   ,    __snake_case:   torch.types.Number   ,    __snake_case:   torch.types.Number   ,    __snake_case:   int   ,    __snake_case:   bool = False   ,    __snake_case:   float = 1E-20   ,    __snake_case:   float = 1E8   ,    )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						batch['template_pseudo_beta_mask']
         __magic_name__										=						template_mask[..., None] * template_mask[..., None, :]
  
         # Compute distogram (this seems to differ slightly from Alg. 5)
         __magic_name__										=						batch['template_pseudo_beta']
         __magic_name__										=						torch.sum((tpb[..., None, :] - tpb[..., None, :, :]) ** 2   ,    dim=-1   ,    keepdim=__snake_case     )
         __magic_name__										=						torch.linspace(__snake_case   ,    __snake_case   ,    __snake_case   ,    device=tpb.device     ) ** 2
         __magic_name__										=						torch.cat([lower[1:], lower.new_tensor([inf]     )]   ,    dim=-1     )
         __magic_name__										=						((dgram > lower) * (dgram < upper)).type(dgram.dtype     )
  
         __magic_name__										=						[dgram, template_mask_ad[..., None]]
  
         __magic_name__										=						nn.functional.one_hot(
             batch['template_aatype']   ,    rc.restype_num + 2   ,    )
  
         __magic_name__										=						batch['template_aatype'].shape[-1]
         to_concat.append(aatype_one_hot[..., None, :, :].expand(*aatype_one_hot.shape[:-2]   ,    __snake_case   ,    -1   ,    -1     )     )
         to_concat.append(aatype_one_hot[..., None, :].expand(*aatype_one_hot.shape[:-2]   ,    -1   ,    __snake_case   ,    -1     )     )
  
         __magic_name__							,     __magic_name__							,     __magic_name__										=						[rc.atom_order[a] for a in ['N', 'CA', 'C']]
         __magic_name__										=						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=__snake_case   ,    )
         __magic_name__										=						rigids.get_trans()[..., None, :, :]
         __magic_name__										=						rigids[..., None].invert_apply(__snake_case     )
  
         __magic_name__										=						torch.rsqrt(eps + torch.sum(rigid_vec**2   ,    dim=-1     )     )
  
         __magic_name__										=						batch['template_all_atom_mask']
         __magic_name__										=						t_aa_masks[..., n] * t_aa_masks[..., ca] * t_aa_masks[..., c]
         __magic_name__										=						template_mask[..., None] * template_mask[..., None, :]
  
         __magic_name__										=						inv_distance_scalar * template_mask_ad
         __magic_name__										=						rigid_vec * inv_distance_scalar[..., None]
  
         if not use_unit_vector:
                __magic_name__										=						unit_vector * 0.0
  
         to_concat.extend(torch.unbind(unit_vector[..., None, :]   ,    dim=-1     )     )
         to_concat.append(template_mask_ad[..., None]     )
  
         __magic_name__										=						torch.cat(__snake_case   ,    dim=-1     )
         __magic_name__										=						act * template_mask_ad[..., None]
  
         return act
  
  
  def        A	(							__snake_case:   Dict[str, torch.Tensor]     )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						nn.functional.one_hot(batch['extra_msa']   ,    2_3     )
         __magic_name__										=						[
             msa_ahot,
             batch['extra_has_deletion'].unsqueeze(-1     ),
             batch['extra_deletion_value'].unsqueeze(-1     ),
         ]
         return torch.cat(__snake_case   ,    dim=-1     )
  
  
  def        A	(							__snake_case:   Rigid   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    )						->		Rigid:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						rrgdf[aatype, ...]
  
         # [*, N, 8] transformations, i.e.
         #   One [*, N, 8, 3, 3] rotation matrix and
         #   One [*, N, 8, 3]    translation matrix
         __magic_name__										=						r.from_tensor_axa(__snake_case     )
  
         __magic_name__										=						alpha.new_zeros((*((1,) * len(alpha.shape[:-1]     )), 2)     )
         __magic_name__										=						1
  
         # [*, N, 8, 2]
         __magic_name__										=						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.
  
         __magic_name__										=						alpha.new_zeros(default_r.get_rots().get_rot_mats().shape     )
         __magic_name__										=						1
         __magic_name__										=						alpha[..., 1]
         __magic_name__										=						-alpha[..., 0]
         __magic_name__										=						alpha
  
         __magic_name__										=						default_r.compose(Rigid(Rotation(rot_mats=__snake_case     )   ,    __snake_case     )     )
  
         __magic_name__										=						all_frames[..., 5]
         __magic_name__										=						all_frames[..., 6]
         __magic_name__										=						all_frames[..., 7]
  
         __magic_name__										=						all_frames[..., 4]
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
         __magic_name__										=						chia_frame_to_bb.compose(__snake_case     )
  
         __magic_name__										=						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   ,    )
  
         __magic_name__										=						r[..., None].compose(__snake_case     )
  
         return all_frames_to_global
  
  
  
  
  
  
  def        A	(							__snake_case:   Rigid   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    __snake_case:   torch.Tensor   ,    )						->		torch.Tensor:
  
         """simple docstring"""
  
  
  
  
  
         __magic_name__										=						group_idx[aatype, ...]
  
         # [*, N, 14, 8]
         __magic_name__										=						nn.functional.one_hot(
             __snake_case   ,    num_classes=default_frames.shape[-3]   ,    )
  
         # [*, N, 14, 8]
         __magic_name__										=						r[..., None, :] * group_mask_one_hot
  
         # [*, N, 14]
         __magic_name__										=						t_atoms_to_global.map_tensor_fn(lambda __snake_case     : torch.sum(__snake_case   ,    dim=-1     )     )
  
         # [*, N, 14, 1]
         __magic_name__										=						atom_mask[aatype, ...].unsqueeze(-1     )
  
         # [*, N, 14, 3]
         __magic_name__										=						lit_positions[aatype, ...]
         __magic_name__										=						t_atoms_to_global.apply(__snake_case     )
         __magic_name__										=						pred_positions * atom_mask
  
         return pred_positions
style_context: 
  
  
  
  
  
  
  """simple docstring"""
  from ...configuration_utils import PretrainedConfig
  from ...utils import logging
  
  
  snake_case   :   int    		=		logging.get_logger(__name__)
  
  snake_case   :   List[str]    		=		{
      """uw-madison/nystromformer-512""": """https://huggingface.co/uw-madison/nystromformer-512/resolve/main/config.json""",
      # See all Nystromformer models at https://huggingface.co/models?filter=nystromformer
  }
  
  
  
  class 					UpperCamelCase__   (							a_):
  
  
  
  
  
  
  
      """simple docstring"""
      __UpperCAmelCase											=   """nystromformer"""
  
  
  
  
  
  
  
      def __init__(		self   :  Dict							,						UpperCamelCase_   :  Optional[Any]=3_0_0_0_0							,						UpperCamelCase_   :  Dict=7_6_8							,						UpperCamelCase_   :  Tuple=1_2							,						UpperCamelCase_   :  Any=1_2							,						UpperCamelCase_   :  List[str]=3_0_7_2							,						UpperCamelCase_   :  Tuple="gelu_new"							,						UpperCamelCase_   :  Optional[Any]=0.1							,						UpperCamelCase_   :  str=0.1							,						UpperCamelCase_   :  Tuple=5_1_0							,						UpperCamelCase_   :  Optional[int]=2							,						UpperCamelCase_   :  Optional[int]=6_4							,						UpperCamelCase_   :  Tuple=6_4							,						UpperCamelCase_   :  Optional[int]=6_5							,						UpperCamelCase_   :  Optional[int]=False							,						UpperCamelCase_   :  List[str]=0.02							,						UpperCamelCase_   :  List[Any]=1e-5							,						UpperCamelCase_   :  Union[str, Any]=1							,						UpperCamelCase_   :  Tuple=0							,						UpperCamelCase_   :  List[Any]=2							,						**UpperCamelCase_   :  str							,						):
  
  
  
  
  
             '''simple docstring'''
  
             __magic_name__										=						vocab_size
             __magic_name__										=						max_position_embeddings
             __magic_name__										=						hidden_size
             __magic_name__										=						num_hidden_layers
             __magic_name__										=						num_attention_heads
             __magic_name__										=						intermediate_size
             __magic_name__										=						hidden_act
             __magic_name__										=						hidden_dropout_prob
             __magic_name__										=						attention_probs_dropout_prob
             __magic_name__										=						initializer_range
             __magic_name__										=						type_vocab_size
             __magic_name__										=						segment_means_seq_len
             __magic_name__										=						num_landmarks
             __magic_name__										=						conv_kernel_size
             __magic_name__										=						inv_coeff_init_option
             __magic_name__										=						layer_norm_eps
             super().__init__(pad_token_id=UpperCamelCase_							,						bos_token_id=UpperCamelCase_							,						eos_token_id=UpperCamelCase_							,						**UpperCamelCase_   )