| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| |
|
|
| """ |
| ODesign: Main model architecture for protein structure prediction and generation. |
| |
| This module implements the core ODesign model architecture, which is based on AlphaFold3's |
| design and adapted for both structure prediction and conditional generation tasks. |
| |
| Main Components: |
| ODesign: Main model class implementing the full forward pass including: |
| - Input feature embedding |
| - MSA (Multiple Sequence Alignment) processing |
| - Pairformer module for residue and pair representations |
| - Diffusion module for coordinate generation |
| - Pairwise prediction heads (distogram, bond types) |
| - Multi-cycle refinement |
| - Symmetric permutation handling |
| |
| Key Features: |
| - Multi-cycle iterative refinement |
| - Multiple model seed sampling for ensemble predictions |
| - Training and inference modes with different noise schedulers |
| - Support for constraint-based generation (distogram constraints) |
| - Memory-efficient kernels and chunking for large structures |
| - DeepSpeed EVO attention optimization |
| - Automatic mixed precision (AMP) support |
| - Symmetric permutation for handling molecular symmetries |
| |
| Architecture Flow: |
| 1. Input Embedding: Convert input features to token and pair representations |
| 2. MSA Module: Process multiple sequence alignments |
| 3. Pairformer Stack: Iterative refinement of token and pair representations |
| 4. Pairwise Head: Predict distogram and bond types |
| 5. Diffusion Module: Generate 3D coordinates through denoising |
| 6. Permutation: Handle molecular symmetries |
| |
| Training vs Inference: |
| - Training: Single cycle randomly selected, gradient enabled only on last cycle |
| - Inference: Fixed number of cycles, multiple model seeds for ensemble |
| """ |
|
|
| import copy |
| import random |
| import logging |
| import time |
| from typing import Any, Optional |
|
|
| import numpy as np |
| import torch |
| import torch.nn as nn |
|
|
| from src.utils.license_register import register_license |
| from src.api.data_interface import OFeatureData, OLabelData |
| from src.api.model_interface import ( |
| PairFormerInput, |
| PairFormerOutput, |
| DiffusionInput, |
| PermutationInput, |
| LossInput, |
| GroundTruth, |
| PairwiseOutput, |
| ODesignOutput |
| ) |
|
|
| from src.model.modules.generator import ( |
| sample_diffusion, |
| sample_diffusion_training, |
| ) |
| from src.model.modules.schedulers import ( |
| TrainingNoiseEDMScheduler, |
| InferenceNoiseEDMScheduler |
| ) |
|
|
| from src.utils.openfold_local.model.primitives import LayerNorm |
| from src.utils.permutation.permutation import SymmetricPermutation |
| from src.utils.model.torch_utils import ( |
| autocasting_disable_decorator, |
| cat_dict |
| ) |
|
|
| from .modules.diffusion import DiffusionModule |
| from .modules.embedders import ( |
| InputFeatureEmbedder, |
| RelativePositionEncoding, |
| ) |
| from .modules.head import PairwiseHead |
| from .modules.pairformer import MSAModule, PairformerStack |
| from .modules.primitives import LinearNoBias |
| from .modules.pairformer import ConstraintTemplateEmbedder |
|
|
| logger = logging.getLogger(__name__) |
|
|
| @register_license('odesign2025') |
| class ODesign(nn.Module): |
| """ |
| ODesign main model implementing AlphaFold3-inspired architecture. |
| |
| This class implements the complete pipeline for protein structure prediction and |
| generation, including input embedding, MSA processing, pairformer iterations, |
| diffusion-based coordinate generation, and pairwise predictions. |
| |
| The model operates in three modes: |
| - train: Training mode with gradient computation and random cycle selection |
| - inference: Inference mode with multiple model seeds for ensemble predictions |
| - eval: Evaluation mode with symmetry-aware permutation matching |
| |
| Architecture Components: |
| 1. Input Feature Embedder: Embeds input features (sequence, positions, etc.) |
| 2. Relative Position Encoding: Encodes token-token relative positions |
| 3. MSA Module: Processes multiple sequence alignments |
| 4. Constraint Embedder (optional): Embeds constraint distograms for conditional generation |
| 5. Pairformer Stack: Iterative refinement of single and pair representations |
| 6. Diffusion Module: Denoising network for coordinate generation |
| 7. Pairwise Head: Predicts distogram and token bond types |
| |
| Attributes: |
| configs: Model configuration object |
| N_cycle: Number of refinement cycles |
| N_model_seed: Number of model seeds for inference ensemble |
| train_noise_schedulers: Noise schedulers for training |
| inference_noise_schedulers: Noise schedulers for inference |
| diffusion_batch_size: Batch size for diffusion sampling |
| input_embedder: Input feature embedding module |
| relative_position_encoding: Relative position encoding module |
| msa_module: MSA processing module |
| constraint_distogram_embedder: Constraint embedding module (optional) |
| pairformer_stack: Pairformer refinement module |
| diffusion_module: Diffusion denoising module |
| pairwise_head: Pairwise prediction head |
| c_s: Single representation channel dimension |
| c_z: Pair representation channel dimension |
| c_s_inputs: Input feature channel dimension |
| |
| Multi-Cycle Refinement: |
| The model iteratively refines representations through N_cycle iterations: |
| - Each cycle processes: z_init -> MSA -> Pairformer -> updated (s, z) |
| - Gradient is only computed on the last cycle during training |
| - Previous cycle outputs are used to initialize the next cycle |
| |
| Diffusion Process: |
| - Training: Uses ground truth coordinates to generate noisy samples for denoising |
| - Inference: Starts from random noise and iteratively denoises to predict structure |
| """ |
|
|
| def __init__(self, configs) -> None: |
| """ |
| Initialize the ODesign model. |
| |
| Args: |
| configs: Configuration object containing all model hyperparameters including: |
| - model.N_cycle: Number of refinement cycles |
| - model.N_model_seed: Number of model seeds for inference |
| - model.train_noise_schedulers: Training noise scheduler configs |
| - model.inference_noise_schedulers: Inference noise scheduler configs |
| - model.input_embedder: Input embedder configuration |
| - model.relative_position_encoding: Relative position encoding config |
| - model.msa_module: MSA module configuration |
| - model.constraint_distogram_embedder: Constraint embedder config (optional) |
| - model.pairformer: Pairformer stack configuration |
| - model.diffusion_module: Diffusion module configuration |
| - model.pairwise_head: Pairwise head configuration |
| - model.c_s, c_z, c_s_inputs: Channel dimensions |
| - diffusion_batch_size: Diffusion sampling batch size |
| - data_condition: Data conditioning types (e.g., ['constraint_distogram']) |
| |
| Returns: |
| None |
| """ |
| super(ODesign, self).__init__() |
| self.configs = configs |
| |
| |
| self.N_cycle = self.configs.model.N_cycle |
| self.N_model_seed = self.configs.model.N_model_seed |
|
|
| |
| self.train_noise_schedulers = { |
| "coordinate" : TrainingNoiseEDMScheduler(**configs.model.train_noise_schedulers.coordinate) |
| } |
| self.inference_noise_schedulers = { |
| "coordinate": InferenceNoiseEDMScheduler(**configs.model.inference_noise_schedulers.coordinate) |
| } |
| self.diffusion_batch_size = self.configs.diffusion_batch_size |
|
|
| |
| self.input_embedder = InputFeatureEmbedder(**configs.model.input_embedder) |
| self.relative_position_encoding = RelativePositionEncoding( |
| **configs.model.relative_position_encoding |
| ) |
| self.msa_module = MSAModule( |
| **configs.model.msa_module, |
| msa_configs=configs.data.get("msa", {}), |
| ) |
|
|
| if set(self.configs.data_condition) & set(['constraint_distogram']): |
| self.constraint_distogram_embedder = ConstraintTemplateEmbedder(**configs.model.constraint_distogram_embedder) |
| |
| self.pairformer_stack = PairformerStack(**configs.model.pairformer) |
| self.diffusion_module = DiffusionModule(**configs.model.diffusion_module) |
| self.pairwise_head = PairwiseHead(**configs.model.pairwise_head) |
|
|
| self.c_s, self.c_z, self.c_s_inputs = ( |
| configs.model.c_s, |
| configs.model.c_z, |
| configs.model.c_s_inputs, |
| ) |
| self.linear_no_bias_sinit = LinearNoBias( |
| in_features=self.c_s_inputs, out_features=self.c_s |
| ) |
| self.linear_no_bias_zinit1 = LinearNoBias( |
| in_features=self.c_s, out_features=self.c_z |
| ) |
| self.linear_no_bias_zinit2 = LinearNoBias( |
| in_features=self.c_s, out_features=self.c_z |
| ) |
| self.linear_no_bias_token_bond = LinearNoBias( |
| in_features=1, out_features=self.c_z |
| ) |
| self.linear_no_bias_z_cycle = LinearNoBias( |
| in_features=self.c_z, out_features=self.c_z |
| ) |
| self.linear_no_bias_s = LinearNoBias( |
| in_features=self.c_s, out_features=self.c_s |
| ) |
| self.layernorm_z_cycle = LayerNorm(self.c_z) |
| self.layernorm_s = LayerNorm(self.c_s) |
|
|
| nn.init.zeros_(self.linear_no_bias_z_cycle.weight) |
| nn.init.zeros_(self.linear_no_bias_s.weight) |
|
|
| def get_pairformer_output( |
| self, |
| input_data: PairFormerInput, |
| N_cycle: int, |
| inplace_safe: bool = False, |
| chunk_size: int | None = None, |
| ) -> PairFormerOutput: |
| """ |
| Forward pass from input features to pairformer output representations. |
| |
| This method processes input features through multiple cycles of refinement: |
| 1. Input Embedding: Embed input features to s_inputs |
| 2. Initialization: Create initial single (s) and pair (z) representations |
| 3. Multi-cycle Refinement: Iteratively refine s and z through: |
| - Constraint embedding (optional) |
| - MSA module processing |
| - Pairformer stack processing |
| |
| The multi-cycle strategy allows the model to iteratively refine its predictions, |
| with gradient computation only on the last cycle during training for efficiency. |
| |
| Args: |
| input_data: PairFormerInput object containing: |
| - residue_index: Residue indices [N_token] |
| - token_bonds: Token bond connectivity [N_token, N_token] |
| - And other input features (see PairFormerInput for complete list) |
| N_cycle: Number of refinement cycles to perform (typically 1-4) |
| inplace_safe: Whether it is safe to use inplace operations for memory efficiency. |
| Set to True during inference when gradients are not needed. Defaults to False. |
| chunk_size: Chunk size for memory-efficient operations. Used to reduce memory |
| consumption for large structures. Defaults to None (no chunking). |
| |
| Returns: |
| PairFormerOutput: Object containing: |
| - s_inputs: Initial embedded single representations [N_token, c_s_inputs] |
| - s: Refined single representations [N_token, c_s] |
| - z: Refined pair representations [N_token, N_token, c_z] |
| |
| Note: |
| - For small structures (N_token <= 16), DeepSpeed EVO attention is disabled |
| - Gradient is only enabled on the last cycle during training |
| - Inplace operations are used when safe to reduce memory usage |
| """ |
| N_token = input_data.residue_index.shape[-1] |
| if N_token <= 16: |
| |
| deepspeed_evo_attention_condition_satisfy = False |
| else: |
| deepspeed_evo_attention_condition_satisfy = True |
|
|
| s_inputs = self.input_embedder( |
| input_data, inplace_safe=False, chunk_size=chunk_size |
| ) |
|
|
| s_init = self.linear_no_bias_sinit(s_inputs) |
| z_init = ( |
| self.linear_no_bias_zinit1(s_init)[..., None, :] |
| + self.linear_no_bias_zinit2(s_init)[..., None, :, :] |
| ) |
| if inplace_safe: |
| z_init += self.relative_position_encoding(input_data) |
| z_init += self.linear_no_bias_token_bond( |
| input_data.token_bonds.unsqueeze(dim=-1) |
| ) |
| else: |
| z_init = z_init + self.relative_position_encoding(input_data) |
| z_init = z_init + self.linear_no_bias_token_bond( |
| input_data.token_bonds.unsqueeze(dim=-1) |
| ) |
| z = torch.zeros_like(z_init) |
| s = torch.zeros_like(s_init) |
|
|
| for cycle_no in range(N_cycle): |
| with torch.set_grad_enabled( |
| self.training |
| and cycle_no == (N_cycle - 1) |
| ): |
| z = z_init + self.linear_no_bias_z_cycle(self.layernorm_z_cycle(z)) |
| if inplace_safe: |
| if set(self.configs.data_condition) & set(['constraint_distogram']): |
| z += self.constraint_distogram_embedder( |
| input_data, |
| z, |
| pair_mask=None, |
| use_memory_efficient_kernel=self.configs.model.use_memory_efficient_kernel, |
| use_deepspeed_evo_attention=self.configs.model.use_deepspeed_evo_attention |
| and deepspeed_evo_attention_condition_satisfy, |
| use_lma=self.configs.model.use_lma, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| z = self.msa_module( |
| input_data, |
| z, |
| s_inputs, |
| pair_mask=None, |
| use_memory_efficient_kernel=self.configs.model.use_memory_efficient_kernel, |
| use_deepspeed_evo_attention=self.configs.model.use_deepspeed_evo_attention |
| and deepspeed_evo_attention_condition_satisfy, |
| use_lma=self.configs.model.use_lma, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| else: |
| if set(self.configs.data_condition) & set(['constraint_distogram']): |
| z = z + self.constraint_distogram_embedder( |
| input_data, |
| z, |
| pair_mask=None, |
| use_memory_efficient_kernel=self.configs.model.use_memory_efficient_kernel, |
| use_deepspeed_evo_attention=self.configs.model.use_deepspeed_evo_attention |
| and deepspeed_evo_attention_condition_satisfy, |
| use_lma=self.configs.model.use_lma, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| z = self.msa_module( |
| input_data, |
| z, |
| s_inputs, |
| pair_mask=None, |
| use_memory_efficient_kernel=self.configs.model.use_memory_efficient_kernel, |
| use_deepspeed_evo_attention=self.configs.model.use_deepspeed_evo_attention |
| and deepspeed_evo_attention_condition_satisfy, |
| use_lma=self.configs.model.use_lma, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| s = s_init + self.linear_no_bias_s(self.layernorm_s(s)) |
| s, z = self.pairformer_stack( |
| s, |
| z, |
| pair_mask=None, |
| use_memory_efficient_kernel=self.configs.model.use_memory_efficient_kernel, |
| use_deepspeed_evo_attention=self.configs.model.use_deepspeed_evo_attention |
| and deepspeed_evo_attention_condition_satisfy, |
| use_lma=self.configs.model.use_lma, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
|
|
| return PairFormerOutput(s_inputs=s_inputs, s=s, z=z) |
|
|
| def main_inference_loop( |
| self, |
| pairformer_input: PairFormerInput, |
| diffusion_input: DiffusionInput, |
| permutation_input: PermutationInput, |
| ground_truth: GroundTruth, |
| N_cycle: int, |
| mode: str, |
| inplace_safe: bool = True, |
| chunk_size: Optional[int] = 4, |
| N_model_seed: int = 1, |
| symmetric_permutation: SymmetricPermutation = None, |
| ) -> tuple[ODesignOutput, dict[str, Any], dict[str, Any]]: |
| """ |
| Main inference loop with multiple model seeds for ensemble predictions. |
| |
| This method runs the inference loop multiple times with different model seeds |
| and aggregates the results. Each model seed produces independent predictions |
| that can be used for confidence estimation or ensemble averaging. |
| |
| Inference Pipeline: |
| 1. For each model seed: |
| a. Run pairformer to get representations (s, z) |
| b. Predict distogram and bond types from pairwise head |
| c. Sample coordinates from diffusion model |
| d. Apply symmetric permutation (if provided) |
| 2. Concatenate results from all model seeds |
| |
| Args: |
| pairformer_input: PairFormerInput object containing input features for pairformer |
| diffusion_input: DiffusionInput object containing features for diffusion module |
| permutation_input: PermutationInput object for handling molecular symmetries |
| ground_truth: GroundTruth object containing ground truth labels (optional for inference) |
| N_cycle: Number of refinement cycles in pairformer |
| mode: Mode of operation ('inference' or 'eval') |
| inplace_safe: Whether to use inplace operations for memory efficiency. |
| Defaults to True for inference. |
| chunk_size: Chunk size for memory-efficient attention computation. |
| Defaults to 4. |
| N_model_seed: Number of independent model seeds for ensemble predictions. |
| Defaults to 1. |
| symmetric_permutation: SymmetricPermutation object for handling molecular |
| symmetries in evaluation mode. Defaults to None. |
| |
| Returns: |
| ODesignOutput: Object containing: |
| - coordinate: Predicted 3D coordinates [N_model_seed, N_sample, N_atom, 3] |
| - token_bond_type_logits: Bond type logits [N_model_seed, N_token, N_token, N_bond_types] |
| - token_bond_gen_mask: Bond generation mask [N_model_seed, N_token, N_token] |
| - distogram: Distance distribution logits [N_model_seed, N_token, N_token, N_bins] |
| |
| Note: |
| - Multiple model seeds provide uncertainty estimates and ensemble predictions |
| - Memory is managed by clearing cache for large structures (N_token > 2000) |
| - Symmetric permutation is applied in eval mode to match ground truth symmetries |
| """ |
| model_outputs = [] |
| for _ in range(N_model_seed): |
| model_output = self._main_inference_loop( |
| pairformer_input=pairformer_input, |
| diffusion_input=diffusion_input, |
| permutation_input=permutation_input, |
| ground_truth=ground_truth, |
| N_cycle=N_cycle, |
| mode=mode, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| symmetric_permutation=symmetric_permutation, |
| ) |
| model_outputs.append(model_output) |
| |
| return ODesignOutput( |
| coordinate=cat_dict(model_outputs, "coordinate"), |
| token_bond_type_logits=cat_dict(model_outputs, "token_bond_type_logits"), |
| token_bond_gen_mask=cat_dict(model_outputs, "token_bond_gen_mask"), |
| ) |
|
|
| def _main_inference_loop( |
| self, |
| pairformer_input: PairFormerInput, |
| diffusion_input: DiffusionInput, |
| permutation_input: PermutationInput, |
| ground_truth: GroundTruth, |
| N_cycle: int, |
| mode: str, |
| inplace_safe: bool = True, |
| chunk_size: Optional[int] = 4, |
| symmetric_permutation: SymmetricPermutation = None, |
| ) -> tuple[dict[str, torch.Tensor], dict[str, Any], dict[str, Any]]: |
| """ |
| Single model seed inference loop for structure prediction. |
| |
| This internal method performs one complete inference pass: |
| 1. Pairformer Module: Generate single and pair representations |
| 2. Pairwise Head: Predict distogram and bond types |
| 3. Diffusion Module: Sample 3D coordinates through denoising |
| 4. Permutation (optional): Match predicted symmetries to ground truth |
| |
| Memory Optimization: |
| - Deletes MSA and template features after pairformer to save memory |
| - Clears CUDA cache for large structures (N_token > 2000) |
| - Uses inplace operations when safe |
| |
| Args: |
| pairformer_input: PairFormerInput object with input features |
| diffusion_input: DiffusionInput object for coordinate generation |
| permutation_input: PermutationInput object for symmetry handling |
| ground_truth: GroundTruth object with ground truth labels (optional) |
| N_cycle: Number of pairformer refinement cycles |
| mode: Operation mode ('inference' or 'eval') |
| inplace_safe: Whether to use inplace operations. Defaults to True. |
| chunk_size: Chunk size for memory-efficient operations. Defaults to 4. |
| symmetric_permutation: SymmetricPermutation object for matching |
| predicted symmetries to ground truth. Used in eval mode. Defaults to None. |
| |
| Returns: |
| ODesignOutput: Object containing model predictions: |
| - coordinate: Predicted 3D coordinates [N_sample, N_atom, 3] |
| - distogram: Distance distribution logits [N_token, N_token, N_bins] |
| - token_bond_type_logits: Bond type predictions [N_token, N_token, N_bond_types] |
| - token_bond_gen_mask: Valid bond mask [N_token, N_token] |
| |
| Note: |
| - This is called by main_inference_loop for each model seed |
| - AMP (Automatic Mixed Precision) is disabled for certain operations |
| - Symmetric permutation ensures predicted coordinates match ground truth symmetries |
| """ |
| N_token = pairformer_input.residue_index.shape[-1] |
|
|
| model_output = ODesignOutput() |
|
|
| pairformer_output = self.get_pairformer_output( |
| input_data=pairformer_input, |
| N_cycle=N_cycle, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
|
|
| pairwise_output: PairwiseOutput = autocasting_disable_decorator( |
| self.configs.model.skip_amp.sample_diffusion_training |
| )(self.pairwise_head)( |
| pairformer_output |
| ) |
| model_output.update( |
| { |
| "distogram": pairwise_output.distogram, |
| "token_bond_type_logits": pairwise_output.token_bond_type_logits, |
| "token_bond_gen_mask": pairformer_input.token_bond_gen_mask |
| } |
| ) |
|
|
| if mode == "inference": |
| keys_to_delete = [] |
| for key in pairformer_input.keys(): |
| if "template_" in key or key in [ |
| "msa", |
| "has_deletion", |
| "deletion_value", |
| "profile", |
| "deletion_mean", |
| "token_bonds", |
| ]: |
| keys_to_delete.append(key) |
|
|
| for key in keys_to_delete: |
| delattr(pairformer_input, key) |
| torch.cuda.empty_cache() |
|
|
| |
| |
| diffusion_output = autocasting_disable_decorator( |
| self.configs.model.skip_amp.sample_diffusion |
| )(sample_diffusion)( |
| denoise_net=self.diffusion_module, |
| input_data=diffusion_input, |
| input_embedding=pairformer_output, |
| ground_truth=ground_truth, |
| N_sample=self.configs.model.sample_diffusion.N_sample, |
| N_step=self.configs.model.sample_diffusion.N_step, |
| attn_chunk_size=self.configs.model.sample_diffusion.attn_chunk_size, |
| diffusion_chunk_size=self.configs.model.sample_diffusion.diffusion_chunk_size, |
| noise_schedulers=self.inference_noise_schedulers, |
| inplace_safe=inplace_safe, |
| ) |
|
|
| model_output.update( |
| { |
| "coordinate": diffusion_output.x_denoised, |
| } |
| ) |
|
|
| if mode == "inference" and N_token > 2000: |
| torch.cuda.empty_cache() |
|
|
| |
| if symmetric_permutation is not None: |
| model_output, _ = symmetric_permutation.permute_inference_output( |
| input_data=permutation_input, |
| model_output=model_output, |
| ground_truth=ground_truth, |
| ) |
|
|
| return model_output |
|
|
| def main_train_loop( |
| self, |
| pairformer_input: PairFormerInput, |
| diffusion_input: DiffusionInput, |
| permutation_input: PermutationInput, |
| ground_truth: GroundTruth, |
| N_cycle: int, |
| symmetric_permutation: SymmetricPermutation, |
| inplace_safe: bool = False, |
| chunk_size: Optional[int] = None, |
| ) -> tuple[ODesignOutput, GroundTruth, dict[str, Any]]: |
| """ |
| Main training loop with diffusion-based coordinate denoising. |
| |
| Training Pipeline: |
| 1. Pairformer Module: |
| - Generate single (s) and pair (z) representations |
| - Multi-cycle refinement with gradient only on last cycle |
| |
| 2. Pairwise Module: |
| - Predict distogram from pair representations |
| - Predict token bond types |
| |
| 3. Denoising Module: |
| - Add noise to ground truth coordinates |
| - Train diffusion model to denoise coordinates |
| - Support conditional dropout for robustness |
| |
| 4. Permutation Module: |
| - Permute predicted coordinates to match ground truth |
| - Handle symmetric atoms and chains |
| - Compute optimal permutation for loss calculation |
| |
| Key Training Features: |
| - Random conditioning dropout with configurable rate |
| - Symmetric permutation matching for proper loss computation |
| - Efficient gradient computation (only last cycle) |
| - Support for multiple diffusion samples per batch |
| |
| Args: |
| pairformer_input: PairFormerInput object containing input features |
| diffusion_input: DiffusionInput object for diffusion module |
| permutation_input: PermutationInput object for symmetry handling |
| ground_truth: GroundTruth object with ground truth coordinates and labels |
| N_cycle: Number of pairformer refinement cycles |
| symmetric_permutation: SymmetricPermutation object for handling molecular |
| symmetries. Required for training. |
| inplace_safe: Whether to use inplace operations. Should be False during |
| training to preserve computation graph. Defaults to False. |
| chunk_size: Chunk size for memory-efficient operations. Defaults to None |
| (no chunking during training). |
| |
| Returns: |
| tuple: Tuple containing three elements: |
| - model_output: ODesignOutput object with predictions: |
| - coordinate: Denoised coordinates [N_sample, N_atom, 3] |
| - noise_level: Noise levels used for training [N_sample] |
| - distogram: Predicted distance distributions [N_token, N_token, N_bins] |
| - token_bond_type_logits: Bond type predictions [N_token, N_token, N_bond_types] |
| - token_bond_gen_mask: Valid bond mask [N_token, N_token] |
| - ground_truth: GroundTruth object (may be permuted to match predictions) |
| - log_dict: Dictionary containing logging information: |
| - Permutation statistics |
| - Any other training metrics |
| |
| Note: |
| - Ground truth coordinates are used to generate noisy training samples |
| - Conditioning dropout helps model learn unconditional generation |
| - Symmetric permutation is crucial for correct loss computation |
| - AMP is disabled for diffusion module for numerical stability |
| """ |
|
|
| log_dict = {} |
| model_output = ODesignOutput() |
|
|
| |
| pairformer_output = self.get_pairformer_output( |
| input_data=pairformer_input, |
| N_cycle=N_cycle, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| |
|
|
| |
| pairwise_output: PairwiseOutput = autocasting_disable_decorator( |
| self.configs.model.skip_amp.sample_diffusion_training |
| )(self.pairwise_head)( |
| pairformer_output |
| ) |
| model_output.update( |
| { |
| "distogram": pairwise_output.distogram, |
| "token_bond_type_logits": pairwise_output.token_bond_type_logits, |
| "token_bond_gen_mask": pairformer_input.token_bond_gen_mask |
| } |
| ) |
| |
|
|
| |
| drop_conditioning = ( |
| random.random() < self.configs.model.condition_embedding_drop_rate |
| ) |
| diffusion_output = autocasting_disable_decorator( |
| self.configs.model.skip_amp.sample_diffusion_training |
| )(sample_diffusion_training)( |
| noise_schedulers=self.train_noise_schedulers, |
| denoise_net=self.diffusion_module, |
| input_data=diffusion_input, |
| input_embedding=pairformer_output, |
| ground_truth=ground_truth, |
| N_sample=self.diffusion_batch_size, |
| diffusion_chunk_size=self.configs.model.diffusion_chunk_size, |
| use_conditioning=not drop_conditioning, |
| ) |
| model_output.update( |
| { |
| "coordinate": diffusion_output.x_denoised, |
| "noise_level": diffusion_output.sigma, |
| } |
| ) |
| |
|
|
| |
| |
| model_output, perm_log_dict, _, _ = ( |
| symmetric_permutation.permute_diffusion_sample_to_match_label( |
| permutation_input, model_output, ground_truth, stage="train" |
| ) |
| ) |
| log_dict.update(perm_log_dict) |
| |
|
|
| return model_output.to_dict(), ground_truth, log_dict |
|
|
| @register_license('odesign2025') |
| def forward( |
| self, |
| feature_data: OFeatureData, |
| label_full_data: OLabelData, |
| label_data: OLabelData, |
| mode: str = "inference", |
| current_step: Optional[int] = None, |
| symmetric_permutation: SymmetricPermutation = None, |
| ) -> tuple[dict[str, torch.Tensor], dict[str, Any], dict[str, Any]]: |
| """ |
| Forward pass of the ODesign model supporting multiple operation modes. |
| |
| This is the main entry point for the model, handling three distinct modes: |
| |
| 1. Training Mode ('train'): |
| - Randomly selects number of cycles (1 to N_cycle) |
| - Computes gradients for backpropagation |
| - Uses ground truth coordinates for diffusion training |
| - Requires symmetric_permutation for loss computation |
| - Single model seed |
| |
| 2. Inference Mode ('inference'): |
| - Uses fixed N_cycle cycles |
| - Multiple model seeds for ensemble predictions |
| - Starts from random noise for coordinate generation |
| - No symmetric permutation needed |
| - Memory-optimized (deletes unused features, clears cache) |
| |
| 3. Evaluation Mode ('eval'): |
| - Uses fixed N_cycle cycles |
| - Multiple model seeds for ensemble predictions |
| - Applies symmetric permutation to match ground truth |
| - Uses full (uncropped) labels for evaluation |
| - Suitable for benchmarking and validation |
| |
| Mode-Specific Behavior: |
| - train: Requires labels, uses random cycles, single seed |
| - inference: No labels needed, fixed cycles, multiple seeds |
| - eval: Requires labels, fixed cycles, multiple seeds, with permutation |
| |
| Args: |
| feature_data: OFeatureData object containing input features: |
| - Sequence information (residue_index, token_index, etc.) |
| - Coordinates and masks (ref_pos, ref_mask, etc.) |
| - MSA features (msa, msa_mask, etc.) |
| - Template features (template_*, etc.) |
| - Bonding information (token_bonds, etc.) |
| label_full_data: OLabelData object with full (uncropped) labels: |
| - Full complex coordinates before cropping |
| - Used for multi-chain permutation in evaluation |
| label_data: OLabelData object with cropped labels: |
| - Ground truth coordinates [N_atom, 3] |
| - Ground truth masks and features |
| - Used for training and evaluation |
| mode: Operation mode, one of: |
| - 'train': Training with gradient computation |
| - 'inference': Inference without ground truth |
| - 'eval': Evaluation with ground truth matching |
| Defaults to 'inference'. |
| current_step: Current training step number. Used to randomly sample |
| N_cycle in training mode. Required for training. Defaults to None. |
| symmetric_permutation: SymmetricPermutation object for handling molecular |
| symmetries. Required for training and eval modes. Defaults to None. |
| |
| Returns: |
| tuple: Tuple containing three elements: |
| - model_output: ODesignOutput object with predictions: |
| - coordinate: 3D coordinates [N_model_seed, N_sample, N_atom, 3] |
| - distogram: Distance distributions [N_model_seed, N_token, N_token, N_bins] |
| - token_bond_type_logits: Bond predictions [N_model_seed, N_token, N_token, N_types] |
| - token_bond_gen_mask: Valid bonds [N_model_seed, N_token, N_token] |
| - noise_level: Noise levels (training only) [N_model_seed, N_sample] |
| - ground_truth: GroundTruth object (may be permuted in training) |
| - loss_input: LossInput object with features needed for loss computation |
| |
| Raises: |
| AssertionError: If mode-specific requirements are not met: |
| - Training mode requires self.training to be True |
| - Training mode requires label_data |
| - Training mode requires symmetric_permutation |
| |
| Note: |
| - Inplace operations are used in inference/eval for memory efficiency |
| - Chunking is enabled in inference/eval for large structures |
| - Memory is actively managed (cache clearing) for inference |
| - Random seed for cycle selection is based on current_step in training |
| """ |
| assert mode in ["train", "inference", "eval"] |
|
|
| inplace_safe = not (self.training or torch.is_grad_enabled()) |
| chunk_size = self.configs.model.chunk_size if inplace_safe else None |
|
|
| if mode == "train": |
| nc_rng = np.random.RandomState(current_step) |
| N_cycle = nc_rng.randint(1, self.N_cycle + 1) |
| if mode == 'train': |
| assert self.training |
| assert label_data is not None |
| assert symmetric_permutation is not None |
|
|
| def prepare_training_inputs(feature_data, label_data): |
| """ |
| Prepare input objects for training mode. |
| |
| Extracts and organizes features into specialized input objects for |
| different model components. |
| |
| Args: |
| feature_data: OFeatureData with all input features |
| label_data: OLabelData with ground truth labels |
| |
| Returns: |
| tuple: (pairformer_input, diffusion_input, permutation_input, |
| loss_input, ground_truth) |
| """ |
| pairformer_input = PairFormerInput.from_feature_data(feature_data) |
| diffusion_input = DiffusionInput.from_feature_data(feature_data) |
| permutation_input = PermutationInput.from_feature_data(feature_data) |
| loss_input = LossInput.from_feature_data(feature_data) |
| ground_truth = GroundTruth.from_label_data(label_data) |
| return pairformer_input, diffusion_input, permutation_input, loss_input, ground_truth |
|
|
| ( |
| pairformer_input, |
| diffusion_input, |
| permutation_input, |
| loss_input, |
| ground_truth |
| ) = prepare_training_inputs(feature_data, label_data) |
|
|
| model_output, ground_truth, _ = self.main_train_loop( |
| pairformer_input=pairformer_input, |
| diffusion_input=diffusion_input, |
| permutation_input=permutation_input, |
| ground_truth=ground_truth, |
| N_cycle=N_cycle, |
| symmetric_permutation=symmetric_permutation, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| ) |
| elif mode == "inference": |
| def prepare_inference_inputs(feature_data, label_data): |
| """ |
| Prepare input objects for inference mode. |
| |
| Similar to training preparation but sets permutation_input and loss_input |
| to None since they are not needed for pure inference. |
| |
| Args: |
| feature_data: OFeatureData with all input features |
| label_data: OLabelData with ground truth labels (may be None) |
| |
| Returns: |
| tuple: (pairformer_input, diffusion_input, None, None, ground_truth) |
| """ |
| pairformer_input = PairFormerInput.from_feature_data(feature_data) |
| diffusion_input = DiffusionInput.from_feature_data(feature_data) |
| permutation_input = None |
| loss_input = None |
| ground_truth = GroundTruth.from_label_data(label_data) |
| return pairformer_input, diffusion_input, permutation_input, loss_input, ground_truth |
|
|
| ( |
| pairformer_input, |
| diffusion_input, |
| permutation_input, |
| loss_input, |
| ground_truth |
| ) = prepare_inference_inputs(feature_data, label_data) |
|
|
| model_output = self.main_inference_loop( |
| pairformer_input=pairformer_input, |
| diffusion_input=diffusion_input, |
| permutation_input=permutation_input, |
| ground_truth=ground_truth, |
| N_cycle=self.N_cycle, |
| mode=mode, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| N_model_seed=self.N_model_seed, |
| symmetric_permutation=None, |
| ) |
| elif mode == "eval": |
| if label_data is not None: |
| assert ( |
| label_data["coordinate"].size() |
| == label_full_data["coordinate"].size() |
| ), print(f'{label_data["coordinate"].size()} != {label_full_data["coordinate"].size()}') |
| label_data.update(label_full_data) |
|
|
| def prepare_eval_inputs(feature_data, label_data): |
| """ |
| Prepare input objects for evaluation mode. |
| |
| Similar to training preparation. Includes permutation_input and loss_input |
| for symmetry-aware evaluation metrics. |
| |
| Args: |
| feature_data: OFeatureData with all input features |
| label_data: OLabelData with ground truth labels (merged with full labels) |
| |
| Returns: |
| tuple: (pairformer_input, diffusion_input, permutation_input, |
| loss_input, ground_truth) |
| """ |
| pairformer_input = PairFormerInput.from_feature_data(feature_data) |
| diffusion_input = DiffusionInput.from_feature_data(feature_data) |
| permutation_input = PermutationInput.from_feature_data(feature_data) |
| loss_input = LossInput.from_feature_data(feature_data) |
| ground_truth = GroundTruth.from_label_data(label_data) |
| return pairformer_input, diffusion_input, permutation_input, loss_input, ground_truth |
|
|
| ( |
| pairformer_input, |
| diffusion_input, |
| permutation_input, |
| loss_input, |
| ground_truth |
| ) = prepare_eval_inputs(feature_data, label_data) |
|
|
| model_output = self.main_inference_loop( |
| pairformer_input=pairformer_input, |
| diffusion_input=diffusion_input, |
| permutation_input=permutation_input, |
| ground_truth=ground_truth, |
| N_cycle=self.N_cycle, |
| mode=mode, |
| inplace_safe=inplace_safe, |
| chunk_size=chunk_size, |
| N_model_seed=self.N_model_seed, |
| symmetric_permutation=symmetric_permutation, |
| ) |
|
|
| return model_output, ground_truth, loss_input |
|
|
