| """ |
| Model interface definitions for ODesign. |
| |
| This module defines data structures for inputs and outputs of various model components: |
| - GroundTruth: Ground truth labels for training |
| - PairFormerInput/Output: Input/output for PairFormer module |
| - DiffusionInput/Output: Input/output for Diffusion module |
| - PermutationInput: Input for symmetric permutation |
| - ODesignOutput: Final model output |
| - LossInput: Input features for loss computation |
| |
| Note: |
| - For input classes, use @auto_type_convert to automatically convert types |
| - For output classes, avoid @auto_type_convert for mixed precision training compatibility |
| """ |
|
|
| import torch |
| import numpy as np |
| from typing import List |
| from attr import define |
| from ._base import * |
| from .data_interface import OFeatureData, OLabelData |
| from src.utils.license_register import register_license |
|
|
| @define |
| @register_license('odesign2025') |
| @auto_type_convert |
| class GroundTruth(DictAccessMixin): |
| """ |
| Ground truth labels for model training and evaluation. |
| |
| This class contains all ground truth information including atomic coordinates, |
| bond information, masks, and metadata needed for loss computation. |
| |
| Attributes: |
| coordinate (FeatureType): Ground truth atomic coordinates. |
| Shape: [N_atom, 3] |
| coordinate_mask (MaskType): Mask indicating which atoms have valid coordinates. |
| Shape: [N_atom] |
| |
| token_bond_type_label (FeatureType, optional): Bond type labels for token pairs. |
| Shape: [N_token, N_token] |
| ligand_bond_mask (MaskType, optional): Mask for ligand bonds. |
| Shape: [N_atom, N_atom] or [N_token, N_token] |
| |
| entity_mol_id (IndexType, optional): Entity molecule ID for each atom. |
| Shape: [N_atom] |
| mol_id (IndexType, optional): Molecule ID for each atom. |
| Shape: [N_atom] |
| mol_atom_index (IndexType, optional): Atom index within molecule. |
| Shape: [N_atom] |
| |
| pae_rep_atom_mask (MaskType, optional): Representative atom mask for PAE computation. |
| Shape: [N_atom] |
| |
| eval_type (np.ndarray, optional): Evaluation type identifier. |
| cluster_id (np.ndarray, optional): Cluster ID for evaluation. |
| chain_1_mask (MaskType, optional): Mask for chain 1 in interface evaluation. |
| Shape: [N_atom] |
| chain_2_mask (MaskType, optional): Mask for chain 2 in interface evaluation. |
| Shape: [N_atom] |
| |
| lddt_mask (MaskType, optional): Mask for lDDT computation (distance within threshold). |
| Shape: [N_atom, N_atom] |
| distance_mask (MaskType, optional): Mask for valid distance pairs. |
| Shape: [N_atom, N_atom] |
| distance (FeatureType, optional): Precomputed pairwise distances. |
| Shape: [N_atom, N_atom] |
| """ |
| coordinate: FeatureType |
| coordinate_mask: MaskType |
|
|
| token_bond_type_label: FeatureType | None = None |
| ligand_bond_mask: MaskType | None = None |
|
|
| entity_mol_id: IndexType | None = None |
| mol_id: IndexType | None = None |
| mol_atom_index: IndexType | None = None |
|
|
| pae_rep_atom_mask: MaskType | None = None |
|
|
| eval_type: np.ndarray | None = None |
| cluster_id: np.ndarray | None = None |
| chain_1_mask: MaskType | None = None |
| chain_2_mask: MaskType | None = None |
|
|
| lddt_mask: MaskType | None = None |
| distance_mask: MaskType | None = None |
| distance: FeatureType | None = None |
|
|
| @classmethod |
| def from_label_data(cls, input_data: OLabelData) -> "GroundTruth": |
| all_fields = {field.name for field in attr.fields(cls)} |
| filtered_dict = {k: v for k, v in input_data.items() if k in all_fields} |
| def _check_required_fields(filtered_dict): |
| required_fields = { |
| field.name for field in attr.fields(cls) |
| if field.default == attr.NOTHING |
| } |
| missing_fields = required_fields - set(filtered_dict.keys()) |
| assert not missing_fields, f"Missing required fields in {cls.__name__}: {missing_fields}" |
|
|
| _check_required_fields(filtered_dict) |
| return cls(**filtered_dict) |
| |
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class PairFormerInput(DictAccessMixin): |
| """ |
| Input features for PairFormer module (Algorithm 17 in AlphaFold3). |
| |
| This class contains all input features needed for the PairFormer trunk, |
| including residue-level features, MSA features, atomic features, and |
| positional encoding information. |
| |
| Attributes: |
| residue_index (IndexType): Residue index in the sequence. |
| Shape: [N_token] |
| restype (OneHotType): One-hot encoded residue type. |
| Shape: [N_token, n_residue_types] |
| token_bonds (FeatureType): Bond features between tokens. |
| Shape: [N_token, N_token, n_bond_features] |
| profile (FeatureType): Sequence profile from MSA (e.g., position-specific scoring). |
| Shape: [N_token, 32] |
| deletion_mean (FeatureType): Mean deletion probability from MSA. |
| Shape: [N_token] |
| is_hotspot_residue (FeatureType): Binary flag indicating hotspot residues. |
| Shape: [N_token] |
| |
| msa (FeatureType): Multiple sequence alignment features. |
| Shape: [N_msa, N_token, n_msa_features] |
| has_deletion (MaskType): Mask indicating presence of deletions in MSA. |
| Shape: [N_msa, N_token] |
| deletion_value (FeatureType): Deletion values in MSA. |
| Shape: [N_msa, N_token] |
| msa_token_mask (MaskType): Mask for valid MSA tokens. |
| Shape: [N_msa, N_token] |
| |
| ref_pos (FeatureType): Reference atomic positions (from structure). |
| Shape: [N_atom, 3] |
| ref_space_uid (IndexType): Spatial unit ID for grouping atoms in same reference frame. |
| Shape: [N_atom] |
| |
| ref_element (FeatureType): Atomic element encoding. |
| Shape: [N_atom, n_elements] (one-hot or embedding) |
| ref_charge (FeatureType): Atomic partial charge. |
| Shape: [N_atom] |
| ref_mask (MaskType): Mask indicating valid reference atoms. |
| Shape: [N_atom] |
| ref_atom_name_chars (OneHotType): One-hot encoded atom name characters. |
| Shape: [N_atom, 4, n_char_types] |
| |
| atom_to_token_idx (IndexType): Mapping from atom index to token index. |
| Shape: [N_atom] |
| |
| asym_id (IndexType): Asymmetric unit ID (chain identifier). |
| Shape: [N_token] |
| entity_id (IndexType): Entity ID (molecule type identifier). |
| Shape: [N_token] |
| sym_id (IndexType): Symmetry operation ID. |
| Shape: [N_token] |
| token_index (IndexType): Token index within residue. |
| Shape: [N_token] |
| |
| constraint_feature (FeatureType): Constraint features for token pairs |
| (e.g., from pocket, contact, substructure constraints). |
| Shape: [N_token, N_token, n_constraint_features] |
| token_bond_gen_mask (MaskType): Mask for bond type generation/evaluation. |
| Shape: [N_token, N_token] |
| |
| is_cyclic_token (FlagType, optional): Flag indicating cyclic peptide tokens. |
| Shape: [N_token] |
| """ |
| |
| residue_index: IndexType |
| restype: OneHotType |
| token_bonds: FeatureType |
| profile: FeatureType |
| deletion_mean: FeatureType |
| is_hotspot_residue: FeatureType |
|
|
| |
| msa: FeatureType |
| has_deletion: MaskType |
| deletion_value: FeatureType |
| msa_token_mask: MaskType |
|
|
| |
| ref_pos: FeatureType |
| ref_space_uid: IndexType |
|
|
| |
| ref_element: FeatureType |
| ref_charge: FeatureType |
| ref_mask: MaskType |
| ref_atom_name_chars: OneHotType |
|
|
| |
| atom_to_token_idx: IndexType |
|
|
| |
| asym_id: IndexType |
| entity_id: IndexType |
| sym_id: IndexType |
| token_index: IndexType |
|
|
| |
| constraint_feature: FeatureType |
| token_bond_gen_mask: MaskType |
|
|
| |
| is_cyclic_token: FlagType | None = None |
|
|
| @classmethod |
| def from_feature_data(cls, input_data: OFeatureData) -> "PairFormerInput": |
| all_fields = {field.name for field in attr.fields(cls)} |
| filtered_dict = {k: v for k, v in input_data.items() if k in all_fields} |
| def _check_required_fields(filtered_dict): |
| required_fields = { |
| field.name for field in attr.fields(cls) |
| if field.default == attr.NOTHING |
| } |
| missing_fields = required_fields - set(filtered_dict.keys()) |
| assert not missing_fields, f"Missing required fields in {cls.__name__}: {missing_fields}" |
|
|
| _check_required_fields(filtered_dict) |
| return cls(**filtered_dict) |
|
|
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class PairFormerOutput(DictAccessMixin): |
| """ |
| Output embeddings from PairFormer trunk module. |
| |
| This class contains the single (per-token) and pair (per-token-pair) embeddings |
| produced by the PairFormer trunk, which are used by downstream modules like |
| the Diffusion module and Pairwise heads. |
| |
| Attributes: |
| s_inputs (EmbeddingType): Input single embeddings before PairFormer processing. |
| Concatenation of per-token features from InputFeatureEmbedder. |
| Shape: [N_token, c_s_inputs] |
| where c_s_inputs = c_token + sum(INPUTFEATS_DIMS) ≈ 449 |
| |
| s (EmbeddingType): Single embeddings after PairFormer processing. |
| Processed through PairFormer stack (MSA + Pairformer blocks). |
| Shape: [N_token, c_s] |
| where c_s = 384 (default) |
| |
| z (PairwiseEmbeddingType): Pair embeddings after PairFormer processing. |
| Captures pairwise relationships between tokens. |
| Shape: [N_token, N_token, c_z] |
| where c_z = 128 (default) |
| |
| Methods: |
| get_embedding(): Returns tuple of (s_inputs, s, z) for downstream use. |
| """ |
| s_inputs: EmbeddingType |
| s: EmbeddingType |
| z: PairwiseEmbeddingType |
|
|
| def get_embedding(self) -> tuple[EmbeddingType, EmbeddingType, PairwiseEmbeddingType]: |
| """ |
| Get all embedding outputs as a tuple. |
| |
| Returns: |
| tuple: (s_inputs, s, z) embeddings for downstream modules. |
| """ |
| return self.s_inputs, self.s, self.z |
|
|
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class PairwiseOutput(DictAccessMixin): |
| """ |
| Output from Pairwise prediction heads. |
| |
| This class contains predictions for token-level pairwise properties including |
| distance distributions (distogram) and bond types. |
| |
| Attributes: |
| distogram (LogitsType): Distance distribution logits for token pairs. |
| Predicts binned distances between representative atoms of token pairs. |
| Shape: [N_token, N_token, n_distance_bins] |
| where n_distance_bins = 64 (default, covering 2.3-21.7 Å) |
| |
| token_bond_type_logits (LogitsType): Bond type prediction logits. |
| Predicts chemical bond types between token pairs. |
| Shape: [N_token, N_token, n_bond_types] |
| where n_bond_types includes: no_bond, single, double, triple, aromatic, etc. |
| """ |
| distogram: LogitsType |
| token_bond_type_logits: LogitsType |
|
|
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class DiffusionInput(DictAccessMixin): |
| """ |
| Input features for Diffusion module (Algorithm 20 in AlphaFold3). |
| |
| This class contains the atomic-level features needed for the diffusion-based |
| structure generation module, including reference positions, atomic properties, |
| and conditioning information. |
| |
| Attributes: |
| ref_pos (FeatureType): Reference atomic positions (ground truth or initial guess). |
| Shape: [N_atom, 3] |
| |
| ref_space_uid (IndexType): Spatial unit ID for grouping atoms in same reference frame. |
| Used for residue-level symmetric atom permutation. |
| Shape: [N_atom] |
| |
| ref_element (FeatureType): Atomic element encoding. |
| Shape: [N_atom, n_elements] or [N_atom] |
| |
| ref_mask (MaskType): Mask indicating valid atoms (exists in structure). |
| Shape: [N_atom] |
| |
| ref_atom_name_chars (OneHotType): One-hot encoded atom name characters. |
| Used in AtomAttentionEncoder for atom identification. |
| Shape: [N_atom, 4, n_char_types] |
| |
| ref_charge (FeatureType): Atomic partial charge. |
| Shape: [N_atom] |
| |
| atom_to_token_idx (IndexType): Mapping from atom index to token index. |
| Used for aggregating atom features to token level. |
| Shape: [N_atom] |
| |
| residue_index (IndexType): Residue index in sequence. |
| Shape: [N_token] |
| |
| asym_id (IndexType): Asymmetric unit ID (chain identifier). |
| Shape: [N_token] |
| |
| entity_id (IndexType): Entity ID (molecule type identifier). |
| Shape: [N_token] |
| |
| sym_id (IndexType): Symmetry operation ID. |
| Shape: [N_token] |
| |
| token_index (IndexType): Token index within residue. |
| Shape: [N_token] |
| |
| is_condition_atom (MaskType): Mask indicating which atoms are conditioned |
| (fixed during diffusion, not generated). |
| Shape: [N_atom] |
| |
| is_cyclic_token (FlagType, optional): Flag for cyclic peptide tokens. |
| Shape: [N_token] |
| |
| cyclic_mode (str, optional): Mode for handling cyclic structures. |
| Options: "full", "partial". Defaults to "full". |
| |
| cycle_bonds (list, optional): List of bonds forming cycles. |
| For cyclic peptide constraint handling. |
| """ |
| ref_pos: FeatureType |
| ref_space_uid: IndexType |
|
|
| ref_element: FeatureType |
| ref_mask: MaskType |
| ref_atom_name_chars: OneHotType |
| ref_charge: FeatureType |
|
|
| atom_to_token_idx: IndexType |
|
|
| residue_index: IndexType |
| asym_id: IndexType |
| entity_id: IndexType |
| sym_id: IndexType |
| token_index: IndexType |
|
|
| is_condition_atom: MaskType |
|
|
| is_cyclic_token: FlagType | None = None |
| cyclic_mode: str = "full" |
| cycle_bonds: list = [] |
| |
| @classmethod |
| def from_feature_data(cls, input_data: OFeatureData) -> "DiffusionInput": |
| all_fields = {field.name for field in attr.fields(cls)} |
| filtered_dict = {k: v for k, v in input_data.items() if k in all_fields} |
| def _check_required_fields(filtered_dict): |
| required_fields = { |
| field.name for field in attr.fields(cls) |
| if field.default == attr.NOTHING |
| } |
| missing_fields = required_fields - set(filtered_dict.keys()) |
| assert not missing_fields, f"Missing required fields in {cls.__name__}: {missing_fields}" |
|
|
| _check_required_fields(filtered_dict) |
| return cls(**filtered_dict) |
| |
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class DiffusionOutput(DictAccessMixin): |
| """ |
| Output from Diffusion module. |
| |
| This class contains the denoised atomic coordinates predicted by the |
| diffusion module, along with optional noise level information. |
| |
| Attributes: |
| x_denoised (FeatureType): Denoised atomic coordinates. |
| In training: Output of denoising network F_θ at given noise level. |
| In inference: Final denoised coordinates after full diffusion sampling. |
| Shape: [N_sample, N_atom, 3] (training/rollout) or [N_atom, 3] (inference) |
| |
| sigma (torch.Tensor, optional): Noise level(s) used for denoising. |
| In training: Sampled noise level from log-normal distribution. |
| In inference: Sequence of noise levels from sampling schedule. |
| Shape: [N_sample] or scalar |
| """ |
| x_denoised: FeatureType |
| sigma: torch.Tensor | None = None |
|
|
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class PermutationInput(DictAccessMixin): |
| """ |
| Input features for symmetric permutation operations. |
| |
| This class contains the information needed to perform chain permutation |
| and atom permutation to resolve symmetry ambiguities in structures. |
| Used in training to align ground truth to predictions. |
| |
| Attributes: |
| entity_mol_id (IndexType): Entity molecule ID for each atom. |
| Used to group atoms by molecule for permutation. |
| Shape: [N_atom] |
| |
| mol_id (IndexType): Molecule ID for each atom. |
| Identifies individual molecules (multiple copies of same entity). |
| Shape: [N_atom] |
| |
| mol_atom_index (IndexType): Atom index within molecule. |
| Maps atoms to their position within molecule for permutation. |
| Shape: [N_atom] |
| |
| pae_rep_atom_mask (MaskType): Representative atom mask for PAE computation. |
| Identifies atoms used as representatives for token-level metrics. |
| Shape: [N_atom] |
| |
| is_ligand (MaskType): Mask indicating ligand atoms. |
| Used for ligand-specific permutation handling. |
| Shape: [N_atom] |
| |
| masked_asym_ids (List[int]): List of asymmetric unit IDs to consider |
| for permutation. Used to select which chains can be permuted. |
| |
| ref_space_uid (IndexType): Spatial unit ID for residue-level grouping. |
| Used for symmetric atom permutation within residues. |
| Shape: [N_atom] |
| |
| atom_perm_list (List[int]): List of atom permutation groups. |
| Defines which atoms can be permuted (e.g., symmetric atoms in |
| aromatic rings, carboxyl groups, etc.). |
| """ |
| entity_mol_id: IndexType |
| mol_id: IndexType |
| mol_atom_index: IndexType |
|
|
| pae_rep_atom_mask: MaskType |
| is_ligand: MaskType |
| masked_asym_ids: List[int] |
|
|
| ref_space_uid: IndexType |
| atom_perm_list: List[int] |
|
|
| @classmethod |
| def from_feature_data(cls, input_data: OFeatureData) -> "PermutationInput": |
| all_fields = {field.name for field in attr.fields(cls)} |
| filtered_dict = {k: v for k, v in input_data.items() if k in all_fields} |
| def _check_required_fields(filtered_dict): |
| required_fields = { |
| field.name for field in attr.fields(cls) |
| if field.default == attr.NOTHING |
| } |
| missing_fields = required_fields - set(filtered_dict.keys()) |
| assert not missing_fields, f"Missing required fields in {cls.__name__}: {missing_fields}" |
|
|
| _check_required_fields(filtered_dict) |
| return cls(**filtered_dict) |
| |
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class ODesignOutput(DictAccessMixin): |
| """ |
| Complete output from ODesign model. |
| |
| This class aggregates outputs from all model components including |
| pairwise predictions (distogram, bonds) and structural predictions |
| (atomic coordinates from diffusion). |
| |
| Attributes: |
| token_bond_type_logits (LogitsType, optional): Predicted bond type logits. |
| Output from PairwiseHead for bond type classification. |
| Shape: [N_token, N_token, n_bond_types] |
| |
| distogram (LogitsType, optional): Distance distribution logits. |
| Output from DistogramHead for distance prediction. |
| Shape: [N_token, N_token, n_distance_bins] |
| |
| token_bond_gen_mask (MaskType, optional): Mask for bond generation evaluation. |
| Indicates which token pairs should be evaluated for bond prediction. |
| Shape: [N_token, N_token] |
| |
| coordinate (FeatureType, optional): Predicted atomic coordinates. |
| Output from Diffusion module. |
| Shape: [N_sample, N_atom, 3] (training/rollout) or [N_atom, 3] (inference) |
| |
| noise_level (torch.Tensor, optional): Noise levels used in diffusion. |
| Shape: [N_sample] (training) or [N_diffusion_steps] (inference) |
| |
| distance (FeatureType, optional): Precomputed pairwise distances from coordinates. |
| Used for efficient loss computation when not using sparse mode. |
| Shape: [N_sample, N_atom, N_atom] or [N_atom, N_atom] |
| |
| Note: |
| Fields are optional as different components may be enabled/disabled |
| based on training configuration (e.g., distogram may be disabled |
| in some training stages). |
| """ |
| |
| token_bond_type_logits: LogitsType | None = None |
| distogram: LogitsType | None = None |
|
|
| |
| token_bond_gen_mask: MaskType | None = None |
|
|
| |
| coordinate: FeatureType | None = None |
| noise_level: torch.Tensor | None = None |
| distance: FeatureType | None = None |
|
|
|
|
| @define |
| @auto_type_convert |
| @register_license('odesign2025') |
| class LossInput(DictAccessMixin): |
| """ |
| Input features for loss computation. |
| |
| This class contains molecular type information and metadata needed |
| for computing various loss components with appropriate weighting and |
| filtering. |
| |
| Attributes: |
| is_rna (MaskType): Binary mask indicating RNA atoms. |
| Used for RNA-specific loss weighting in MSE loss. |
| Shape: [N_atom] |
| |
| is_dna (MaskType): Binary mask indicating DNA atoms. |
| Used for DNA-specific loss weighting in MSE loss. |
| Shape: [N_atom] |
| |
| is_ligand (MaskType): Binary mask indicating ligand atoms. |
| Used for ligand-specific loss weighting and bond loss computation. |
| Shape: [N_atom] |
| |
| is_condition_atom (MaskType): Mask indicating conditioned (fixed) atoms. |
| Used to determine alignment strategy and filter generation atoms. |
| Shape: [N_atom] |
| |
| resolution (FeatureType): Structure resolution in Angstroms. |
| Used to filter confidence loss computation (only for structures |
| with resolution in valid range). |
| Shape: scalar or [1] |
| |
| distogram_rep_atom_mask (MaskType, optional): Representative atom mask |
| for distogram loss computation. Identifies atoms used as token |
| representatives (Cβ/Cα for proteins, C4'/C2' for nucleotides). |
| Shape: [N_atom] |
| |
| Note: |
| MSE loss uses different weights for different molecule types: |
| - RNA: weight_rna (default 5.0) |
| - DNA: weight_dna (default 5.0) |
| - Ligand: weight_ligand (default 10.0) |
| - Others: weight 1.0 |
| """ |
| is_rna: MaskType |
| is_dna: MaskType |
| is_ligand: MaskType |
| is_condition_atom: MaskType |
| resolution: FeatureType |
| distogram_rep_atom_mask: MaskType | None |
|
|
| @classmethod |
| def from_feature_data(cls, input_data: OFeatureData) -> "PermutationInput": |
| all_fields = {field.name for field in attr.fields(cls)} |
| filtered_dict = {k: v for k, v in input_data.items() if k in all_fields} |
| def _check_required_fields(filtered_dict): |
| required_fields = { |
| field.name for field in attr.fields(cls) |
| if field.default == attr.NOTHING |
| } |
| missing_fields = required_fields - set(filtered_dict.keys()) |
| assert not missing_fields, f"Missing required fields in {cls.__name__}: {missing_fields}" |
|
|
| _check_required_fields(filtered_dict) |
| return cls(**filtered_dict) |
