






"""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







"""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_   )