Publish 11 evaluated Astra histories with reproducible checkpoint artifacts (part 50)

.gitattributes

@@ -1157,3 +1157,7 @@ tasks/mass-spectrometry-molecule-retrieval/mass-spectrometry-molecule-retrieval-
 tasks/natural-disease-progression/ndp-astra-xhigh-48h-20261020a/index.json filter=lfs diff=lfs merge=lfs -text
 tasks/natural-disease-progression/ndp-astra-xhigh-48h-20261020a/logs/sessions/2026/10/20/rollout-2026-10-20T08-00-22-01a15853-62be-7f40-8462-cc37f5a654b3.jsonl filter=lfs diff=lfs merge=lfs -text
 tasks/natural-disease-progression/ndp-astra-xhigh-48h-20261020a/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/sessions/2026/10/22/rollout-2026-10-22T03-00-28-01a1618d-8956-7b80-9cc4-d67245b7663a.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/logs/sessions/2026/10/22/rollout-2026-10-22T03-38-50-01a161b0-ac23-78b3-96d0-140821a2d85b.jsonl filter=lfs diff=lfs merge=lfs -text
+tasks/protein-sequence-modeling/protein-sequence-modeling-astra-xhigh-1h100-48h-20261022a/logs/trajectory.jsonl filter=lfs diff=lfs merge=lfs -text

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/training/checkpoint.py

@@ -0,0 +1,65 @@
+"""Utilities for gradient checkpointing.
+
+References:
+  * `PyTorch Checkpoint Documentation`_
+
+  .. _PyTorch Checkpoint Documentation: https://pytorch.org/docs/stable/checkpoint.html
+"""
+
+from typing import Any, Callable
+
+import torch
+from torch.utils.checkpoint import checkpoint
+
+
+def create_custom_forward(
+    module: Callable[..., Any], **kwargs: Any
+) -> Callable[..., Any]:
+    """Create a custom forward function for gradient checkpointing with fixed kwargs.
+
+    Enables passing keyword arguments to a module when using PyTorch's checkpoint function,
+    which only accepts positional arguments for the function to be checkpointed.
+
+    Args:
+      module: The callable (typically a nn.Module) to wrap.
+      **kwargs: Keyword arguments to pass to the module during forward.
+
+    Returns:
+      A callable that accepts only positional arguments and forwards them along
+      with the fixed kwargs to the original module.
+    """
+
+    def custom_forward(*inputs: Any) -> Any:
+        return module(*inputs, **kwargs)
+
+    return custom_forward
+
+
+def activation_checkpointing(function: Callable[..., Any]) -> Callable[..., Any]:
+    """Decorator to enable gradient checkpointing for a function during training.
+
+    Args:
+      function: The function to apply gradient checkpointing to.
+
+    Returns:
+      Wrapped function that conditionally applies checkpointing based on gradient state.
+
+    Examples:
+      Apply to a forward pass method::
+
+        @activation_checkpointing
+        def forward(self, x, mask=None):
+            return self.layer(x, mask)
+
+    Notes:
+      Uses ``use_reentrant=False`` for compatibility with recent PyTorch versions.
+    """
+
+    def wrapper(*args: Any, **kwargs: Any) -> Any:
+        if torch.is_grad_enabled():
+            return checkpoint(
+                create_custom_forward(function, **kwargs), *args, use_reentrant=False
+            )
+        return function(*args, **kwargs)
+
+    return wrapper

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/training/schedulers.py

@@ -0,0 +1,91 @@
+from dataclasses import dataclass
+
+from torch.optim.lr_scheduler import LRScheduler, _LRScheduler
+from torch.optim.optimizer import Optimizer
+
+
+class AF3Scheduler(_LRScheduler):
+    """Implements a two-phase learning rate schedule a-la AF-3:
+        1. The base learning rate is 1.8 · 10^−3, which is linearly increased from 0 over the first 1,000 steps.
+        2. The learning rate is then decreased by a factor of 0.95 every 50,000 steps.
+
+    From the AF-3 Supplement, Section 5.4:
+    >  "For training we use the Adam optimizer with parameters β1 = 0.9, β2 = 0.95, ϵ = 10^−8. The base learning rate
+        is 1.8 · 10^−3, which is linearly increased from 0 over the first 1,000 steps. The learning rate is then decreased
+        by a factor of 0.95 every 5 · 10^4 steps."
+
+    References:
+        - AF-3 Supplement
+    """
+
+    def __init__(
+        self,
+        optimizer: Optimizer,
+        base_lr: float = 1.8e-3,
+        warmup_steps: int = 1000,
+        decay_factor: float = 0.95,
+        decay_steps: int = 50000,
+        last_epoch: int = -1,
+    ) -> None:
+        """Initializes a new instance of AF3LRScheduler.
+
+        Note that the "last_epoch" value is incremented every time we call `scheduler.step()`
+        method; we name it "epoch" to follow the PyTorch convention.
+
+        Args:
+            optimizer (Optimizer): Wrapped optimizer.
+            base_lr (float): The base learning rate after warmup (which will then be decayed).
+            warmup_steps (int): Number of steps for linear warmup.
+            decay_factor (float): Factor by which the learning rate is multiplied every decay_steps.
+            decay_steps (int): Number of steps between each decay.
+            last_epoch (int): The index of the last epoch. Default: -1.
+        """
+        self.base_lr = base_lr
+        self.warmup_steps = warmup_steps
+        self.decay_factor = decay_factor
+        self.decay_steps = decay_steps
+        super(AF3Scheduler, self).__init__(optimizer, last_epoch)
+
+    def get_lr(self) -> list[float]:
+        if self.last_epoch < self.warmup_steps:
+            # Linear warmup
+            return [
+                self.base_lr * (self.last_epoch / self.warmup_steps)
+                for _ in self.optimizer.param_groups
+            ]
+        else:
+            # Decay after warmup
+            num_decays = (self.last_epoch - self.warmup_steps) // self.decay_steps
+            return [
+                self.base_lr * (self.decay_factor**num_decays)
+                for _ in self.optimizer.param_groups
+            ]
+
+
+@dataclass
+class SchedulerConfig:
+    """Flexible configuration for a learning rate scheduler.
+
+    Modeled on the PyTorch Lightning scheduler configuration.
+
+    Attributes:
+        scheduler (LRScheduler): The learning rate scheduler instance. Must inherit from `torch.optim.lr_scheduler.LRScheduler`.
+        interval (str): The interval at which to apply the scheduler, typically "epoch" or "step". Defaults to "step".
+        frequency (int): The frequency of applying the scheduler. For example, a frequency of 1 means the scheduler is applied every epoch. Defaults to 1.
+    """
+
+    scheduler: LRScheduler
+    interval: str = "step"
+    frequency: int = 1
+
+    def state_dict(self) -> dict:
+        return {
+            "scheduler": self.scheduler.state_dict(),
+            "interval": self.interval,
+            "frequency": self.frequency,
+        }
+
+    def load_state_dict(self, state_dict: dict) -> None:
+        self.scheduler.load_state_dict(state_dict["scheduler"])
+        self.interval = state_dict["interval"]
+        self.frequency = state_dict["frequency"]

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/alignment.py

@@ -0,0 +1,102 @@
+import logging
+
+import torch
+
+logger = logging.getLogger(__name__)
+
+
+def weighted_rigid_align(
+    X_L: torch.Tensor,  # [B, L, 3]
+    X_gt_L: torch.Tensor,  # [B, L, 3]
+    X_exists_L: torch.Tensor | None = None,  # [L]
+    w_L: torch.Tensor | None = None,  # [B, L]
+) -> torch.Tensor:
+    """
+    Weighted rigid body alignment of X_gt_L onto X_L with weights w_L
+    Allows for "moving target" ground truth that is se3 invariant
+    Following algorithm 28 in AF3 paper
+    Returns:
+      X_align_L: [B, L, 3]
+    """
+
+    # Canonicalize dimensions
+    if X_L.ndim == 2:
+        X_L = X_L[None]
+    if X_gt_L.ndim == 2:
+        X_gt_L = X_gt_L[None]
+    if X_exists_L is None:
+        X_exists_L = torch.ones((X_L.shape[-2]), dtype=torch.bool)
+    if w_L is None:
+        w_L = torch.ones_like(X_L[..., 0])
+    else:
+        if w_L.ndim == 1:
+            w_L = w_L[None]
+        w_L = w_L.to(torch.float32)
+
+    # Assert `X_exists_L` is a boolean mask
+    assert (
+        X_exists_L.dtype == torch.bool
+    ), "X_exists_L should be a boolean mask! Otherwise, the alignment will be incorrect (silent failure)!"
+
+    assert X_L.shape == X_gt_L.shape
+    assert X_L.shape[:-1] == w_L.shape
+
+    X_resolved = X_L[:, X_exists_L]
+    X_gt_resolved = X_gt_L[:, X_exists_L]
+    w_resolved = w_L[:, X_exists_L]
+    u_X = torch.sum(X_resolved * w_resolved.unsqueeze(-1), dim=-2) / torch.sum(
+        w_resolved, dim=-1, keepdim=True
+    )
+    u_X_gt = torch.sum(X_gt_resolved * w_resolved.unsqueeze(-1), dim=-2) / torch.sum(
+        w_resolved, dim=-1, keepdim=True
+    )
+
+    X_resolved = X_resolved - u_X.unsqueeze(-2)
+    X_gt_resolved = X_gt_resolved - u_X_gt.unsqueeze(-2)
+
+    # Computation of the covariance matrix
+    C = torch.einsum("bji,bjk->bik", w_resolved[..., None] * X_gt_resolved, X_resolved)
+
+    U, S, V = torch.linalg.svd(C)
+
+    R = U @ V
+    B, _, _ = X_L.shape
+    # F is the reflection correction for the Kabsch rotation: its last diagonal
+    # entry flips to -1 when det(R) < 0 so R stays a proper rotation. It feeds
+    # `U @ F @ V` below, where matmul requires a shared dtype — U and V carry
+    # X_L's dtype (SVD of an input-derived covariance), so F must too. torch.eye
+    # defaults to float32, so without dtype= float64 inputs raise a mismatch.
+    F = torch.eye(3, 3, device=X_L.device, dtype=X_L.dtype)[None].tile(
+        (
+            B,
+            1,
+            1,
+        )
+    )
+
+    det = torch.linalg.det(R)
+    F[..., -1, -1] = torch.sign(det)
+    R = U @ F @ V
+
+    X_gt_L = X_gt_L - u_X_gt.unsqueeze(-2)
+    X_align_L = X_gt_L @ R + u_X.unsqueeze(-2)
+
+    return X_align_L.detach()
+
+
+def get_rmsd(xyz1: torch.Tensor, xyz2: torch.Tensor, eps: float = 1e-4) -> torch.Tensor:
+    L = xyz1.shape[-2]
+    rmsd = torch.sqrt(torch.sum((xyz2 - xyz1) * (xyz2 - xyz1), dim=(-1, -2)) / L + eps)
+    return rmsd
+
+
+def superimpose(
+    xyz1: torch.Tensor, xyz2: torch.Tensor, mask: torch.Tensor, eps: float = 1e-4
+) -> None:
+    """
+    Superimpose xyz1 onto xyz2 using mask
+    """
+    L = xyz1.shape[-2]
+    assert mask.shape == (L,)
+    assert xyz1.shape == xyz2.shape
+    assert mask.dtype == torch.bool

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/components.py

@@ -0,0 +1,434 @@
+import random
+import re
+from typing import List
+
+import numpy as np
+from atomworks.ml.encoding_definitions import AF3SequenceEncoding
+from biotite.structure import AtomArray
+
+from foundry.constants import (
+    TIP_BY_RESTYPE,
+)
+from foundry.utils.ddp import RankedLogger
+
+global_logger = RankedLogger(__name__, rank_zero_only=False)
+sequence_encoding = AF3SequenceEncoding()
+_aa_like_res_names = sequence_encoding.all_res_names[sequence_encoding.is_aa_like]
+
+
+#################################################################################
+# Component / contig parsing
+#################################################################################
+
+
+class ComponentValidationError(ValueError):
+    """Raised when contig/component inputs cannot be parsed or validated."""
+
+    def __init__(
+        self,
+        message: str,
+        *,
+        component: str | None = None,
+        details: dict | None = None,
+    ):
+        self.component = component
+        self.details = details or {}
+        prefix = f"[component={component}] " if component else ""
+        suffix = f" Details: {self.details}" if self.details else ""
+        super().__init__(f"{prefix}{message}{suffix}")
+
+
+class ComponentStr(str):
+    """Component identifier, e.g. "A1" for residues, "B12", etc. Previously named `contig_string`"""
+
+    def split_component(v) -> list:
+        return split_contig(v)
+
+
+def split_contig(x: str) -> list:
+    try:
+        chain = str(x[0])
+        idx = int(x[1:])
+        if idx < 0:
+            raise ComponentValidationError(
+                "Residue index must be a non-negative integer.", component=str(x)
+            )
+    except Exception as e:
+        raise ComponentValidationError(
+            f"Invalid contig format: '{x}'. Expected format is 'ChainIDResID' (e.g. 'A20').",
+            component=str(x),
+        ) from e
+    return [chain, idx]
+
+
+def extract_pn_unit_info(contig: str) -> tuple[str, int, int]:
+    """
+    Convert substring like A20-21 or A20 to separate terms: A, 20, 21.
+    """
+    pattern = r"([A-Za-z])(\d+)(?:-(\d+))?"
+
+    match = re.match(pattern, contig)
+    if match:
+        pn_unit_id = match.group(1)
+        start = int(match.group(2))
+        end = int(match.group(3)) if match.group(3) else start
+        return pn_unit_id, start, end
+
+    raise ComponentValidationError(
+        "Invalid contig format. Expected 'ChainIDStart-Stop' or 'ChainIDIdx'.",
+        component=contig,
+    )
+
+
+def get_design_pattern_with_constraints(
+    contig: str, length: str | None = None
+) -> list[str]:
+    """
+    Convert the contig string to separate modules.
+    e.g. '1-5,A20-21,1-5,A25-25,1-5,A30-30,/0,1-5' with length = 10-10 may be converted to [2, A20, A21, 2, A25, 3, A30, /0, 3]
+    Integers represent number of free residues to put there.
+
+    """
+    contig_parts = contig.split(",")
+
+    # Separate fixed segments (e.g., "A1051-1051") and variable ranges (e.g., "0-40")
+    variable_ranges: list[list[int]] = []
+    fixed_parts: list[tuple[str, int, int]] = []
+    pos_to_put_motif = []
+
+    suff = []  # suffixes for diffused regions P(optional),R,D
+
+    for part in contig_parts:
+        ## updating to include DNA and RNA generation
+        if part[-1] in ["R", "D"]:  ##Detect non-fixed RNA and DNA contig part
+            suff.append(part[-1])
+            part = part[:-1]
+            if "-" in part:
+                start, end = map(int, part.split("-"))
+            else:
+                start = end = int(part)
+            variable_ranges.append([start, end])
+            pos_to_put_motif.append(0)
+
+        elif any(c.isalpha() for c in part):  # Detect parts containing letters as fixed
+            pn_unit_id, pn_unit_start, pn_unit_end = extract_pn_unit_info(part)
+            fixed_parts.append((pn_unit_id, pn_unit_start, pn_unit_end))
+            pos_to_put_motif.append(1)
+        elif part == "/0":
+            pos_to_put_motif.append(2)
+        else:
+            if "-" in part:
+                start, end = map(int, part.split("-"))
+            else:
+                start = end = int(part)
+            variable_ranges.append([start, end])
+            pos_to_put_motif.append(0)
+            suff.append("P")
+
+    # adjust the total length to solely for free residues
+    num_motif_residues = sum([i[2] - i[1] + 1 for i in fixed_parts])
+
+    if length is None:
+        length_min, length_max = 0, 9999
+    else:
+        if "-" in length:
+            length_min, length_max = map(int, length.split("-"))
+        else:
+            length_min = length_max = int(length)
+
+    length_min -= num_motif_residues
+    length_max -= num_motif_residues
+
+    remaining_length_min = length_min
+    remaining_length_max = length_max
+
+    num_free_atoms: list[int] = []
+    for range_limits in variable_ranges:
+        min_value = range_limits[0]
+        max_value = range_limits[1]
+
+        # Calculate the valid range for the current segment
+        valid_min = max(
+            min_value,
+            remaining_length_min
+            - sum(r[1] for r in variable_ranges[len(num_free_atoms) + 1 :]),
+        )
+        valid_max = min(
+            max_value,
+            remaining_length_max
+            - sum(r[0] for r in variable_ranges[len(num_free_atoms) + 1 :]),
+        )
+
+        if valid_min > valid_max and length is not None:
+            raise ComponentValidationError(
+                "No valid selections possible with the given constraints."
+            )
+
+        # Randomly select a value for the current segment
+        selected_value = random.randint(valid_min, valid_max)
+        num_free_atoms.append(selected_value)
+
+        # Update remaining lengths
+        remaining_length_min -= selected_value
+        remaining_length_max -= selected_value
+
+    atoms_with_motif = []
+    for idx in range(len(pos_to_put_motif)):
+        if pos_to_put_motif[idx] == 1:
+            motif = fixed_parts.pop(0)
+            pn_unit_id, pn_unit_start, pn_unit_end = motif[0], motif[1], motif[2]
+            for index in range(pn_unit_start, pn_unit_end + 1):
+                atoms_with_motif.append(f"{pn_unit_id}{index}")
+        elif pos_to_put_motif[idx] == 0:
+            free_atom = num_free_atoms.pop(0)
+            atoms_with_motif.append(str(free_atom) + suff.pop(0))
+        elif pos_to_put_motif[idx] == 2:
+            atoms_with_motif.append("/0")
+
+    return atoms_with_motif
+
+
+def get_motif_components_and_breaks(
+    unindexed_contig: str, index_all: bool = False
+) -> tuple[list[str], list[bool | None]]:
+    """
+    Convert a contig string into its components and breaks in motif
+    This way you can specify in your contigs where the breaks in the motif should be, so that,
+        say, residues aren't glued together by the model. Used for parsing unindexed inputs.
+
+    e.g.:
+        contig="A14,A15,A16" -> components=[A14, A15, A16] breaks=[True, True,  True]
+        contig="A14-15,A16"  -> components=[A14, A15, A16] breaks=[True, False, True]
+
+    args:
+        unindexed_contig: Contig string for unindexed tokens, see above for example on how positional
+            encodings between contigs can be selectively leaked
+        index_all: No breaks are used, allows for full indexing of concatenated tokens
+            Can use cleanup if this is the desired way to provide motif tokens.
+    """
+    components: list[str] = []
+    breaks: list[bool | None] = []
+
+    contig_parts = unindexed_contig.split(",")
+    for part in contig_parts:
+        if any(c.isalpha() for c in part):
+            # ... Parse possibilities: A11 | A11-12 | A11-11
+            pn_unit_id, pn_unit_start, pn_unit_end = extract_pn_unit_info(part)
+
+            if pn_unit_start == pn_unit_end:
+                # ... For single residues, append and break
+                components.append(f"{pn_unit_id}{pn_unit_start}")
+                breaks.append(True)
+            else:
+                # ... For multiple residues, break and then append without breaks
+                for index in range(pn_unit_start, pn_unit_end + 1):
+                    components.append(f"{pn_unit_id}{index}")
+                    if index == pn_unit_start:
+                        breaks.append(True)
+                    else:
+                        breaks.append(False)
+        elif part == "/0":
+            components.append(part)
+            breaks.append(None)
+        else:
+            if "-" in part:
+                raise ComponentValidationError(
+                    "Partial unindexing without fixed length is not supported.",
+                    component=part,
+                )
+            components.append(part)
+            breaks.append(None)
+
+    breaks[0] = True  # Decouple unindexed region from global index
+    if index_all:
+        global_logger.info("Unindexing all residues")
+        breaks = [(False if b is not None else None) for b in breaks]
+    return components, breaks
+
+
+#################################################################################
+# Mask getters
+#################################################################################
+
+
+def get_name_mask(
+    source_names: np.ndarray,
+    query_names: str | list[str],
+    source_resname: str | None = None,
+) -> np.ndarray:
+    """
+    Args:
+        source_names: list of all names to match in current token
+        query_string: specifier of names to get:
+            "ALL" - All atom names in token are matched
+            "BKBN - Only backbone atoms (not CB)
+            "TIP" - 2 farthest atoms from the backbone are fixed with any
+                additional atoms that automatically constrain geometries
+                (e.g. 4 atoms for carboxylates/amides). See `constants.py`.
+            Comma-separated string - e.g. "N,CA,C,O,CB" for exact queries
+            List of names - e.g. ["N", "CA", "C", "O"] for exact queries
+        source_resname: residue name is required when specifying just to grab the names for a "TIP"
+
+    Raises error if not all exact atom names are found and unique
+
+    Returns:
+        mask of atoms corresponding to token
+    """
+    if isinstance(query_names, list):
+        names = query_names
+    elif isinstance(query_names, str):
+        if query_names.upper() == "ALL":
+            return np.ones(source_names.shape[0], dtype=bool)
+        elif query_names.upper() == "BKBN":
+            names = ["N", "CA", "C", "O"]
+        elif query_names.upper() == "TIP":
+            if source_resname is None:
+                raise ComponentValidationError(
+                    "TIP selection requires a residue name.",
+                    component=str(source_resname),
+                )
+            tip_names = TIP_BY_RESTYPE[source_resname]
+            if tip_names is None:
+                raise ComponentValidationError(
+                    "Residue does not define TIP atoms; use ALL, BKBN, or explicit names.",
+                    component=str(source_resname),
+                )
+            names = tip_names
+        elif query_names == "":
+            names = []
+        else:
+            names = query_names.split(",")
+    else:
+        raise ComponentValidationError(
+            "query_names must be a string or list of strings.",
+            details={"got_type": str(type(query_names))},
+        )
+
+    if any(n == "" for n in names):
+        raise ComponentValidationError(
+            f"Empty atom name found in selection '{query_names}'.",
+            component=str(source_resname),
+        )
+    mask = np.isin(source_names, names)
+
+    if len(names) == 0:
+        return mask
+
+    if not len(set(names)) == len(names):
+        raise ComponentValidationError(
+            f"Atom names in '{query_names}' must be unique.",
+            details={"duplicates": names},
+        )
+    if not mask.any():
+        raise ComponentValidationError(
+            f"Could not find requested atoms '{query_names}' in atom array.",
+            details={"source_names": np.asarray(source_names).tolist()},
+        )
+    if mask.sum() != len(names):
+        global_logger.warning(
+            "Not all atoms found in atom array. Are you expecting multiple residues/ligands with the same names? "
+            + "If not, check your input pdb file. "
+            + "Atom array requested to contain names {}. Got: {}. Requested {}".format(
+                query_names,
+                np.asarray(source_names).tolist(),
+                np.asarray(names).tolist(),
+            )
+        )
+    if mask.sum() % len(names) != 0:
+        # for the case where source_names are originated from multiple residues with the same names
+        # (e.g. two ORO ligands in the input pdb: {ligand: "ORO", fixed_atoms: {ORO:"N3,C2,C4,N1"}})
+        raise ComponentValidationError(
+            "Number of atoms must be a multiple of the requested names.",
+            details={
+                "query": query_names,
+                "source_names": np.asarray(source_names).tolist(),
+                "requested": np.asarray(names).tolist(),
+            },
+        )
+
+    return mask
+
+
+def fetch_mask_from_idx(contig_str: str, *, atom_array: AtomArray) -> np.ndarray:
+    """
+    contig_str: A11
+    returns:
+        mask of atoms within contig (e.g. residue 11 in chain A)
+    """
+    chain, res_id = split_contig(contig_str)
+    mask = (atom_array.chain_id == chain) & (atom_array.res_id == res_id)
+    if not np.any(mask):
+        raise ComponentValidationError(
+            f"Residue {chain}{res_id} not found in atom array.",
+            component=f"{chain}{res_id}",
+        )
+    return mask
+
+
+def fetch_mask_from_name(name: str, *, atom_array: AtomArray) -> np.ndarray:
+    """
+    name: LIG_NAME
+    returns:
+        mask of atoms corresponding to non-protein
+    """
+    mask = atom_array.res_name == name
+    if not np.any(mask):
+        non_protein_res_names = np.unique(
+            atom_array.res_name[~np.isin(atom_array.res_name, _aa_like_res_names)]
+        )
+        raise ComponentValidationError(
+            "Component not found in input atom array.",
+            component=name,
+            details={"available_non_protein": non_protein_res_names.tolist()},
+        )
+    return mask
+
+
+def fetch_mask_from_component(component: str, *, atom_array: AtomArray) -> np.ndarray:
+    """
+    Catch-all function for fetching a component by non-protein name or contig
+    component: A11 or LIG_NAME
+    returns:
+        mask of atoms corresponding to component
+    """
+    try:
+        mask = fetch_mask_from_name(component, atom_array=atom_array)
+    except ComponentValidationError:
+        mask = fetch_mask_from_idx(component, atom_array=atom_array)
+    return mask
+
+
+def unravel_components(
+    v: str, *, atom_array: AtomArray = None, allow_multiple_matches: bool = False
+) -> List[str]:
+    """Safely unravel components from a string input."""
+    components = []
+    if "," in v or "-" in v:
+        components.extend(get_design_pattern_with_constraints(v))
+    else:
+        # Safely canonicalize to single component
+        mask = fetch_mask_from_component(v, atom_array=atom_array)
+        if mask.sum() > 0:
+            res_ids, chain_ids = atom_array.res_id[mask], atom_array.chain_id[mask]
+            # assert unique resids for component
+            if len(set(zip(chain_ids, res_ids))) != 1:
+                if not allow_multiple_matches:
+                    raise ComponentValidationError(
+                        f"Component '{v}' maps to multiple residues.",
+                        component=v,
+                    )
+                else:
+                    global_logger.warning(
+                        f"Component '{v}' maps to multiple residues. If you are using Symmetry this is OK."
+                    )
+                    components.extend([f"{c}{r}" for c, r in zip(chain_ids, res_ids)])
+                    components = list(set(components))  # unique components
+                    return components
+            res_id, chain_id = res_ids[0], chain_ids[0]
+
+            component = f"{chain_id}{res_id}"
+            global_logger.debug(
+                "Canonicalized component string: %s -> %s", v, component
+            )
+            components.append(component)
+    return components

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/datasets.py

@@ -0,0 +1,416 @@
+import hydra
+import torch
+from atomworks.ml.samplers import (
+    DistributedMixedSampler,
+    FallbackSamplerWrapper,
+    LazyWeightedRandomSampler,
+    LoadBalancedDistributedSampler,
+    MixedSampler,
+)
+from beartype.typing import Any
+from omegaconf import DictConfig, ListConfig
+from torch.utils.data import (
+    DataLoader,
+    Dataset,
+    RandomSampler,
+    Sampler,
+    SequentialSampler,
+    Subset,
+    WeightedRandomSampler,
+)
+from torch.utils.data.distributed import DistributedSampler
+
+from foundry.hydra.resolvers import register_resolvers
+from foundry.utils.ddp import RankedLogger
+
+ranked_logger = RankedLogger(__name__, rank_zero_only=True)
+try:
+    from atomworks.ml.datasets import (
+        ConcatDatasetWithID,
+        FallbackDatasetWrapper,
+        get_row_and_index_by_example_id,
+    )
+except Exception as e:
+    ranked_logger.warning(
+        f"Failed to import atomworks.ml.datasets: {type(e).__name__}: {e}. "
+        "If training networks, the PDB_MIRROR environment variable must be set."
+    )
+
+
+register_resolvers()
+
+
+def wrap_dataset_and_sampler_with_fallbacks(
+    dataset_to_be_wrapped: Dataset,
+    sampler_to_be_wrapped: Sampler,
+    dataset_to_fallback_to: Dataset,
+    sampler_to_fallback_to: Sampler,
+    n_fallback_retries: int,
+) -> tuple[Dataset, Sampler]:
+    """Wrap the specified dataset and sampler with fallback dataloading.
+
+    If the provided fallback sampler does not have weights (e.g., a MixedSampler), we will use uniform weights.
+
+    Args:
+        dataset_to_be_wrapped (Dataset): The main dataset to be wrapped.
+        sampler_to_be_wrapped (Sampler): The main sampler to be wrapped.
+        dataset_to_fallback_to (Dataset): The fallback dataset. We will sample from this dataset if the main dataset fails.
+        sampler_to_fallback_to (Sampler): The fallback sampler. We will sample from this sampler if the main sampler fails.
+        n_fallback_retries (int): Number of retries for the fallback mechanism before raising an exception.
+
+    Returns:
+        tuple[Dataset, Sampler]: The wrapped dataset and sampler with fallbacks.
+    """
+    # Instantiate a new fallback sampler to avoid scaling issues.
+    # `hasattr`, not `"weights" in sampler`: `in` on a Sampler has no `__contains__`, so it
+    # iterates the sampler's indices (ints) and never matches the string "weights" — the
+    # weighted branch was dead and the membership test needlessly drew samples.
+    if hasattr(sampler_to_fallback_to, "weights"):
+        fallback_weights = sampler_to_fallback_to.weights
+    else:
+        # torch types `Dataset` without `__len__`, but map-style datasets provide it.
+        fallback_weights = torch.ones(len(dataset_to_fallback_to))  # type: ignore[arg-type]
+    fallback_sampler = LazyWeightedRandomSampler(
+        weights=fallback_weights,
+        num_samples=int(1e9),
+        replacement=True,  # replacement for fallback dataloading, so we can draw a huge number of samples
+        generator=None,
+        prefetch_buffer_size=4,
+    )
+
+    # Wrap the dataset and sampler with fallback mechanisms
+    wrapped_dataset = FallbackDatasetWrapper(
+        dataset_to_be_wrapped, fallback_dataset=dataset_to_fallback_to
+    )
+    wrapped_sampler = FallbackSamplerWrapper(
+        sampler_to_be_wrapped,
+        fallback_sampler=fallback_sampler,
+        n_fallback_retries=n_fallback_retries,
+    )
+
+    return wrapped_dataset, wrapped_sampler
+
+
+def instantiate_single_dataset_and_sampler(cfg: DictConfig) -> dict[str, Any]:
+    """Instantiate a dataset and its corresponding sampler from a configuration dictionary.
+
+    Args:
+        cfg (DictConfig): Configuration dictionary defining the dataset and its parameters.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the instantiated dataset and sampler.
+    """
+    # ... instantiate the dataset
+    dataset = hydra.utils.instantiate(cfg.dataset)
+
+    # Users may provide only weights, in which case we will use a WeightedRandomSampler,
+    # or they may provide a sampler directly
+
+    if "weights" in cfg and "sampler" not in cfg:
+        # ... instantiate the weights and create a WeightedRandomSampler
+        weights = hydra.utils.instantiate(cfg.weights, dataset_df=dataset.data)
+        sampler = WeightedRandomSampler(
+            weights=weights,
+            num_samples=len(dataset),
+            replacement=True,
+        )
+    elif "sampler" in cfg and "weights" not in cfg:
+        # ... instantiate the sampler with the number of samples
+        sampler = hydra.utils.instantiate(cfg.sampler)
+    else:
+        dataset_name = getattr(getattr(cfg.dataset, "dataset", None), "name", None)
+        ranked_logger.warning(
+            f"No weights or sampler provided for dataset: {dataset_name}, using uniform weights with replacement."
+        )
+        sampler = WeightedRandomSampler(
+            # torch types `weights` as `Sequence[float]`; a Tensor is accepted at runtime.
+            weights=torch.ones(len(dataset)),  # type: ignore[arg-type]
+            num_samples=len(dataset),
+            replacement=True,
+        )
+
+    return {"dataset": dataset, "sampler": sampler}
+
+
+def recursively_instantiate_datasets_and_samplers(
+    cfg: DictConfig, name: str | None = None
+) -> dict[str, Any]:
+    """Recursively instantiate datasets and samplers from a configuration dictionary.
+
+    We must handle three cases:
+        (1) A single "leaf" dataset (e.g., "distillation"), specified with the "dataset" key
+        (2) Multiple sub-datasets that should be concatenated together with their weights (e.g., "interfaces" and "pn_units"),
+            specified with the "sub_datasets" key
+        (3) Multiple "leaf" datasets that should be sampled from with a certain probability (e.g., "distillation" and "pdb"),
+
+    Args:
+        cfg (DictConfig): Configuration dictionary defining datasets and their parameters.
+        name (str, optional): The name of the dataset, used for reporting. Defaults to None.
+
+    Returns:
+        dict[str, Any]: A dictionary containing the instantiated dataset and sampler.
+    """
+    # ------- Base case (1): A single "leaf" dataset -------#
+    if "dataset" in cfg:
+        return {**instantiate_single_dataset_and_sampler(cfg), "name": name}
+
+    # ------- Recursive case (2): Multiple sub-datasets that must be concatenated together -------#
+    elif "sub_datasets" in cfg:
+        # ... create a list of dictionaries for each sub-dataset
+        datasets_info = []
+        for sub_dataset_name, sub_dataset_cfg in cfg.sub_datasets.items():
+            if sub_dataset_cfg is None:
+                # (Skip any None sub-datasets; e.g., those overrode by the experiment config)
+                continue
+
+            datasets_info.append(
+                recursively_instantiate_datasets_and_samplers(
+                    sub_dataset_cfg, name=sub_dataset_name
+                )
+            )
+
+        # ... concatenate sub-datasets and weights (e.g., "interfaces" and "pn_units" into one ConcatDataset)
+        # NOTE: Order of the weights must match the order of the datasets!
+        concatenated_dataset = ConcatDatasetWithID(
+            datasets=[info["dataset"] for info in datasets_info]
+        )
+        concatenated_weights = torch.cat(
+            [info["sampler"].weights for info in datasets_info]
+        )
+        sampler = WeightedRandomSampler(
+            # torch types `weights` as `Sequence[float]`; a Tensor is accepted at runtime.
+            weights=concatenated_weights,  # type: ignore[arg-type]
+            num_samples=len(concatenated_dataset),
+            replacement=True,
+        )
+
+        return {"dataset": concatenated_dataset, "sampler": sampler, "name": name}
+
+    # ------- Recursive case (3): Multiple datasets that must be sampled from with specified probabilities -------#
+    else:
+        datasets_info = []
+        for nested_dataset_name, nested_dataset_cfg in cfg.items():
+            if nested_dataset_cfg is None:
+                # (Skip any None training datasets; e.g., those overrode by the experiment config)
+                continue
+
+            # (To use a MixedSampler, we must provide a "probability" key for each dataset)
+            assert (
+                "probability" in nested_dataset_cfg
+            ), "Expected 'probability' key in dataset configuration"
+            datasets_info.append(
+                {
+                    **recursively_instantiate_datasets_and_samplers(
+                        nested_dataset_cfg, name=str(nested_dataset_name)
+                    ),
+                    "probability": nested_dataset_cfg["probability"],
+                }
+            )
+
+        # ... check that the sum of probabilities of all datasets is 1
+        assert (
+            abs(1 - sum(dataset_info["probability"] for dataset_info in datasets_info))
+            < 1e-5
+        ), "Sum of probabilities must be 1.0"
+
+        # ... compose the list of datasets into a single dataset
+        composed_train_dataset = ConcatDatasetWithID(
+            datasets=[dataset["dataset"] for dataset in datasets_info]
+        )
+
+        composed_train_sampler = MixedSampler(datasets_info=datasets_info, shuffle=True)
+
+        return {
+            "dataset": composed_train_dataset,
+            "sampler": composed_train_sampler,
+            "name": name,
+        }
+
+
+def assemble_distributed_loader(
+    dataset: Dataset,
+    sampler: Sampler | None = None,
+    rank: int | None = None,
+    world_size: int | None = None,
+    n_examples_per_epoch: int | None = None,
+    loader_cfg: DictConfig | dict | None = None,
+    shuffle: bool = True,
+    drop_last: bool = False,
+) -> DataLoader:
+    """Assembles a distributed DataLoader for training or validation.
+
+    Performs the following steps:
+        (1) If not already a distributed sampler, wraps the sampler with a DistributedSampler or DistributedMixedSampler
+        (2) Wraps the dataset and sampler with a fallback mechanism, if needed
+        (3) Assembles the final DataLoader
+
+    Args:
+        dataset (Dataset): The dataset to be used for training or validation.
+        sampler (Sampler): The sampler to be used for training or validation. May already be distributed.
+        rank (int): The rank of the current process in distributed training.
+        world_size (int): The total number of processes participating in the distributed training.
+        n_examples_per_epoch (int): The number of examples to sample per epoch, across all GPUs.
+            For example, if we have 8 GPUs, with 2 gradient accumulation steps and 10 optimizer
+            steps per epoch, we would sample 160 examples per epoch (8 * 2 * 10).
+        loader_cfg (DictConfig or dict, optional): Additional configuration parameters for the
+            DataLoader, such as `batch_size` and `num_workers`. Defaults to an empty dictionary.
+        shuffle (bool, optional): Whether to shuffle the dataset. Defaults to True.
+        drop_last (bool, optional): Whether to drop the last incomplete batch if the dataset size
+            is not divisible by the number of GPUs. Defaults to False.
+
+    Returns:
+        DataLoader: A PyTorch DataLoader configured for distributed training, with datasets
+            concatenated and sampled according to their defined probabilities.
+    """
+    if not loader_cfg:
+        loader_cfg = {}
+
+    if isinstance(sampler, MixedSampler):
+        # (If given a MixedSampler, we must convert to a DistributedMixedSampler)
+        assert (
+            rank is not None
+            and world_size is not None
+            and n_examples_per_epoch is not None
+        ), "Rank, world_size, and n_examples_per_epoch must be provided for MixedSampler"
+        sampler = DistributedMixedSampler(
+            datasets_info=sampler.datasets_info,
+            num_replicas=world_size,
+            rank=rank,
+            n_examples_per_epoch=n_examples_per_epoch,
+            shuffle=shuffle,
+            drop_last=drop_last,
+        )
+    elif isinstance(sampler, (RandomSampler, SequentialSampler)):
+        # (If given a RandomSampler or SequentialSampler, we must convert to a DistributedSampler)
+        assert (
+            rank is not None and world_size is not None
+        ), "Rank and world_size must be provided for RandomSampler or SequentialSampler"
+        sampler = DistributedSampler(
+            dataset=dataset,
+            num_replicas=world_size,
+            rank=rank,
+            shuffle=shuffle,
+            drop_last=drop_last,
+        )
+    elif sampler is None and isinstance(dataset, Subset):
+        # We are subsetting the dataset to a specific set of example IDs
+        ranked_logger.info(f"Subsetting dataset to {len(dataset)} examples!")
+    else:
+        # (We assume we are already given a DistributedSampler or DistributedMixedSampler)
+        assert (
+            rank is None and world_size is None
+        ), "Rank and world_size will have no effect on the provided sampler and should be None"
+        assert isinstance(
+            sampler, (DistributedSampler, DistributedMixedSampler)
+        ), "Invalid sampler type for distributed training."
+
+    # ... wrap the composed dataset and sampler with a fallback mechanism, if needed
+    if (
+        "n_fallback_retries" in loader_cfg
+        and loader_cfg["n_fallback_retries"] > 0
+        and sampler is not None
+    ):
+        ranked_logger.info(
+            f"Wrapping train dataset and sampler with {loader_cfg['n_fallback_retries']} fallbacks..."
+        )
+        dataset, sampler = wrap_dataset_and_sampler_with_fallbacks(
+            dataset_to_be_wrapped=dataset,
+            sampler_to_be_wrapped=sampler,
+            dataset_to_fallback_to=dataset,
+            sampler_to_fallback_to=sampler,
+            n_fallback_retries=loader_cfg["n_fallback_retries"],
+        )
+
+    # ... assemble the final loader
+    loader = DataLoader(
+        dataset=dataset,
+        sampler=sampler,
+        collate_fn=lambda x: x,  # No collation
+        **loader_cfg["dataloader_params"] if "dataloader_params" in loader_cfg else {},
+    )
+
+    return loader
+
+
+def subset_dataset_to_example_ids(
+    dataset: Dataset,
+    example_ids: list[str] | ListConfig,
+) -> Dataset:
+    """Subset a dataset to a specific set of example IDs."""
+    indices = []
+    for example_id in example_ids:
+        # atomworks types the dataset arg as `ExampleIDMixin`; the datasets passed here mix it in.
+        index = get_row_and_index_by_example_id(dataset, example_id)["index"]  # type: ignore[arg-type]
+        indices.append(index)
+
+    return Subset(dataset, indices)
+
+
+def assemble_val_loader_dict(
+    cfg: DictConfig,
+    rank: int = 0,
+    world_size: int = 1,
+    loader_cfg: DictConfig | dict | None = None,
+) -> dict[str, DataLoader]:
+    """Assemble a dictionary of validation loaders for multiple datasets.
+
+    If a key is provided to balance the dataset, we will use a LoadBalancedDistributedSampler
+    rather than a DistributedSampler to maintain a balanced example load across processes
+    (i.e., avoid a situation where one GPU is allocated all small examples and another all large examples).
+
+    Args:
+        cfg (DictConfig): Configuration dictionary defining the validation datasets. Each key should correspond to a dataset name.
+        rank (int, optional): The rank of the current process in distributed training. Defaults to 0.
+        world_size (int, optional): The total number of processes participating in the distributed training. Defaults to 1.
+        loader_cfg (DictConfig, optional): Additional configuration parameters for the DataLoader, such as `batch_size` and `num_workers`. Defaults to None.
+    """
+    # ... loop through the validation datasets and create a DataLoader for each, preserving the dataset name
+    val_loaders = {}
+    for val_dataset_name, val_dataset in cfg.items():
+        if not val_dataset:
+            # (Skip any None validation datasets; e.g., those overrode by the experiment config)
+            continue
+        # DictConfig keys are typed as a broad union; coerce to the str they always are.
+        val_dataset_name = str(val_dataset_name)
+
+        assert (
+            "dataset" in val_dataset
+        ), f"Expected 'dataset' key in validation dataset config for {val_dataset_name}"
+        dataset = hydra.utils.instantiate(
+            val_dataset.dataset
+        )  # directly instantiate the dataset
+
+        if "key_to_balance" in val_dataset and val_dataset.key_to_balance:
+            # (If a key is provided to balance the dataset, we will use a LoadBalancedDistributedSampler)
+            key_to_balance = val_dataset.key_to_balance
+            ranked_logger.info(f"Balancing dataset with key: {key_to_balance}")
+
+            assert (
+                key_to_balance in dataset.data.columns
+            ), f"Key {key_to_balance} not found in dataset columns!"
+
+            sampler: Sampler = LoadBalancedDistributedSampler(
+                dataset=dataset,
+                num_replicas=world_size,
+                rank=rank,
+                key_to_balance=key_to_balance,
+            )
+        else:
+            # (Otherwise, we will use a DistributedSampler, without regard to sample size)
+            sampler = DistributedSampler(
+                dataset,
+                num_replicas=world_size,
+                rank=rank,
+                shuffle=False,
+                drop_last=False,
+            )
+
+        val_loader = assemble_distributed_loader(
+            dataset=dataset,
+            sampler=sampler,
+            loader_cfg=loader_cfg,
+        )
+
+        val_loaders[val_dataset_name] = val_loader
+
+    return val_loaders

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/ddp.py

@@ -0,0 +1,111 @@
+import logging
+
+import torch
+from beartype.typing import Any
+from lightning.fabric.utilities import rank_zero_only
+from lightning_utilities.core.rank_zero import rank_prefixed_message
+from omegaconf import DictConfig
+
+logger = logging.getLogger(__name__)
+
+
+def get_current_rank() -> int | None:
+    """Returns the rank of the current process, or None if it is not yet set."""
+    return getattr(rank_zero_only, "rank", None)
+
+
+def is_rank_zero() -> bool:
+    """Returns whether the current process is rank zero."""
+    return get_current_rank() == 0
+
+
+def set_accelerator_based_on_availability(cfg: DictConfig) -> DictConfig:
+    """Set training accelerator based on available hardware.
+
+    Args:
+        cfg: Hydra object with trainer settings "accelerator", "devices_per_node", and "num_nodes".
+
+    Returns:
+        The same `cfg` object, modified in place.
+    """
+    assert "trainer" in cfg, "Configuration object must have a 'trainer' key."
+    for key in ["accelerator", "devices_per_node", "num_nodes"]:
+        assert (
+            key in cfg.trainer
+        ), f"Configuration object must have a 'trainer.{key}' key."
+
+    if torch.cuda.is_available():
+        cfg.trainer.accelerator = "gpu"
+    elif hasattr(torch, "xpu") and torch.xpu.is_available():
+        logger.info("Intel XPU detected - using XPU accelerator")
+        cfg.trainer.accelerator = "xpu"
+    elif torch.backends.mps.is_available():
+        logger.info("Apple MPS detected - using MPS accelerator with float32 precision")
+        cfg.trainer.accelerator = "mps"
+        if hasattr(cfg.trainer, "precision"):
+            cfg.trainer.precision = "32-true"
+    else:
+        logger.error(
+            "No GPUs/XPUs/MPS available - Setting accelerator to 'cpu'. Are you sure you are using the correct configs?"
+        )
+        cfg.trainer.accelerator = "cpu"
+        cfg.trainer.devices_per_node = 1
+        cfg.trainer.num_nodes = 1
+
+    return cfg
+
+
+class RankedLogger(logging.LoggerAdapter):
+    """A multi-GPU-friendly python command line logger.
+
+    Modified from https://github.com/ashleve/lightning-hydra-template/blob/main/src/utils/pylogger.py
+    """
+
+    def __init__(
+        self,
+        name: str = __name__,
+        rank_zero_only: bool = False,
+        extra: Any | None = None,
+    ) -> None:
+        """Initializes a multi-GPU-friendly python command line logger that logs on all processes
+        with their rank prefixed in the log message.
+
+        :param name: The name of the logger. Default is ``__name__``.
+        :param rank_zero_only: Whether to force all logs to only occur on the rank zero process. Default is `False`.
+        :param extra: (Optional) A dict-like object which provides contextual information. See `logging.LoggerAdapter`.
+        """
+        logger = logging.getLogger(name)
+        super().__init__(logger=logger, extra=extra)
+        self.rank_zero_only = rank_zero_only
+
+    def log(  # type: ignore[override]  # deliberately extends LoggerAdapter.log with a `rank` parameter
+        self, level: int, msg: str, rank: int | None = None, *args: Any, **kwargs: Any
+    ) -> None:
+        """
+        Delegate a log call to the underlying logger, after prefixing its message with the rank
+        of the process it's being logged from. If `'rank'` is provided, then the log will only
+        occur on that rank/process.
+
+        Args:
+            level (int): The level to log at. Look at `logging.__init__.py` for more information.
+            msg (str): The message to log.
+            rank (Optional[int]): The rank to log at.
+            args: Additional args to pass to the underlying logging function.
+            kwargs: Any additional keyword args to pass to the underlying logging function.
+        """
+        if self.isEnabledFor(level):
+            msg, log_kwargs = self.process(msg, kwargs)
+            current_rank = getattr(rank_zero_only, "rank", None)
+            if current_rank is None:
+                raise RuntimeError(
+                    "The `rank_zero_only.rank` needs to be set before use"
+                )
+            msg = rank_prefixed_message(msg, current_rank)
+            if self.rank_zero_only:
+                if current_rank == 0:
+                    self.logger.log(level, msg, *args, **log_kwargs)
+            else:
+                if rank is None:
+                    self.logger.log(level, msg, *args, **log_kwargs)
+                elif current_rank == rank:
+                    self.logger.log(level, msg, *args, **log_kwargs)

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/instantiators.py

@@ -0,0 +1,72 @@
+import hydra
+from lightning.fabric.loggers import Logger
+from omegaconf import DictConfig
+
+from foundry.callbacks.callback import BaseCallback
+
+
+def _can_be_instantiated(cfg: DictConfig) -> bool:
+    """Checks if a config can be instantiated."""
+    return isinstance(cfg, DictConfig) and "_target_" in cfg
+
+
+class InstantiationError(ValueError):
+    """Raised when a config cannot be instantiated."""
+
+    pass
+
+
+def instantiate_callbacks(callbacks_cfg: DictConfig | None) -> list[BaseCallback]:
+    """Instantiates callbacks from config.
+
+    Args:
+        callbacks_cfg: A DictConfig object containing callback configurations.
+
+    Returns:
+        A list of instantiated callbacks.
+
+    Reference:
+        - Lightning Hydra Template (https://github.com/ashleve/lightning-hydra-template/blob/main/src/utils/instantiators.py#L36)
+    """
+    callbacks: list[BaseCallback] = []
+
+    if not callbacks_cfg:
+        return callbacks
+
+    for _, cb_conf in callbacks_cfg.items():
+        if _can_be_instantiated(cb_conf):
+            callbacks.append(hydra.utils.instantiate(cb_conf))
+        else:
+            raise InstantiationError(
+                f"Skipping callback <{cb_conf}> - Not a DictConfig with `_target_` key! Please provide a valid `_target_` for instantiation."
+            )
+
+    return callbacks
+
+
+def instantiate_loggers(logger_cfg: DictConfig | None) -> list[Logger]:
+    """Instantiates loggers from config.
+
+    Args:
+        logger_cfg: A DictConfig object containing logger configurations.
+
+    Return:
+        A list of instantiated loggers.
+
+    Reference:
+        - Lightning Hydra Template (https://github.com/ashleve/lightning-hydra-template/blob/main/src/utils/instantiators.py#L36)
+    """
+    loggers: list[Logger] = []
+
+    if not logger_cfg:
+        return loggers
+
+    for _, lg_conf in logger_cfg.items():
+        if _can_be_instantiated(lg_conf):
+            loggers.append(hydra.utils.instantiate(lg_conf))
+        else:
+            raise InstantiationError(
+                f"Skipping logger <{lg_conf}> - Not a DictConfig with `_target_` key! Please provide a valid `_target_` for instantiation."
+            )
+
+    return loggers

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/logging.py

@@ -0,0 +1,281 @@
+import logging
+import warnings
+from contextlib import contextmanager
+
+import pandas as pd
+from beartype.typing import Any, Iterator
+from lightning.fabric.utilities import rank_zero_only
+from omegaconf import DictConfig, OmegaConf
+from rich.console import Console
+from rich.syntax import Syntax
+from rich.table import Table
+from rich.tree import Tree
+from torch import nn
+
+from foundry.utils.ddp import RankedLogger
+
+ranked_logger = RankedLogger(__name__, rank_zero_only=True)
+
+
+class CachedDataFilter(logging.Filter):
+    """Filter to suppress atomworks cached data logging messages."""
+
+    def filter(self, record: logging.LogRecord) -> bool:
+        # Filter out "Cached data not found" messages
+        if "Cached data not found" in record.getMessage():
+            return False
+        return True
+
+
+def silence_warnings() -> None:
+    """Silence common warnings that appear during foundry execution."""
+    warnings.filterwarnings(
+        "ignore", message="All-NaN slice encountered", category=RuntimeWarning
+    )
+
+    warnings.filterwarnings(
+        "ignore",
+        message="Category 'chem_comp_bond' not found. No bonds will be parsed",
+        category=UserWarning,
+        module="biotite.structure.io.pdbx.convert",
+    )
+
+    warnings.filterwarnings(
+        "ignore",
+        message="torch.get_autocast_gpu_dtype\\(\\) is deprecated.*",
+        category=DeprecationWarning,
+        module="cuequivariance_ops_torch.triangle_attention",
+    )
+
+    warnings.filterwarnings(
+        "ignore",
+        message=".*multi-threaded.*fork.*may lead to deadlocks.*",
+        category=DeprecationWarning,
+    )
+
+    warnings.filterwarnings(
+        "ignore",
+        message=".*is_pyramidine.*deprecated.*Use.*is_pyrimidine.*",
+        category=DeprecationWarning,
+    )
+
+    warnings.filterwarnings(
+        "ignore",
+        message=".*index_reduce.*is in beta.*API may change.*",
+        category=UserWarning,
+    )
+
+
+@contextmanager
+def suppress_warnings(is_inference: bool = False) -> Iterator[None]:
+    """Context manager to suppress specific warnings within its scope.
+
+    Args:
+        is_inference: If True, also suppress inference-specific logging messages
+                     (e.g., atomworks cached data warnings).
+
+    Required to suppress warnings within multiprocessing contexts; e.g., `torch.multiprocessing.spawn`.
+    """
+    cached_data_filter = None
+
+    try:
+        with warnings.catch_warnings():
+            silence_warnings()
+            if is_inference:
+                # Add filter to suppress cached data messages
+                cached_data_filter = CachedDataFilter()
+                atomworks_ml_logger = logging.getLogger("atomworks.ml")
+                atomworks_ml_logger.addFilter(cached_data_filter)
+
+            yield
+    finally:
+        # Remove the filter
+        if cached_data_filter is not None:
+            atomworks_ml_logger = logging.getLogger("atomworks.ml")
+            atomworks_ml_logger.removeFilter(cached_data_filter)
+
+
+def configure_minimal_inference_logging() -> None:
+    """Configure minimal logging for inference (quiet mode)."""
+    # Suppress most logging by default
+    logging.getLogger().setLevel(logging.WARNING)
+
+    # Suppress specific noisy loggers
+    for logger_name in [
+        "atomworks",
+        "transforms",
+        "foundry.metrics",
+        "foundry.trainers",
+        "foundry.inference_engines.base",
+        "rf3.trainers",
+        "rf3.utils.inference",
+        "lightning",
+        "lightning_fabric",
+        "root",
+    ]:
+        logging.getLogger(logger_name).setLevel(logging.ERROR)
+
+    # Keep model-specific inference engine loggers at INFO for progress messages
+    logging.getLogger("rf3.inference_engines").setLevel(logging.INFO)
+    logging.getLogger("rfd3.engine").setLevel(logging.INFO)
+
+    # Suppress warnings
+    warnings.filterwarnings("ignore")
+
+
+@rank_zero_only
+def print_config_tree(
+    cfg: DictConfig,
+    resolve: bool = False,
+    console_width: int = 100,
+    title: str = "CONFIG",
+) -> None:
+    """Prints the contents of a DictConfig as a tree structure using the Rich library.
+
+    Args:
+        cfg (DictConfig): A DictConfig composed by Hydra.
+        resolve (bool): Whether to resolve reference fields of DictConfig. Default is False.
+        console_width (int): The width of the console for printing. Default is 100.
+    """
+    console = Console(width=console_width)
+    style = "dim"
+    tree = Tree(title, style=style, guide_style=style)
+
+    # Generate config tree in natural order
+    for field in cfg:
+        branch = tree.add(str(field), style=style, guide_style=style)
+
+        config_group = cfg[field]
+        if isinstance(config_group, DictConfig):
+            branch_content = OmegaConf.to_yaml(config_group, resolve=resolve)
+        else:
+            branch_content = str(config_group)
+
+        branch.add(Syntax(branch_content, "yaml", word_wrap=True))
+
+    # Print config tree using Rich's Console
+    # (This call happens before instantiating other loggers, so we don't try to capture the output)
+    console.print(tree)
+
+
+@rank_zero_only
+def print_model_parameters(model: nn.Module, name: str = "") -> None:
+    """Prints the total and trainable parameters of a PyTorch model.
+
+    Args:
+        model (nn.Module): The PyTorch model to analyze.
+    """
+    total_params = sum(p.numel() for p in model.parameters())
+    trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
+    data = {
+        "Type": ["Total Parameters", "Trainable Parameters"],
+        "Count": [total_params, trainable_params],
+    }
+
+    title = f"Model Parameters: {name}" if name else "Model Parameters"
+    print_df_as_table(pd.DataFrame(data), title=title)
+
+
+def log_hyperparameters_with_all_loggers(
+    trainer: Any, cfg: dict | DictConfig, model: Any
+) -> None:
+    """Logs hyperparameters using all loggers in the trainer.
+
+    Args:
+        trainer: The training object containing loggers.
+        cfg: Configuration dictionary containing hyperparameters.
+        model: The model to be tracked by loggers like WandbLogger.
+    """
+    # If given a DictConfig, convert it to a dictionary
+    if isinstance(cfg, DictConfig):
+        hparams = OmegaConf.to_container(cfg, resolve=True)
+    else:
+        hparams = cfg
+
+    for logger in trainer.fabric.loggers:
+        # ...log hyperparameters to each Fabric logger
+        # For Abstract Base Class of Fabric `Loggers`, see: https://lightning.ai/docs/fabric/stable/_modules/lightning/fabric/loggers/logger.html#Logger
+        assert hasattr(
+            logger, "log_hyperparams"
+        ), f"Logger {logger} does not have a `log_hyperparams` method. Ensure that the logger is a subclass of Fabric's ABC `Logger`."
+        try:
+            logger.log_hyperparams(hparams)
+        except NotImplementedError:
+            pass
+
+
+def condense_count_columns_of_grouped_df(df: pd.DataFrame) -> pd.DataFrame:
+    """Returns modified DF with single Count column if valid, otherwise original DF.
+
+    Helpful to avoid repeating count columns in a DataFrame with multi-level columns.
+    """
+    if not isinstance(df.columns, pd.MultiIndex):
+        return df
+
+    try:
+        # Validate count structure
+        count_cols = df.xs("count", level=1, axis=1)
+        mean_cols = df.xs("mean", level=1, axis=1)
+
+        # Check count consistency per row and column existence
+        if not (count_cols.nunique(axis=1) == 1).all():
+            return df
+
+        # Build condensed dataframe
+        condensed_df = mean_cols.rename(columns=lambda c: f"{c} (mean)")
+        condensed_df["Count"] = count_cols.iloc[:, 0].astype(int)
+        return condensed_df
+
+    except (KeyError, IndexError):
+        return df
+
+
+def table_from_df(df: pd.DataFrame, title: str) -> Table:
+    """Create a Rich Table from a DataFrame."""
+    table = Table(title=title, show_header=True, header_style="bold cyan")
+
+    # Add columns to the table
+    for col in df.columns:
+        table.add_column(col, justify="right", style="magenta", overflow="fold")
+
+    # Iterate through DataFrame rows and add them to the table
+    for _, row in df.iterrows():
+        row_cells = []
+
+        for col in df.columns:
+            cell_value = row[col]
+
+            # Determine formatting based on data type
+            if pd.api.types.is_integer_dtype(df[col]):
+                formatted_value = f"{int(cell_value):,}"
+            elif pd.api.types.is_float_dtype(df[col]):
+                formatted_value = f"{float(cell_value):,.4f}"
+            else:
+                formatted_value = str(cell_value)
+
+            row_cells.append(formatted_value)
+
+        table.add_row(*row_cells)
+
+    return table
+
+
+def safe_print(obj: Any, console_width: int = 100, logger: Any | None = None) -> None:
+    """Print a Rich object in a console- and logger-safe manner."""
+    console = Console(force_terminal=False, color_system=None, width=console_width)
+
+    # Capture the table as a string and log it
+    with console.capture() as capture:
+        console.print(obj)
+
+    if logger:
+        # Use the provided logger
+        logger.info(f"\n{capture.get()}")
+    else:
+        # Use the default ranked logger
+        ranked_logger.info(f"\n{capture.get()}")
+
+
+def print_df_as_table(df: pd.DataFrame, title: str, console_width: int = 100) -> None:
+    """Pretty-print a DataFrame using Rich Table"""
+    safe_print(table_from_df(df=df, title=title), console_width=console_width)

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/rigid.py

@@ -0,0 +1,1466 @@
+# Copyright 2021 AlQuraishi Laboratory
+# Copyright 2021 DeepMind Technologies Limited
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+from typing import Any, Callable, Optional, Tuple, cast
+
+import numpy as np
+import torch
+
+
+def rot_matmul(a: torch.Tensor, b: torch.Tensor) -> torch.Tensor:
+    """
+    Performs matrix multiplication of two rotation matrix tensors. Written
+    out by hand to avoid AMP downcasting.
+
+    Args:
+        a: [*, 3, 3] left multiplicand
+        b: [*, 3, 3] right multiplicand
+    Returns:
+        The product ab
+    """
+    row_1 = torch.stack(
+        [
+            a[..., 0, 0] * b[..., 0, 0]
+            + a[..., 0, 1] * b[..., 1, 0]
+            + a[..., 0, 2] * b[..., 2, 0],
+            a[..., 0, 0] * b[..., 0, 1]
+            + a[..., 0, 1] * b[..., 1, 1]
+            + a[..., 0, 2] * b[..., 2, 1],
+            a[..., 0, 0] * b[..., 0, 2]
+            + a[..., 0, 1] * b[..., 1, 2]
+            + a[..., 0, 2] * b[..., 2, 2],
+        ],
+        dim=-1,
+    )
+    row_2 = torch.stack(
+        [
+            a[..., 1, 0] * b[..., 0, 0]
+            + a[..., 1, 1] * b[..., 1, 0]
+            + a[..., 1, 2] * b[..., 2, 0],
+            a[..., 1, 0] * b[..., 0, 1]
+            + a[..., 1, 1] * b[..., 1, 1]
+            + a[..., 1, 2] * b[..., 2, 1],
+            a[..., 1, 0] * b[..., 0, 2]
+            + a[..., 1, 1] * b[..., 1, 2]
+            + a[..., 1, 2] * b[..., 2, 2],
+        ],
+        dim=-1,
+    )
+    row_3 = torch.stack(
+        [
+            a[..., 2, 0] * b[..., 0, 0]
+            + a[..., 2, 1] * b[..., 1, 0]
+            + a[..., 2, 2] * b[..., 2, 0],
+            a[..., 2, 0] * b[..., 0, 1]
+            + a[..., 2, 1] * b[..., 1, 1]
+            + a[..., 2, 2] * b[..., 2, 1],
+            a[..., 2, 0] * b[..., 0, 2]
+            + a[..., 2, 1] * b[..., 1, 2]
+            + a[..., 2, 2] * b[..., 2, 2],
+        ],
+        dim=-1,
+    )
+
+    return torch.stack([row_1, row_2, row_3], dim=-2)
+
+
+def rot_vec_mul(r: torch.Tensor, t: torch.Tensor) -> torch.Tensor:
+    """
+    Applies a rotation to a vector. Written out by hand to avoid transfer
+    to avoid AMP downcasting.
+
+    Args:
+        r: [*, 3, 3] rotation matrices
+        t: [*, 3] coordinate tensors
+    Returns:
+        [*, 3] rotated coordinates
+    """
+    x = t[..., 0]
+    y = t[..., 1]
+    z = t[..., 2]
+    return torch.stack(
+        [
+            r[..., 0, 0] * x + r[..., 0, 1] * y + r[..., 0, 2] * z,
+            r[..., 1, 0] * x + r[..., 1, 1] * y + r[..., 1, 2] * z,
+            r[..., 2, 0] * x + r[..., 2, 1] * y + r[..., 2, 2] * z,
+        ],
+        dim=-1,
+    )
+
+
+def identity_rot_mats(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    rots = torch.eye(3, dtype=dtype, device=device, requires_grad=requires_grad)
+    rots = rots.view(*((1,) * len(batch_dims)), 3, 3)
+    rots = rots.expand(*batch_dims, -1, -1)
+
+    return rots
+
+
+def identity_trans(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    trans = torch.zeros(
+        (*batch_dims, 3), dtype=dtype, device=device, requires_grad=requires_grad
+    )
+    return trans
+
+
+def identity_quats(
+    batch_dims: Tuple[int, ...],
+    dtype: Optional[torch.dtype] = None,
+    device: Optional[torch.device] = None,
+    requires_grad: bool = True,
+) -> torch.Tensor:
+    quat = torch.zeros(
+        (*batch_dims, 4), dtype=dtype, device=device, requires_grad=requires_grad
+    )
+
+    with torch.no_grad():
+        quat[..., 0] = 1
+
+    return quat
+
+
+_quat_elements = ["a", "b", "c", "d"]
+_qtr_keys = [l1 + l2 for l1 in _quat_elements for l2 in _quat_elements]
+_qtr_ind_dict = {key: ind for ind, key in enumerate(_qtr_keys)}
+
+
+def _to_mat(pairs: list[tuple[str, int]]) -> np.ndarray:
+    mat = np.zeros((4, 4))
+    for pair in pairs:
+        key, value = pair
+        ind = _qtr_ind_dict[key]
+        mat[ind // 4][ind % 4] = value
+
+    return mat
+
+
+_QTR_MAT = np.zeros((4, 4, 3, 3))
+_QTR_MAT[..., 0, 0] = _to_mat([("aa", 1), ("bb", 1), ("cc", -1), ("dd", -1)])
+_QTR_MAT[..., 0, 1] = _to_mat([("bc", 2), ("ad", -2)])
+_QTR_MAT[..., 0, 2] = _to_mat([("bd", 2), ("ac", 2)])
+_QTR_MAT[..., 1, 0] = _to_mat([("bc", 2), ("ad", 2)])
+_QTR_MAT[..., 1, 1] = _to_mat([("aa", 1), ("bb", -1), ("cc", 1), ("dd", -1)])
+_QTR_MAT[..., 1, 2] = _to_mat([("cd", 2), ("ab", -2)])
+_QTR_MAT[..., 2, 0] = _to_mat([("bd", 2), ("ac", -2)])
+_QTR_MAT[..., 2, 1] = _to_mat([("cd", 2), ("ab", 2)])
+_QTR_MAT[..., 2, 2] = _to_mat([("aa", 1), ("bb", -1), ("cc", -1), ("dd", 1)])
+
+
+def quat_to_rot(quat: torch.Tensor) -> torch.Tensor:
+    """
+    Converts a quaternion to a rotation matrix.
+
+    Args:
+        quat: [*, 4] quaternions
+    Returns:
+        [*, 3, 3] rotation matrices
+    """
+    # [*, 4, 4]
+    quat = quat[..., None] * quat[..., None, :]
+
+    # [4, 4, 3, 3]
+    mat = quat.new_tensor(_QTR_MAT, requires_grad=False)
+
+    # [*, 4, 4, 3, 3]
+    shaped_qtr_mat = mat.view((1,) * len(quat.shape[:-2]) + mat.shape)
+    quat = quat[..., None, None] * shaped_qtr_mat
+
+    # [*, 3, 3]
+    return torch.sum(quat, dim=(-3, -4))
+
+
+def rot_to_quat(
+    rot: torch.Tensor,
+) -> torch.Tensor:
+    if rot.shape[-2:] != (3, 3):
+        raise ValueError("Input rotation is incorrectly shaped")
+
+    rot_elements = [[rot[..., i, j] for j in range(3)] for i in range(3)]
+    [[xx, xy, xz], [yx, yy, yz], [zx, zy, zz]] = rot_elements
+
+    k = [
+        [
+            xx + yy + zz,
+            zy - yz,
+            xz - zx,
+            yx - xy,
+        ],
+        [
+            zy - yz,
+            xx - yy - zz,
+            xy + yx,
+            xz + zx,
+        ],
+        [
+            xz - zx,
+            xy + yx,
+            yy - xx - zz,
+            yz + zy,
+        ],
+        [
+            yx - xy,
+            xz + zx,
+            yz + zy,
+            zz - xx - yy,
+        ],
+    ]
+
+    k_matrix = (1.0 / 3.0) * torch.stack([torch.stack(t, dim=-1) for t in k], dim=-2)
+
+    _, vectors = torch.linalg.eigh(k_matrix)
+    return vectors[..., -1]
+
+
+_QUAT_MULTIPLY = np.zeros((4, 4, 4))
+_QUAT_MULTIPLY[:, :, 0] = [[1, 0, 0, 0], [0, -1, 0, 0], [0, 0, -1, 0], [0, 0, 0, -1]]
+
+_QUAT_MULTIPLY[:, :, 1] = [[0, 1, 0, 0], [1, 0, 0, 0], [0, 0, 0, 1], [0, 0, -1, 0]]
+
+_QUAT_MULTIPLY[:, :, 2] = [[0, 0, 1, 0], [0, 0, 0, -1], [1, 0, 0, 0], [0, 1, 0, 0]]
+
+_QUAT_MULTIPLY[:, :, 3] = [[0, 0, 0, 1], [0, 0, 1, 0], [0, -1, 0, 0], [1, 0, 0, 0]]
+
+_QUAT_MULTIPLY_BY_VEC = _QUAT_MULTIPLY[:, 1:, :]
+
+
+def quat_multiply(quat1: torch.Tensor, quat2: torch.Tensor) -> torch.Tensor:
+    """Multiply a quaternion by another quaternion."""
+    mat = quat1.new_tensor(_QUAT_MULTIPLY)
+    reshaped_mat = mat.view((1,) * len(quat1.shape[:-1]) + mat.shape)
+    return torch.sum(
+        reshaped_mat * quat1[..., :, None, None] * quat2[..., None, :, None],
+        dim=(-3, -2),
+    )
+
+
+def quat_multiply_by_vec(quat: torch.Tensor, vec: torch.Tensor) -> torch.Tensor:
+    """Multiply a quaternion by a pure-vector quaternion."""
+    mat = quat.new_tensor(_QUAT_MULTIPLY_BY_VEC)
+    reshaped_mat = mat.view((1,) * len(quat.shape[:-1]) + mat.shape)
+    return torch.sum(
+        reshaped_mat * quat[..., :, None, None] * vec[..., None, :, None], dim=(-3, -2)
+    )
+
+
+def invert_rot_mat(rot_mat: torch.Tensor) -> torch.Tensor:
+    return rot_mat.transpose(-1, -2)
+
+
+def invert_quat(quat: torch.Tensor) -> torch.Tensor:
+    quat_prime = quat.clone()
+    quat_prime[..., 1:] *= -1
+    inv = quat_prime / torch.sum(quat**2, dim=-1, keepdim=True)
+    return inv
+
+
+class Rotation:
+    """
+    A 3D rotation. Depending on how the object is initialized, the
+    rotation is represented by either a rotation matrix or a
+    quaternion, though both formats are made available by helper functions.
+    To simplify gradient computation, the underlying format of the
+    rotation cannot be changed in-place. Like Rigid, the class is designed
+    to mimic the behavior of a torch Tensor, almost as if each Rotation
+    object were a tensor of rotations, in one format or another.
+    """
+
+    def __init__(
+        self,
+        rot_mats: Optional[torch.Tensor] = None,
+        quats: Optional[torch.Tensor] = None,
+        normalize_quats: bool = True,
+    ):
+        """
+        Args:
+            rot_mats:
+                A [*, 3, 3] rotation matrix tensor. Mutually exclusive with
+                quats
+            quats:
+                A [*, 4] quaternion. Mutually exclusive with rot_mats. If
+                normalize_quats is not True, must be a unit quaternion
+            normalize_quats:
+                If quats is specified, whether to normalize quats
+        """
+        if (rot_mats is None and quats is None) or (
+            rot_mats is not None and quats is not None
+        ):
+            raise ValueError("Exactly one input argument must be specified")
+
+        if (rot_mats is not None and rot_mats.shape[-2:] != (3, 3)) or (
+            quats is not None and quats.shape[-1] != 4
+        ):
+            raise ValueError("Incorrectly shaped rotation matrix or quaternion")
+
+        # Force full-precision
+        if quats is not None:
+            quats = quats.type(torch.float32)
+        if rot_mats is not None:
+            rot_mats = rot_mats.type(torch.float32)
+
+        if quats is not None and normalize_quats:
+            quats = quats / torch.linalg.norm(quats, dim=-1, keepdim=True)
+
+        self._rot_mats = rot_mats
+        self._quats = quats
+
+    @staticmethod
+    def identity(
+        shape: Tuple[int, ...],
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> "Rotation":
+        """
+        Returns an identity Rotation.
+
+        Args:
+            shape:
+                The "shape" of the resulting Rotation object. See documentation
+                for the shape property
+            dtype:
+                The torch dtype for the rotation
+            device:
+                The torch device for the new rotation
+            requires_grad:
+                Whether the underlying tensors in the new rotation object
+                should require gradient computation
+            fmt:
+                One of "quat" or "rot_mat". Determines the underlying format
+                of the new object's rotation
+        Returns:
+            A new identity rotation
+        """
+        if fmt == "rot_mat":
+            rot_mats = identity_rot_mats(
+                shape,
+                dtype,
+                device,
+                requires_grad,
+            )
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif fmt == "quat":
+            quats = identity_quats(shape, dtype, device, requires_grad)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError(f"Invalid format: f{fmt}")
+
+    # Magic methods
+
+    def __getitem__(self, index: Any) -> "Rotation":
+        """
+        Allows torch-style indexing over the virtual shape of the rotation
+        object. See documentation for the shape property.
+
+        Args:
+            index:
+                A torch index. E.g. (1, 3, 2), or (slice(None,))
+        Returns:
+            The indexed rotation
+        """
+        if not isinstance(index, tuple):
+            index = (index,)
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats[index + (slice(None), slice(None))]
+            return Rotation(rot_mats=rot_mats)
+        elif self._quats is not None:
+            quats = self._quats[index + (slice(None),)]
+            return Rotation(quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __setitem__(self, index: Any, new: Any) -> None:
+        if not isinstance(index, tuple):
+            index = (index,)
+
+        if self._rot_mats is not None:
+            self._rot_mats[index + (slice(None), slice(None))] = new.get_rot_mats()
+        elif self._quats is not None:
+            self._quats[index + (slice(None),)] = new.get_quats()
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __mul__(
+        self,
+        right: torch.Tensor,
+    ) -> "Rotation":
+        """
+        Pointwise left multiplication of the rotation with a tensor. Can be
+        used to e.g. mask the Rotation.
+
+        Args:
+            right:
+                The tensor multiplicand
+        Returns:
+            The product
+        """
+        if not (isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats * right[..., None, None]
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = self._quats * right[..., None]
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def __rmul__(
+        self,
+        left: torch.Tensor,
+    ) -> "Rotation":
+        """
+        Reverse pointwise multiplication of the rotation with a tensor.
+
+        Args:
+            left:
+                The left multiplicand
+        Returns:
+            The product
+        """
+        return self.__mul__(left)
+
+    # Properties
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+        Returns the virtual shape of the rotation object. This shape is
+        defined as the batch dimensions of the underlying rotation matrix
+        or quaternion. If the Rotation was initialized with a [10, 3, 3]
+        rotation matrix tensor, for example, the resulting shape would be
+        [10].
+
+        Returns:
+            The virtual shape of the rotation object
+        """
+        if self._quats is not None:
+            return self._quats.shape[:-1]
+        elif self._rot_mats is not None:
+            return self._rot_mats.shape[:-2]
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def dtype(self) -> torch.dtype:
+        """
+        Returns the dtype of the underlying rotation.
+
+        Returns:
+            The dtype of the underlying rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.dtype
+        elif self._quats is not None:
+            return self._quats.dtype
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def device(self) -> torch.device:
+        """
+        The device of the underlying rotation
+
+        Returns:
+            The device of the underlying rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.device
+        elif self._quats is not None:
+            return self._quats.device
+        else:
+            raise ValueError("Both rotations are None")
+
+    @property
+    def requires_grad(self) -> bool:
+        """
+        Returns the requires_grad property of the underlying rotation
+
+        Returns:
+            The requires_grad property of the underlying tensor
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats.requires_grad
+        elif self._quats is not None:
+            return self._quats.requires_grad
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_rot_mats(self) -> torch.Tensor:
+        """
+        Returns the underlying rotation as a rotation matrix tensor.
+
+        Returns:
+            The rotation as a rotation matrix tensor
+        """
+        rot_mats = self._rot_mats
+        if rot_mats is None:
+            if self._quats is None:
+                raise ValueError("Both rotations are None")
+            else:
+                rot_mats = quat_to_rot(self._quats)
+
+        return rot_mats
+
+    def get_quats(self) -> torch.Tensor:
+        """
+        Returns the underlying rotation as a quaternion tensor.
+
+        Depending on whether the Rotation was initialized with a
+        quaternion, this function may call torch.linalg.eigh.
+
+        Returns:
+            The rotation as a quaternion tensor.
+        """
+        quats = self._quats
+        if quats is None:
+            if self._rot_mats is None:
+                raise ValueError("Both rotations are None")
+            else:
+                quats = rot_to_quat(self._rot_mats)
+
+        return quats
+
+    def get_cur_rot(self) -> torch.Tensor:
+        """
+        Return the underlying rotation in its current form
+
+        Returns:
+            The stored rotation
+        """
+        if self._rot_mats is not None:
+            return self._rot_mats
+        elif self._quats is not None:
+            return self._quats
+        else:
+            raise ValueError("Both rotations are None")
+
+    def get_rotvec(self, eps: float = 1e-4) -> torch.Tensor:
+        """
+        Return the underlying axis-angle rotation vector.
+
+        Follow's scipy's implementation:
+        https://github.com/scipy/scipy/blob/HEAD/scipy/spatial/transform/_rotation.pyx#L1385-L1402
+
+        Returns:
+            The stored rotation as a axis-angle vector.
+        """
+        quat = self.get_quats()
+        # w > 0 to ensure 0 <= angle <= pi
+        flip = (quat[..., :1] < 0).float()
+        quat = (-1 * quat) * flip + (1 - flip) * quat
+
+        angle = 2 * torch.atan2(torch.linalg.norm(quat[..., 1:], dim=-1), quat[..., 0])
+
+        angle2 = angle * angle
+        small_angle_scales = 2 + angle2 / 12 + 7 * angle2 * angle2 / 2880
+        large_angle_scales = angle / torch.sin(angle / 2 + eps)
+
+        small_angles = (angle <= 1e-3).float()
+        rot_vec_scale = (
+            small_angle_scales * small_angles + (1 - small_angles) * large_angle_scales
+        )
+        rot_vec = rot_vec_scale[..., None] * quat[..., 1:]
+        return rot_vec
+
+    # Rotation functions
+
+    def compose_q_update_vec(
+        self,
+        q_update_vec: torch.Tensor,
+        normalize_quats: bool = True,
+        update_mask: torch.Tensor | None = None,
+    ) -> "Rotation":
+        """
+        Returns a new quaternion Rotation after updating the current
+        object's underlying rotation with a quaternion update, formatted
+        as a [*, 3] tensor whose final three columns represent x, y, z such
+        that (1, x, y, z) is the desired (not necessarily unit) quaternion
+        update.
+
+        Args:
+            q_update_vec:
+                A [*, 3] quaternion update tensor
+            normalize_quats:
+                Whether to normalize the output quaternion
+        Returns:
+            An updated Rotation
+        """
+        quats = self.get_quats()
+        quat_update = quat_multiply_by_vec(quats, q_update_vec)
+        if update_mask is not None:
+            quat_update = quat_update * update_mask
+        new_quats = quats + quat_update
+        return Rotation(
+            rot_mats=None,
+            quats=new_quats,
+            normalize_quats=normalize_quats,
+        )
+
+    def compose_r(self, r: "Rotation") -> "Rotation":
+        """
+        Compose the rotation matrices of the current Rotation object with
+        those of another.
+
+        Args:
+            r:
+                An update rotation object
+        Returns:
+            An updated rotation object
+        """
+        r1 = self.get_rot_mats()
+        r2 = r.get_rot_mats()
+        new_rot_mats = rot_matmul(r1, r2)
+        return Rotation(rot_mats=new_rot_mats, quats=None)
+
+    def compose_q(self, r: "Rotation", normalize_quats: bool = True) -> "Rotation":
+        """
+        Compose the quaternions of the current Rotation object with those
+        of another.
+
+        Depending on whether either Rotation was initialized with
+        quaternions, this function may call torch.linalg.eigh.
+
+        Args:
+            r:
+                An update rotation object
+        Returns:
+            An updated rotation object
+        """
+        q1 = self.get_quats()
+        q2 = r.get_quats()
+        new_quats = quat_multiply(q1, q2)
+        return Rotation(rot_mats=None, quats=new_quats, normalize_quats=normalize_quats)
+
+    def apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        Apply the current Rotation as a rotation matrix to a set of 3D
+        coordinates.
+
+        Args:
+            pts:
+                A [*, 3] set of points
+        Returns:
+            [*, 3] rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        return rot_vec_mul(rot_mats, pts)
+
+    def invert_apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        The inverse of the apply() method.
+
+        Args:
+            pts:
+                A [*, 3] set of points
+        Returns:
+            [*, 3] inverse-rotated points
+        """
+        rot_mats = self.get_rot_mats()
+        inv_rot_mats = invert_rot_mat(rot_mats)
+        return rot_vec_mul(inv_rot_mats, pts)
+
+    def invert(self) -> "Rotation":
+        """
+        Returns the inverse of the current Rotation.
+
+        Returns:
+            The inverse of the current Rotation
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=invert_rot_mat(self._rot_mats), quats=None)
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=invert_quat(self._quats),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    # "Tensor" stuff
+
+    def unsqueeze(
+        self,
+        dim: int,
+    ) -> "Rotation":
+        """
+        Analogous to torch.unsqueeze. The dimension is relative to the
+        shape of the Rotation object.
+
+        Args:
+            dim: A positive or negative dimension index.
+        Returns:
+            The unsqueezed Rotation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats.unsqueeze(dim if dim >= 0 else dim - 2)
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = self._quats.unsqueeze(dim if dim >= 0 else dim - 1)
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    @staticmethod
+    def cat(
+        rs: list["Rotation"],
+        dim: int,
+    ) -> "Rotation":
+        """
+        Concatenates rotations along one of the batch dimensions. Analogous
+        to torch.cat().
+
+        Note that the output of this operation is always a rotation matrix,
+        regardless of the format of input rotations.
+
+        Args:
+            rs:
+                A list of rotation objects
+            dim:
+                The dimension along which the rotations should be
+                concatenated
+        Returns:
+            A concatenated Rotation object in rotation matrix format
+        """
+        rot_mats = [r.get_rot_mats() for r in rs]
+        cat_rot_mats = torch.cat(rot_mats, dim=dim if dim >= 0 else dim - 2)
+
+        return Rotation(rot_mats=cat_rot_mats, quats=None)
+
+    def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> "Rotation":
+        """
+        Apply a Tensor -> Tensor function to underlying rotation tensors,
+        mapping over the rotation dimension(s). Can be used e.g. to sum out
+        a one-hot batch dimension.
+
+        Args:
+            fn:
+                A Tensor -> Tensor function to be mapped over the Rotation
+        Returns:
+            The transformed Rotation object
+        """
+        if self._rot_mats is not None:
+            rot_mats = self._rot_mats.view(self._rot_mats.shape[:-2] + (9,))
+            rot_mats = torch.stack(
+                list(map(fn, torch.unbind(rot_mats, dim=-1))), dim=-1
+            )
+            rot_mats = rot_mats.view(rot_mats.shape[:-1] + (3, 3))
+            return Rotation(rot_mats=rot_mats, quats=None)
+        elif self._quats is not None:
+            quats = torch.stack(
+                list(map(fn, torch.unbind(self._quats, dim=-1))), dim=-1
+            )
+            return Rotation(rot_mats=None, quats=quats, normalize_quats=False)
+        else:
+            raise ValueError("Both rotations are None")
+
+    def cuda(self) -> "Rotation":
+        """
+        Analogous to the cuda() method of torch Tensors
+
+        Returns:
+            A copy of the Rotation in CUDA memory
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=self._rot_mats.cuda(), quats=None)
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None, quats=self._quats.cuda(), normalize_quats=False
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    def to(
+        self, device: Optional[torch.device], dtype: Optional[torch.dtype]
+    ) -> "Rotation":
+        """
+        Analogous to the to() method of torch Tensors
+
+        Args:
+            device:
+                A torch device
+            dtype:
+                A torch dtype
+        Returns:
+            A copy of the Rotation using the new device and dtype
+        """
+        if self._rot_mats is not None:
+            return Rotation(
+                rot_mats=self._rot_mats.to(device=device, dtype=dtype),
+                quats=None,
+            )
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=self._quats.to(device=device, dtype=dtype),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+    def detach(self) -> "Rotation":
+        """
+        Returns a copy of the Rotation whose underlying Tensor has been
+        detached from its torch graph.
+
+        Returns:
+            A copy of the Rotation whose underlying Tensor has been detached
+            from its torch graph
+        """
+        if self._rot_mats is not None:
+            return Rotation(rot_mats=self._rot_mats.detach(), quats=None)
+        elif self._quats is not None:
+            return Rotation(
+                rot_mats=None,
+                quats=self._quats.detach(),
+                normalize_quats=False,
+            )
+        else:
+            raise ValueError("Both rotations are None")
+
+
+class Rigid:
+    """
+    A class representing a rigid transformation. Little more than a wrapper
+    around two objects: a Rotation object and a [*, 3] translation
+    Designed to behave approximately like a single torch tensor with the
+    shape of the shared batch dimensions of its component parts.
+    """
+
+    def __init__(
+        self,
+        rots: Optional[Rotation],
+        trans: Optional[torch.Tensor],
+    ):
+        """
+        Args:
+            rots: A [*, 3, 3] rotation tensor
+            trans: A corresponding [*, 3] translation tensor
+        """
+        # (we need device, dtype, etc. from at least one input)
+
+        batch_dims, dtype, device, requires_grad = None, None, None, None
+        if trans is not None:
+            batch_dims = trans.shape[:-1]
+            dtype = trans.dtype
+            device = trans.device
+            requires_grad = trans.requires_grad
+        elif rots is not None:
+            batch_dims = rots.shape
+            dtype = rots.dtype
+            device = rots.device
+            requires_grad = rots.requires_grad
+        else:
+            raise ValueError("At least one input argument must be specified")
+
+        if rots is None:
+            rots = Rotation.identity(
+                batch_dims,
+                dtype,
+                device,
+                requires_grad,
+            )
+        if trans is None:
+            trans = identity_trans(
+                batch_dims,
+                dtype,
+                device,
+                requires_grad,
+            )
+
+        if (rots.shape != trans.shape[:-1]) or (rots.device != trans.device):
+            raise ValueError("Rots and trans incompatible")
+
+        # Force full precision. Happens to the rotations automatically.
+        trans = trans.type(torch.float32)
+
+        self._rots = rots
+        self._trans = trans
+
+    @staticmethod
+    def identity(
+        shape: Tuple[int, ...],
+        dtype: Optional[torch.dtype] = None,
+        device: Optional[torch.device] = None,
+        requires_grad: bool = True,
+        fmt: str = "quat",
+    ) -> "Rigid":
+        """
+        Constructs an identity transformation.
+
+        Args:
+            shape:
+                The desired shape
+            dtype:
+                The dtype of both internal tensors
+            device:
+                The device of both internal tensors
+            requires_grad:
+                Whether grad should be enabled for the internal tensors
+        Returns:
+            The identity transformation
+        """
+        return Rigid(
+            Rotation.identity(shape, dtype, device, requires_grad, fmt=fmt),
+            identity_trans(shape, dtype, device, requires_grad),
+        )
+
+    def __getitem__(
+        self,
+        index: Any,
+    ) -> "Rigid":
+        """
+        Indexes the affine transformation with PyTorch-style indices.
+        The index is applied to the shared dimensions of both the rotation
+        and the translation.
+
+        E.g.::
+
+            r = Rotation(rot_mats=torch.rand(10, 10, 3, 3), quats=None)
+            t = Rigid(r, torch.rand(10, 10, 3))
+            indexed = t[3, 4:6]
+            assert indexed.shape == (2,)
+            assert indexed.get_rots().shape == (2,)
+            assert indexed.get_trans().shape == (2, 3)
+
+        Args:
+            index: A standard torch tensor index. E.g. 8, (10, None, 3),
+            or (3, slice(0, 1, None))
+        Returns:
+            The indexed tensor
+        """
+        if not isinstance(index, tuple):
+            index = (index,)
+
+        return Rigid(
+            self._rots[index],
+            self._trans[index + (slice(None),)],
+        )
+
+    def __mul__(
+        self,
+        right: torch.Tensor,
+    ) -> "Rigid":
+        """
+        Pointwise left multiplication of the transformation with a tensor.
+        Can be used to e.g. mask the Rigid.
+
+        Args:
+            right:
+                The tensor multiplicand
+        Returns:
+            The product
+        """
+        if not (isinstance(right, torch.Tensor)):
+            raise TypeError("The other multiplicand must be a Tensor")
+
+        new_rots = self._rots * right
+        new_trans = self._trans * right[..., None]
+
+        return Rigid(new_rots, new_trans)
+
+    def __rmul__(
+        self,
+        left: torch.Tensor,
+    ) -> "Rigid":
+        """
+        Reverse pointwise multiplication of the transformation with a
+        tensor.
+
+        Args:
+            left:
+                The left multiplicand
+        Returns:
+            The product
+        """
+        return self.__mul__(left)
+
+    @property
+    def shape(self) -> torch.Size:
+        """
+        Returns the shape of the shared dimensions of the rotation and
+        the translation.
+
+        Returns:
+            The shape of the transformation
+        """
+        s = self._trans.shape[:-1]
+        return s
+
+    @property
+    def device(self) -> torch.device:
+        """
+        Returns the device on which the Rigid's tensors are located.
+
+        Returns:
+            The device on which the Rigid's tensors are located
+        """
+        return self._trans.device
+
+    def get_rots(self) -> Rotation:
+        """
+        Getter for the rotation.
+
+        Returns:
+            The rotation object
+        """
+        return self._rots
+
+    def get_trans(self) -> torch.Tensor:
+        """
+        Getter for the translation.
+
+        Returns:
+            The stored translation
+        """
+        return self._trans
+
+    def compose_q_update_vec(
+        self,
+        q_update_vec: torch.Tensor,
+        update_mask: torch.Tensor | None = None,
+    ) -> "Rigid":
+        """
+        Composes the transformation with a quaternion update vector of
+        shape [*, 6], where the final 6 columns represent the x, y, and
+        z values of a quaternion of form (1, x, y, z) followed by a 3D
+        translation.
+
+        Args:
+            q_vec: The quaternion update vector.
+        Returns:
+            The composed transformation.
+        """
+        q_vec, t_vec = q_update_vec[..., :3], q_update_vec[..., 3:]
+        new_rots = self._rots.compose_q_update_vec(q_vec, update_mask=update_mask)
+
+        trans_update = self._rots.apply(t_vec)
+        if update_mask is not None:
+            trans_update = trans_update * update_mask
+        new_translation = self._trans + trans_update
+
+        return Rigid(new_rots, new_translation)
+
+    def compose_tran_update_vec(
+        self,
+        t_vec: torch.Tensor,
+        update_mask: torch.Tensor | None = None,
+    ) -> "Rigid":
+        """
+        Composes the transformation with a quaternion update vector of
+        shape [*, 3], where columns represent a 3D translation.
+
+        Args:
+            q_vec: The quaternion update vector.
+        Returns:
+            The composed transformation.
+        """
+        trans_update = self._rots.apply(t_vec)
+        if update_mask is not None:
+            trans_update = trans_update * update_mask
+        new_translation = self._trans + trans_update
+
+        return Rigid(self._rots, new_translation)
+
+    def compose(
+        self,
+        r: "Rigid",
+    ) -> "Rigid":
+        """
+        Composes the current rigid object with another.
+
+        Args:
+            r:
+                Another Rigid object
+        Returns:
+            The composition of the two transformations
+        """
+        new_rot = self._rots.compose_r(r._rots)
+        new_trans = self._rots.apply(r._trans) + self._trans
+        return Rigid(new_rot, new_trans)
+
+    def compose_r(self, rot: Rotation, order: str = "right") -> "Rigid":
+        """
+        Composes the current rigid object with another.
+
+        Args:
+            r:
+                Another Rigid object
+            order:
+                Order in which to perform rotation multiplication.
+        Returns:
+            The composition of the two transformations
+        """
+        if order == "right":
+            new_rot = self._rots.compose_r(rot)
+        elif order == "left":
+            new_rot = rot.compose_r(self._rots)
+        else:
+            raise ValueError(f"Unrecognized multiplication order: {order}")
+        return Rigid(new_rot, self._trans)
+
+    def apply(
+        self,
+        pts: torch.Tensor,
+    ) -> torch.Tensor:
+        """
+        Applies the transformation to a coordinate tensor.
+
+        Args:
+            pts: A [*, 3] coordinate tensor.
+        Returns:
+            The transformed points.
+        """
+        rotated = self._rots.apply(pts)
+        return rotated + self._trans
+
+    def invert_apply(self, pts: torch.Tensor) -> torch.Tensor:
+        """
+        Applies the inverse of the transformation to a coordinate tensor.
+
+        Args:
+            pts: A [*, 3] coordinate tensor
+        Returns:
+            The transformed points.
+        """
+        pts = pts - self._trans
+        return self._rots.invert_apply(pts)
+
+    def invert(self) -> "Rigid":
+        """
+        Inverts the transformation.
+
+        Returns:
+            The inverse transformation.
+        """
+        rot_inv = self._rots.invert()
+        trn_inv = rot_inv.apply(self._trans)
+
+        return Rigid(rot_inv, -1 * trn_inv)
+
+    def map_tensor_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> "Rigid":
+        """
+        Apply a Tensor -> Tensor function to underlying translation and
+        rotation tensors, mapping over the translation/rotation dimensions
+        respectively.
+
+        Args:
+            fn:
+                A Tensor -> Tensor function to be mapped over the Rigid
+        Returns:
+            The transformed Rigid object
+        """
+        new_rots = self._rots.map_tensor_fn(fn)
+        new_trans = torch.stack(
+            list(map(fn, torch.unbind(self._trans, dim=-1))), dim=-1
+        )
+
+        return Rigid(new_rots, new_trans)
+
+    def to_tensor_4x4(self) -> torch.Tensor:
+        """
+        Converts a transformation to a homogenous transformation tensor.
+
+        Returns:
+            A [*, 4, 4] homogenous transformation tensor
+        """
+        tensor = self._trans.new_zeros((*self.shape, 4, 4))
+        tensor[..., :3, :3] = self._rots.get_rot_mats()
+        tensor[..., :3, 3] = self._trans
+        tensor[..., 3, 3] = 1
+        return tensor
+
+    @staticmethod
+    def from_tensor_4x4(t: torch.Tensor) -> "Rigid":
+        """
+        Constructs a transformation from a homogenous transformation
+        tensor.
+
+        Args:
+            t: [*, 4, 4] homogenous transformation tensor
+        Returns:
+            T object with shape [*]
+        """
+        if t.shape[-2:] != (4, 4):
+            raise ValueError("Incorrectly shaped input tensor")
+
+        rots = Rotation(rot_mats=t[..., :3, :3], quats=None)
+        trans = t[..., :3, 3]
+
+        return Rigid(rots, trans)
+
+    def to_tensor_7(self) -> torch.Tensor:
+        """
+        Converts a transformation to a tensor with 7 final columns, four
+        for the quaternion followed by three for the translation.
+
+        Returns:
+            A [*, 7] tensor representation of the transformation
+        """
+        tensor = self._trans.new_zeros((*self.shape, 7))
+        tensor[..., :4] = self._rots.get_quats()
+        tensor[..., 4:] = self._trans
+
+        return tensor
+
+    @staticmethod
+    def from_tensor_7(
+        t: torch.Tensor,
+        normalize_quats: bool = False,
+    ) -> "Rigid":
+        if t.shape[-1] != 7:
+            raise ValueError("Incorrectly shaped input tensor")
+
+        quats, trans = t[..., :4], t[..., 4:]
+
+        rots = Rotation(rot_mats=None, quats=quats, normalize_quats=normalize_quats)
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def from_3_points(
+        p_neg_x_axis: torch.Tensor,
+        origin: torch.Tensor,
+        p_xy_plane: torch.Tensor,
+        eps: float = 1e-4,
+    ) -> "Rigid":
+        """
+        Implements algorithm 21. Constructs transformations from sets of 3
+        points using the Gram-Schmidt algorithm.
+
+        Args:
+            p_neg_x_axis: [*, 3] coordinates
+            origin: [*, 3] coordinates used as frame origins
+            p_xy_plane: [*, 3] coordinates
+            eps: Small epsilon value
+        Returns:
+            A transformation object of shape [*]
+        """
+        p_neg_x_axis_cols = torch.unbind(p_neg_x_axis, dim=-1)
+        origin_cols = torch.unbind(origin, dim=-1)
+        p_xy_plane_cols = torch.unbind(p_xy_plane, dim=-1)
+
+        e0 = [c1 - c2 for c1, c2 in zip(origin_cols, p_neg_x_axis_cols)]
+        e1 = [c1 - c2 for c1, c2 in zip(p_xy_plane_cols, origin_cols)]
+
+        denom = torch.sqrt(cast(torch.Tensor, sum(c * c for c in e0)) + eps)
+        e0 = [c / denom for c in e0]
+        dot = sum((c1 * c2 for c1, c2 in zip(e0, e1)))
+        e1 = [c2 - c1 * dot for c1, c2 in zip(e0, e1)]
+        denom = torch.sqrt(cast(torch.Tensor, sum(c * c for c in e1)) + eps)
+        e1 = [c / denom for c in e1]
+        e2 = [
+            e0[1] * e1[2] - e0[2] * e1[1],
+            e0[2] * e1[0] - e0[0] * e1[2],
+            e0[0] * e1[1] - e0[1] * e1[0],
+        ]
+
+        rots = torch.stack([c for tup in zip(e0, e1, e2) for c in tup], dim=-1)
+        rots = rots.reshape(rots.shape[:-1] + (3, 3))
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, torch.stack(origin_cols, dim=-1))
+
+    def unsqueeze(
+        self,
+        dim: int,
+    ) -> "Rigid":
+        """
+        Analogous to torch.unsqueeze. The dimension is relative to the
+        shared dimensions of the rotation/translation.
+
+        Args:
+            dim: A positive or negative dimension index.
+        Returns:
+            The unsqueezed transformation.
+        """
+        if dim >= len(self.shape):
+            raise ValueError("Invalid dimension")
+        rots = self._rots.unsqueeze(dim)
+        trans = self._trans.unsqueeze(dim if dim >= 0 else dim - 1)
+
+        return Rigid(rots, trans)
+
+    @staticmethod
+    def cat(
+        ts: list["Rigid"],
+        dim: int,
+    ) -> "Rigid":
+        """
+        Concatenates transformations along a new dimension.
+
+        Args:
+            ts:
+                A list of T objects
+            dim:
+                The dimension along which the transformations should be
+                concatenated
+        Returns:
+            A concatenated transformation object
+        """
+        rots = Rotation.cat([t._rots for t in ts], dim)
+        trans = torch.cat([t._trans for t in ts], dim=dim if dim >= 0 else dim - 1)
+
+        return Rigid(rots, trans)
+
+    def apply_rot_fn(self, fn: Callable[[Rotation], Rotation]) -> "Rigid":
+        """
+        Applies a Rotation -> Rotation function to the stored rotation
+        object.
+
+        Args:
+            fn: A function of type Rotation -> Rotation
+        Returns:
+            A transformation object with a transformed rotation.
+        """
+        return Rigid(fn(self._rots), self._trans)
+
+    def apply_trans_fn(self, fn: Callable[[torch.Tensor], torch.Tensor]) -> "Rigid":
+        """
+        Applies a Tensor -> Tensor function to the stored translation.
+
+        Args:
+            fn:
+                A function of type Tensor -> Tensor to be applied to the
+                translation
+        Returns:
+            A transformation object with a transformed translation.
+        """
+        return Rigid(self._rots, fn(self._trans))
+
+    def scale_translation(self, trans_scale_factor: float) -> "Rigid":
+        """
+        Scales the translation by a constant factor.
+
+        Args:
+            trans_scale_factor:
+                The constant factor
+        Returns:
+            A transformation object with a scaled translation.
+        """
+        fn = lambda t: t * trans_scale_factor  # noqa: E731
+        return self.apply_trans_fn(fn)
+
+    def stop_rot_gradient(self) -> "Rigid":
+        """
+        Detaches the underlying rotation object
+
+        Returns:
+            A transformation object with detached rotations
+        """
+        fn = lambda r: r.detach()  # noqa: E731
+        return self.apply_rot_fn(fn)
+
+    @staticmethod
+    def make_transform_from_reference(
+        n_xyz: torch.Tensor,
+        ca_xyz: torch.Tensor,
+        c_xyz: torch.Tensor,
+        eps: float = 1e-20,
+    ) -> "Rigid":
+        """
+        Returns a transformation object from reference coordinates.
+
+        Note that this method does not take care of symmetries. If you
+        provide the atom positions in the non-standard way, the N atom will
+        end up not at [-0.527250, 1.359329, 0.0] but instead at
+        [-0.527250, -1.359329, 0.0]. You need to take care of such cases in
+        your code.
+
+        Args:
+            n_xyz: A [*, 3] tensor of nitrogen xyz coordinates.
+            ca_xyz: A [*, 3] tensor of carbon alpha xyz coordinates.
+            c_xyz: A [*, 3] tensor of carbon xyz coordinates.
+        Returns:
+            A transformation object. After applying the translation and
+            rotation to the reference backbone, the coordinates will
+            approximately equal to the input coordinates.
+        """
+        translation = -1 * ca_xyz
+        n_xyz = n_xyz + translation
+        c_xyz = c_xyz + translation
+
+        c_x, c_y, c_z = [c_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + c_x**2 + c_y**2)
+        sin_c1 = -c_y / norm
+        cos_c1 = c_x / norm
+
+        c1_rots = sin_c1.new_zeros((*sin_c1.shape, 3, 3))
+        c1_rots[..., 0, 0] = cos_c1
+        c1_rots[..., 0, 1] = -1 * sin_c1
+        c1_rots[..., 1, 0] = sin_c1
+        c1_rots[..., 1, 1] = cos_c1
+        c1_rots[..., 2, 2] = 1
+
+        norm = torch.sqrt(eps + c_x**2 + c_y**2 + c_z**2)
+        sin_c2 = c_z / norm
+        cos_c2 = torch.sqrt(c_x**2 + c_y**2) / norm
+
+        c2_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        c2_rots[..., 0, 0] = cos_c2
+        c2_rots[..., 0, 2] = sin_c2
+        c2_rots[..., 1, 1] = 1
+        c1_rots[..., 2, 0] = -1 * sin_c2
+        c1_rots[..., 2, 2] = cos_c2
+
+        c_rots = rot_matmul(c2_rots, c1_rots)
+        n_xyz = rot_vec_mul(c_rots, n_xyz)
+
+        _, n_y, n_z = [n_xyz[..., i] for i in range(3)]
+        norm = torch.sqrt(eps + n_y**2 + n_z**2)
+        sin_n = -n_z / norm
+        cos_n = n_y / norm
+
+        n_rots = sin_c2.new_zeros((*sin_c2.shape, 3, 3))
+        n_rots[..., 0, 0] = 1
+        n_rots[..., 1, 1] = cos_n
+        n_rots[..., 1, 2] = -1 * sin_n
+        n_rots[..., 2, 1] = sin_n
+        n_rots[..., 2, 2] = cos_n
+
+        rots = rot_matmul(n_rots, c_rots)
+
+        rots = rots.transpose(-1, -2)
+        translation = -1 * translation
+
+        rot_obj = Rotation(rot_mats=rots, quats=None)
+
+        return Rigid(rot_obj, translation)
+
+    def cuda(self) -> "Rigid":
+        """
+        Moves the transformation object to GPU memory
+
+        Returns:
+            A version of the transformation on GPU
+        """
+        return Rigid(self._rots.cuda(), self._trans.cuda())

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/rotation_augmentation.py

@@ -0,0 +1,67 @@
+import math
+
+import torch
+
+from foundry.utils.rigid import rot_vec_mul
+
+
+def centre(X_L: torch.Tensor, X_exists_L: torch.Tensor) -> torch.Tensor:
+    X_L = X_L.clone()
+    X_L[X_exists_L] = X_L[X_exists_L] - torch.mean(
+        X_L[X_exists_L], dim=-2, keepdim=True
+    )
+    X_L[~X_exists_L] = 0.0
+    return X_L
+
+
+def get_random_augmentation(X_L: torch.Tensor, s_trans: float) -> torch.Tensor:
+    """
+    Inputs:
+        X_L [D, L, 3]: Batched atom coordinates
+        s_trans (float): standard deviation of a global translation to be applied for each
+            element in the batch
+    """
+    D, L, _ = X_L.shape
+    R = uniform_random_rotation((D,)).to(X_L.device)
+    noise = s_trans * torch.normal(mean=0, std=1, size=(D, 1, 3)).to(X_L.device)
+    return rot_vec_mul(R[:, None], X_L) + noise
+
+
+def centre_random_augmentation(
+    X_L: torch.Tensor, X_exists_L: torch.Tensor, s_trans: float
+) -> torch.Tensor:
+    X_L = centre(X_L, X_exists_L)
+    return get_random_augmentation(X_L, s_trans)
+
+
+def uniform_random_rotation(size: tuple[int, ...]) -> torch.Tensor:
+    # Sample random angles for rotations around X, Y, and Z axes
+    theta_x = torch.rand(size) * 2 * math.pi
+    theta_y = torch.rand(size) * 2 * math.pi
+    theta_z = torch.rand(size) * 2 * math.pi
+
+    # Calculate the cosines and sines of the angles
+    cos_x = torch.cos(theta_x)
+    sin_x = torch.sin(theta_x)
+    cos_y = torch.cos(theta_y)
+    sin_y = torch.sin(theta_y)
+    cos_z = torch.cos(theta_z)
+    sin_z = torch.sin(theta_z)
+
+    # Create the rotation matrices around X, Y, and Z axes
+    rotation_x = torch.stack(
+        [torch.tensor([[1, 0, 0], [0, c, -s], [0, s, c]]) for c, s in zip(cos_x, sin_x)]
+    )
+
+    rotation_y = torch.stack(
+        [torch.tensor([[c, 0, s], [0, 1, 0], [-s, 0, c]]) for c, s in zip(cos_y, sin_y)]
+    )
+
+    rotation_z = torch.stack(
+        [torch.tensor([[c, -s, 0], [s, c, 0], [0, 0, 1]]) for c, s in zip(cos_z, sin_z)]
+    )
+
+    # Combine the rotation matrices
+    rotation_matrix = torch.matmul(rotation_z, torch.matmul(rotation_y, rotation_x))
+
+    return rotation_matrix

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/squashfs.py

@@ -0,0 +1,172 @@
+"""Squashfs filesystem mount management.
+
+Provides a singleton manager for mounting and caching squashfs filesystems.
+Mounts are lazy (happen on first access) and persist for the lifetime of the program.
+"""
+
+import atexit
+import logging
+import os
+import subprocess
+import tempfile
+import threading
+from pathlib import Path
+
+logger = logging.getLogger(__name__)
+
+
+class SquashfsManager:
+    """Singleton manager for squashfs filesystem mounts.
+
+    Provides lazy mounting of squashfs files with automatic caching and cleanup.
+    Thread-safe for use with multiprocessing/DataLoader workers.
+
+    Examples:
+        Get mount directory (mounts automatically if needed)::
+
+            from foundry.utils.squashfs import SquashfsManager
+
+            mount_dir = SquashfsManager.get_mount("/path/to/file.sqfs")
+            file_path = os.path.join(mount_dir, "internal/path/to/file")
+
+        Inspect active mounts::
+
+            mounts = SquashfsManager.list_mounts()
+            print(f"Active mounts: {len(mounts)}")
+
+        Cleanup (typically for tests)::
+
+            SquashfsManager.unmount_all()
+    """
+
+    _mounts: dict[str, str] = {}
+    _lock = threading.Lock()
+    _cleanup_registered = False
+
+    @classmethod
+    def get_mount(cls, sqfs_file: str) -> str:
+        """Get mount directory for squashfs file, mounting if needed.
+
+        Args:
+            sqfs_file: Path to the .sqfs file.
+
+        Returns:
+            Path to the mount directory containing the squashfs contents.
+
+        Raises:
+            FileNotFoundError: If the sqfs file doesn't exist.
+            RuntimeError: If mounting fails.
+        """
+        sqfs_file = str(Path(sqfs_file).resolve())
+
+        # Check file exists
+        if not os.path.exists(sqfs_file):
+            raise FileNotFoundError(f"Squashfs file not found: {sqfs_file}")
+
+        with cls._lock:
+            # Register cleanup on first use
+            if not cls._cleanup_registered:
+                atexit.register(cls._cleanup_on_exit)
+                cls._cleanup_registered = True
+
+            # Return cached mount if exists
+            if sqfs_file in cls._mounts:
+                return cls._mounts[sqfs_file]
+
+            # Mount and cache
+            mount_dir = cls._mount(sqfs_file)
+            cls._mounts[sqfs_file] = mount_dir
+            logger.info(f"Mounted {sqfs_file} at {mount_dir}")
+            return mount_dir
+
+    @classmethod
+    def _mount(cls, sqfs_file: str) -> str:
+        """Internal: Actually perform the squashfs mount.
+
+        Args:
+            sqfs_file: Path to the .sqfs file.
+
+        Returns:
+            Path to the mount directory.
+
+        Raises:
+            RuntimeError: If mounting fails.
+        """
+        mount_dir = tempfile.mkdtemp(prefix="sqfs_")
+        try:
+            subprocess.run(
+                ["squashfuse", sqfs_file, mount_dir],
+                check=True,
+                capture_output=True,
+            )
+            return mount_dir
+        except subprocess.CalledProcessError as e:
+            # Cleanup failed mount directory
+            try:
+                os.rmdir(mount_dir)
+            except OSError:
+                pass
+            raise RuntimeError(
+                f"Failed to mount {sqfs_file}: {e.stderr.decode()}"
+            ) from e
+
+    @classmethod
+    def _unmount(cls, sqfs_file: str) -> None:
+        """Internal: Unmount a squashfs filesystem.
+
+        Args:
+            sqfs_file: Path to the .sqfs file to unmount.
+        """
+        if sqfs_file not in cls._mounts:
+            return
+
+        mount_dir = cls._mounts[sqfs_file]
+        try:
+            subprocess.run(
+                ["fusermount", "-u", mount_dir],
+                check=True,
+                capture_output=True,
+            )
+            os.rmdir(mount_dir)
+            logger.info(f"Unmounted {sqfs_file}")
+        except (subprocess.CalledProcessError, OSError) as e:
+            logger.warning(f"Failed to unmount {sqfs_file}: {e}")
+        finally:
+            del cls._mounts[sqfs_file]
+
+    @classmethod
+    def list_mounts(cls) -> dict[str, str]:
+        """List all active squashfs mounts.
+
+        Returns:
+            Dictionary mapping sqfs file paths to mount directories.
+
+        Examples:
+            >>> mounts = SquashfsManager.list_mounts()
+            >>> print(f"Active mounts: {len(mounts)}")
+            >>> for sqfs, mount_dir in mounts.items():
+            ...     print(f"{sqfs} -> {mount_dir}")
+        """
+        with cls._lock:
+            return cls._mounts.copy()
+
+    @classmethod
+    def unmount_all(cls) -> None:
+        """Unmount all squashfs filesystems.
+
+        Useful for cleanup in tests or explicit resource management.
+        Normally not needed as cleanup happens automatically on program exit.
+
+        Examples:
+            >>> SquashfsManager.unmount_all()  # Clean up in test teardown
+        """
+        with cls._lock:
+            sqfs_files = list(cls._mounts.keys())
+            for sqfs_file in sqfs_files:
+                cls._unmount(sqfs_file)
+
+    @classmethod
+    def _cleanup_on_exit(cls) -> None:
+        """Cleanup hook called on program exit via atexit."""
+        logger.debug("Cleaning up squashfs mounts on exit")
+        cls.unmount_all()

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/torch.py

@@ -0,0 +1,367 @@
+"""General convenience utilities for PyTorch."""
+
+__all__ = [
+    "map_to",
+    "assert_no_nans",
+    "assert_shape",
+    "assert_same_shape",
+    "scatter_mean",
+]
+
+import time
+import warnings
+from contextlib import contextmanager
+
+import numpy as np
+import torch
+from beartype.typing import Any, Iterator, Sequence
+from toolz import valmap
+from torch import Tensor
+from torch._prims_common import DeviceLikeType
+from torch.types import _dtype
+
+from foundry import should_check_nans
+from foundry.common import at_least_one_exists, do_nothing
+
+
+def map_to(
+    x: Any,
+    *,
+    device: DeviceLikeType | None = None,
+    dtype: _dtype | None = None,
+    non_blocking: bool = False,
+    **to_kwargs: Any,
+) -> Any:
+    """
+    Recursively applies the `.to()` method to all tensors in a nested structure.
+
+    This function handles nested structures such as dictionaries and lists, applying the `.to()` method
+    to any PyTorch tensors while leaving other types unchanged.
+
+    NOTE: If you are instantiating a new tensor, you should use the `device` and `dtype` arguments
+    instead of calling `map_to()` on the tensor.
+    (https://pytorch.org/tutorials/recipes/recipes/tuning_guide.html#create-tensors-directly-on-the-target-device)
+
+
+    Args:
+        - x (Any): The input structure, which can be a tensor, dictionary, list, or any other type.
+        - device (DeviceLikeType | None): The target device to move tensors to (e.g., 'cpu', 'cuda').
+        - dtype (_dtype | None): The target dtype to cast tensors to.
+        - non_blocking (bool): Whether to use non-blocking transfers when possible.
+        - **to_kwargs: Additional keyword arguments to pass to the `.to()` method.
+
+    Returns:
+        - Any: The input structure with all contained tensors processed by the `.to()` method.
+
+    Example:
+        >>> data = {"tensor": torch.tensor([1, 2, 3]), "list": [torch.tensor([4, 5]), "string"]}
+        >>> map_to(data, device="cuda", dtype=torch.float32)
+        {'tensor': tensor([1., 2., 3.], device='cuda:0', dtype=torch.float32),
+         'list': [tensor([4., 5.], device='cuda:0', dtype=torch.float32), 'string']}
+    """
+    torch._assert(
+        at_least_one_exists(device, dtype),
+        "Must provide at least one of `device` or `dtype`",
+    )
+
+    if isinstance(x, dict):
+        return valmap(
+            lambda v: map_to(
+                v, device=device, dtype=dtype, non_blocking=non_blocking, **to_kwargs
+            ),
+            x,
+        )
+    elif isinstance(x, (list, tuple)):
+        return type(x)(
+            map(
+                lambda v: map_to(
+                    v,
+                    device=device,
+                    dtype=dtype,
+                    non_blocking=non_blocking,
+                    **to_kwargs,
+                ),
+                x,
+            )
+        )
+    elif isinstance(x, Tensor):
+        return x.to(device=device, dtype=dtype, non_blocking=non_blocking, **to_kwargs)
+    else:
+        return x
+
+
+def _assert_no_nans(x: Any, *, msg: str = "", fail_if_not_tensor: bool = False) -> None:
+    """Recursively checks for NaN values in tensor-like objects.
+
+    Args:
+        - x (Any): Input to check for NaNs. Can be a tensor, dict, list, tuple, or other type.
+        - msg (str): Prefix for error messages.
+        - fail_if_not_tensor (bool): If True, raises error for non-tensor types.
+    """
+    if isinstance(x, Tensor):
+        torch._assert(
+            not torch.isnan(x).any(),
+            ": ".join(filter(bool, [msg, "Tensor contains NaNs!"])),
+        )
+    elif isinstance(x, np.ndarray):
+        torch._assert(
+            not np.isnan(x).any(),
+            ": ".join(filter(bool, [msg, "Numpy array contains NaNs!"])),
+        )
+    elif isinstance(x, float):
+        torch._assert(
+            not np.isnan(x),
+            ": ".join(filter(bool, [msg, "float is NaN!"])),
+        )
+    elif isinstance(x, dict):
+        for k, v in x.items():
+            _assert_no_nans(
+                v,
+                msg=".".join(filter(bool, [msg, k])),
+                fail_if_not_tensor=fail_if_not_tensor,
+            )
+    elif isinstance(x, (list, tuple)):
+        for idx, v in enumerate(x):
+            _assert_no_nans(
+                v,
+                msg=".".join(filter(bool, [msg, str(idx)])),
+                fail_if_not_tensor=fail_if_not_tensor,
+            )
+    elif fail_if_not_tensor:
+        raise ValueError(f"Unsupported type: {type(x)}")
+
+
+assert_no_nans = _assert_no_nans if should_check_nans else do_nothing
+
+
+@contextmanager
+def _suppress_tracer_warnings() -> Iterator[None]:
+    """
+    Context manager to temporarily suppress known warnings in torch.jit.trace().
+    Note: Cannot use catch_warnings because of https://bugs.python.org/issue29672
+
+    References:
+        - https://github.com/NVlabs/edm2/blob/main/torch_utils/misc.py
+    """
+    tracer_warning_filter = ("ignore", None, torch.jit.TracerWarning, None, 0)
+    # warnings.filters is typed as an immutable Sequence in typeshed but is a mutable
+    # list at runtime, so insert/remove are valid.
+    warnings.filters.insert(0, tracer_warning_filter)  # type: ignore[attr-defined]
+    yield
+    warnings.filters.remove(tracer_warning_filter)  # type: ignore[attr-defined]
+
+
+def assert_shape(tensor: Tensor, ref_shape: Sequence[int | None]) -> None:
+    """
+    Assert that the shape of a tensor matches the given list of integers.
+    None indicates that the size of a dimension is allowed to vary.
+    Performs symbolic assertion when used in torch.jit.trace().
+
+    Args:
+        - tensor (Tensor): The tensor to check the shape of.
+        - ref_shape (Sequence[int | None]): The expected shape of the tensor.
+
+    References:
+        - https://github.com/NVlabs/edm2/blob/main/torch_utils/misc.py
+    """
+
+    if tensor.ndim != len(ref_shape):
+        raise AssertionError(
+            f"Wrong number of dimensions: got {tensor.ndim}, expected {len(ref_shape)}"
+        )
+
+    for idx, (size, ref_size) in enumerate(zip(tensor.shape, ref_shape)):
+        if tensor.ndim != len(ref_shape):
+            raise AssertionError(
+                f"Wrong number of dimensions: got {tensor.ndim}, expected {len(ref_shape)}"
+            )
+
+        for idx, (size, ref_size) in enumerate(zip(tensor.shape, ref_shape)):
+            if ref_size is None:
+                pass
+            elif isinstance(ref_size, torch.Tensor):
+                with (
+                    _suppress_tracer_warnings()
+                ):  # as_tensor results are registered as constants
+                    torch._assert(
+                        torch.equal(torch.as_tensor(size), ref_size),
+                        f"Wrong size for dimension {idx}",
+                    )
+            elif isinstance(size, torch.Tensor):
+                with (
+                    _suppress_tracer_warnings()
+                ):  # as_tensor results are registered as constants
+                    torch._assert(
+                        torch.equal(size, torch.as_tensor(ref_size)),
+                        f"Wrong size for dimension {idx}: expected {ref_size}",
+                    )
+            elif size != ref_size:
+                raise AssertionError(
+                    f"Wrong size for dimension {idx}: got {size}, expected {ref_size}"
+                )
+
+
+def assert_same_shape(tensor: Tensor, ref_tensor: Tensor) -> None:
+    """Assert that two tensors have the same shape."""
+    assert_shape(tensor, ref_tensor.shape)
+
+
+def scatter_mean(zeros: Tensor, dim: int, index: Tensor, source: Tensor) -> Tensor:
+    """Scatter-mean aggregation, with an MPS-compatible fallback.
+
+    On non-MPS devices uses index_reduce (faster, in-place kernel).
+    On MPS, index_reduce is not implemented so falls back to scatter_add + count.
+
+    Equivalent to: zeros.index_reduce(dim, index, source, 'mean', include_self=False)
+
+    Args:
+        zeros: Pre-allocated zero tensor, shape (..., I, C). Will not be modified in-place.
+        dim: Dimension to scatter along. Must not be the last dimension.
+        index: 1D index tensor of shape (N,) mapping source positions to output positions.
+        source: Source tensor where size at `dim` equals N.
+
+    Returns:
+        Tensor of same shape as zeros.
+    """
+    if zeros.device.type != "mps":
+        return zeros.index_reduce(dim, index, source, "mean", include_self=False)
+
+    ndim = source.dim()
+    if dim < 0:
+        dim = ndim + dim
+
+    # Expand 1D index (N,) to match source shape (..., N, C)
+    shape = [1] * ndim
+    shape[dim] = index.shape[0]
+    idx = index.view(shape).expand_as(source)
+
+    # Sum source values into output positions
+    result = zeros.scatter_add(dim, idx, source)
+
+    # Count how many source values land in each output position.
+    # Take a single slice along the last dim to avoid allocating a full (N, C) ones tensor.
+    idx_count = idx[..., :1]  # (..., N, 1)
+    ones = torch.ones_like(source[..., :1])  # (..., N, 1)
+    count = torch.zeros(*zeros.shape[:-1], 1, device=zeros.device, dtype=zeros.dtype)
+    count = count.scatter_add(dim, idx_count, ones)  # (..., I, 1)
+
+    return result / count.clamp(min=1)
+
+
+def device_of(obj: Any) -> torch.device:
+    """Get the device of a PyTorch object, e.g. a `nn.Module` or a `Tensor`."""
+    if hasattr(obj, "device"):
+        return obj.device
+    elif hasattr(obj, "parameters"):
+        return next(obj.parameters()).device
+    else:
+        raise ValueError(f"Unsupported type: {type(obj)}")
+
+
+class Timer:
+    """
+    A simple timer class for measuring elapsed time.
+
+    This class provides functionality to start, stop, reset, and measure elapsed time.
+    It can optionally use CUDA or MPS synchronization barriers for more accurate timing
+    when working with GPU operations.
+
+    Attributes:
+        name_ (str): The name of the timer.
+        elapsed_ (float): The total elapsed time.
+        started_ (bool): Flag indicating if the timer is currently running.
+        start_time (float): The start time of the current timing session.
+        use_barrier (bool): Whether to use CUDA or MPS synchronization barriers.
+
+    Args:
+        name (str): The name of the timer.
+        use_barrier (bool, optional): Whether to use synchronization barriers. Defaults to True.
+    """
+
+    def __init__(self, name: str, use_barrier: bool = True):
+        self.name_ = name
+        self.elapsed_ = 0.0
+        self.started_ = False
+        self.start_time = time.time()
+        self.use_barrier = use_barrier
+
+    def start(self) -> None:
+        """Start the timer."""
+        assert not self.started_, f"timer {self.name_} has already been started"
+        if self.use_barrier and torch.cuda.is_available():
+            torch.cuda.synchronize()
+        elif self.use_barrier and torch.backends.mps.is_available():
+            torch.mps.synchronize()
+        self.start_time = time.time()
+        self.started_ = True
+
+    def stop(self) -> None:
+        """Stop the timer."""
+        assert self.started_, f"timer {self.name_} is not started"
+        if self.use_barrier and torch.cuda.is_available():
+            torch.cuda.synchronize()
+        elif self.use_barrier and torch.backends.mps.is_available():
+            torch.mps.synchronize()
+        self.elapsed_ += time.time() - self.start_time
+        self.started_ = False
+
+    def reset(self) -> None:
+        """Reset timer."""
+        self.elapsed_ = 0.0
+        self.started_ = False
+
+    def elapsed(self, reset: bool = True) -> float:
+        """Calculate the elapsed time."""
+        started_ = self.started_
+        # If the timing in progress, end it first.
+        if self.started_:
+            self.stop()
+        # Get the elapsed time.
+        elapsed_ = self.elapsed_
+        # Reset the elapsed time
+        if reset:
+            self.reset()
+        # If timing was in progress, set it back.
+        if started_:
+            self.start()
+        return elapsed_
+
+
+class Timers:
+    """
+    A collection of named Timer objects.
+
+    This class manages multiple Timer instances, allowing for easy creation,
+    starting, stopping, resetting, and querying of elapsed times for multiple timers.
+
+    Attributes:
+        timers (dict): A dictionary of Timer objects, keyed by their names.
+    """
+
+    def __init__(self) -> None:
+        self.timers: dict[str, Timer] = {}
+
+    def __call__(self, name: str, use_barrier: bool = True) -> Timer:
+        """Get or create a Timer object."""
+        if name not in self.timers:
+            self.timers[name] = Timer(name, use_barrier=use_barrier)
+        return self.timers[name]
+
+    def start(self, *names: str) -> None:
+        """Start the specified timers."""
+        for name in names:
+            self(name).start()
+
+    def stop(self, *names: str) -> None:
+        """Stop the specified timers."""
+        for name in names:
+            self.timers[name].stop()
+
+    def reset(self, *names: str) -> None:
+        """Reset the specified timers."""
+        for name in names:
+            self.timers[name].reset()
+
+    def elapsed(self, *names: str, reset: bool = True) -> dict[str, float]:
+        """Get the elapsed time for the specified timers."""
+        return {name: self.timers[name].elapsed(reset=reset) for name in names}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/weights.py

@@ -0,0 +1,274 @@
+"""Utils for loading weights from checkpoints."""
+
+import re
+from dataclasses import dataclass, field
+from enum import StrEnum, auto
+from os import PathLike
+
+import torch
+from beartype.typing import Any, Pattern
+from torch import nn
+
+from foundry.utils.ddp import RankedLogger
+
+ranked_logger = RankedLogger(__name__, rank_zero_only=True)
+
+
+class WeightLoadingError(Exception):
+    """Exception raised when there's an error loading weights."""
+
+    pass
+
+
+class WeightLoadingPolicy(StrEnum):
+    """Policy for handling weights when loading checkpoints."""
+
+    # Always keep default initialization, regardless of whether the parameter is in the checkpoint or shapes match
+    REINIT = auto()
+
+    # Always zero-initialize, regardless of whether the parameter is in the checkpoint or shapes match
+    ZERO_INIT = auto()
+
+    # Copy from checkpoint only when shapes match exactly, otherwise error
+    COPY = auto()
+
+    # Copy from checkpoint if tensors are the same rank, padding with zeros if shapes don't match exectly
+    COPY_AND_ZERO_PAD = auto()
+
+
+class _PatternPolicyMixin:
+    """Mixin for handling glob-to-regex pattern compilation and matching for parameter policies.
+
+    Patterns can use the following wildcards:
+        - * matches any sequence of characters
+        - ? matches any single character
+        - [abc] matches any character in the brackets
+        - . matches a literal dot
+
+    Examples:
+        - "model.*.weight" matches any weight parameter in the model
+        - "model.encoder?.weight" matches encoder1.weight, encoder2.weight, etc.
+        - "model.encoder[12].weight" matches encoder1.weight and encoder2.weight
+        - "model.encoder.*.bias" matches any bias parameter in encoder submodules
+    """
+
+    _compiled_patterns: dict[Pattern, Any]
+
+    @staticmethod
+    def _glob_to_regex(pattern: str) -> str:
+        # Convert glob pattern to regex string
+        return (
+            pattern.replace(".", r"\.")
+            .replace("*", ".*")
+            .replace("?", ".")
+            .replace("[", "[")
+            .replace("]", "]")
+        )
+
+    def _compile_patterns(self, policy_dict: dict[str, Any]) -> dict[Pattern, Any]:
+        compiled = {}
+        for pattern, value in list(policy_dict.items()):
+            if any(c in pattern for c in ["*", "?", "[", "]"]):
+                regex = self._glob_to_regex(pattern)
+                compiled[re.compile(f"^{regex}$")] = value
+        return compiled
+
+    def _get_policy_by_pattern(
+        self, param_name: str, policy_dict: dict[str, Any], default: Any
+    ) -> Any:
+        # Exact match first
+        if policy_dict and param_name in policy_dict:
+            return policy_dict[param_name]
+        # Pattern match
+        for pattern, value in self._compiled_patterns.items():
+            if pattern.match(param_name):
+                return value
+        return default
+
+
+@dataclass
+class WeightLoadingConfig(_PatternPolicyMixin):
+    """Configuration for handling weights when loading a checkpoint."""
+
+    default_policy: WeightLoadingPolicy | str = WeightLoadingPolicy.COPY
+    fallback_policy: WeightLoadingPolicy | str = WeightLoadingPolicy.REINIT
+    param_policies: dict[str, WeightLoadingPolicy | str] = field(default_factory=dict)
+    _compiled_patterns: dict[Pattern, WeightLoadingPolicy] = field(
+        default_factory=dict, repr=False
+    )
+
+    def __post_init__(self) -> None:
+        if isinstance(self.default_policy, str):
+            self.default_policy = WeightLoadingPolicy(self.default_policy)
+        if isinstance(self.fallback_policy, str):
+            self.fallback_policy = WeightLoadingPolicy(self.fallback_policy)
+        for key, value in self.param_policies.items():
+            if isinstance(value, str):
+                self.param_policies[key] = WeightLoadingPolicy(value)
+        self._compiled_patterns = self._compile_patterns(self.param_policies)
+
+    def get_policy(self, param_name: str) -> WeightLoadingPolicy:
+        policy = self._get_policy_by_pattern(
+            param_name, self.param_policies, self.default_policy
+        )
+        assert isinstance(policy, WeightLoadingPolicy)
+        return policy
+
+
+@dataclass
+class ParameterFreezingConfig(_PatternPolicyMixin):
+    """Configuration for freezing model parameters after loading weights.
+
+    Allows specifying which parameters to freeze (set requires_grad=False) by exact name or pattern.
+    Patterns use glob-style wildcards (*, ?).
+
+    Attributes:
+        param_policies: Dict mapping parameter names or patterns to True (freeze) or False (do not freeze).
+        freeze_by_default: Whether to freeze parameters not matched by any pattern (default: False).
+    """
+
+    param_policies: dict[str, bool] = field(default_factory=dict)
+    freeze_by_default: bool = False
+    _compiled_patterns: dict[Pattern, bool] = field(default_factory=dict, repr=False)
+
+    def __post_init__(self) -> None:
+        self._compiled_patterns = self._compile_patterns(self.param_policies)
+
+    def is_frozen(self, param_name: str) -> bool:
+        """Get whether a parameter is frozen according to the config."""
+        is_frozen = self._get_policy_by_pattern(
+            param_name, self.param_policies, self.freeze_by_default
+        )
+        assert isinstance(is_frozen, bool)
+        return is_frozen
+
+
+def freeze_parameters_with_config(
+    model: nn.Module, config: ParameterFreezingConfig, verbose: bool = True
+) -> None:
+    """Freeze (set requires_grad=False) or unfreeze parameters according to config.
+
+    Args:
+        model: The model whose parameters to freeze/unfreeze.
+        config: ParameterFreezingConfig specifying which parameters to freeze.
+        verbose: Whether to log which parameters have non-default policies applied.
+    """
+    for name, param in model.named_parameters():
+        is_frozen = config.is_frozen(name)
+        param.requires_grad = not is_frozen
+
+        if is_frozen != config.freeze_by_default and verbose:
+            ranked_logger.info(f"Non-default freezing applied to {name}: {is_frozen}")
+
+
+def load_weights_with_policies(
+    model: nn.Module,
+    ckpt: dict[str, torch.Tensor],
+    config: WeightLoadingConfig | None = None,
+) -> dict:
+    """Load checkpoint weights into model according to the specified configuration.
+
+    Allows for partial loading of weights and zero-initialization of mismatched and arbitrary parameters.
+
+    Args:
+        model: The model to load weights INTO. By default, all model weights are re-initialized; we overwrite
+            with the checkpoint weights where appropriate
+        ckpt: Dictionary mapping parameter names to tensors (loaded from checkpoint on disk)
+        config: Configuration for handling weight loading. If None, uses default config
+    Returns:
+        dict: The updated state_dict (not loaded into model yet)
+    """
+    if config is None:
+        # (Initialize default config if not provided)
+        config = WeightLoadingConfig()
+
+    current_state = model.state_dict()
+    updated_state = {}  # We will update this with the new weights
+
+    def _apply_policy(
+        name: str,
+        current_param: torch.Tensor,
+        checkpoint_param: torch.Tensor | None,
+        policy: WeightLoadingPolicy,
+    ) -> torch.Tensor:
+        """Apply a weight loading policy and return the resulting tensor.
+
+        Raises WeightLoadingError for any policy application failures.
+        """
+        if policy == WeightLoadingPolicy.REINIT:
+            # Keep original initialization
+            return current_param
+
+        elif policy == WeightLoadingPolicy.ZERO_INIT:
+            # Zero-initialize
+            return torch.zeros_like(current_param)
+
+        elif policy == WeightLoadingPolicy.COPY:
+            # Must have checkpoint param and shapes must match
+            if checkpoint_param is None:
+                raise WeightLoadingError(f"Parameter '{name}' not found in checkpoint")
+            if current_param.shape != checkpoint_param.shape:
+                raise WeightLoadingError(
+                    f"Shape mismatch for '{name}': model {current_param.shape} vs checkpoint {checkpoint_param.shape}"
+                )
+            return checkpoint_param
+
+        elif policy == WeightLoadingPolicy.COPY_AND_ZERO_PAD:
+            # Must have checkpoint param and same number of dimensions
+            if checkpoint_param is None:
+                raise WeightLoadingError(f"Parameter '{name}' not found in checkpoint")
+            if len(current_param.shape) != len(checkpoint_param.shape):
+                raise WeightLoadingError(
+                    f"Different dimensions for '{name}': model {len(current_param.shape)}D vs checkpoint {len(checkpoint_param.shape)}D"
+                )
+
+            # Copy where shapes match, zero-init the rest
+            new_param = torch.zeros_like(current_param)
+            slices = tuple(
+                slice(0, min(d_ckpt, d_current))
+                for d_ckpt, d_current in zip(
+                    checkpoint_param.shape, current_param.shape
+                )
+            )
+            new_param[slices] = checkpoint_param[slices]
+            return new_param
+
+    # ... loop through all named parameters in the model
+    for name, current_param in current_state.items():
+        # Get the policy for this parameter
+        policy = config.get_policy(name)
+
+        # Get the corresponding parameter from the checkpoint
+        checkpoint_param = ckpt.get(name, None)
+
+        try:
+            # Try to apply the primary policy
+            result = _apply_policy(name, current_param, checkpoint_param, policy)
+            updated_state[name] = result
+        except WeightLoadingError as e:
+            # Primary policy failed, try fallback
+            ranked_logger.warning(
+                f"Failed to apply policy: '{policy}' to '{name}': {str(e)}. Falling back to policy: '{config.fallback_policy}'."
+            )
+            # __post_init__ normalises fallback_policy from str to the enum.
+            fallback_policy = config.fallback_policy
+            assert isinstance(fallback_policy, WeightLoadingPolicy)
+            result = _apply_policy(
+                name, current_param, checkpoint_param, fallback_policy
+            )
+            updated_state[name] = result
+
+    return updated_state
+
+
+@dataclass
+class CheckpointConfig:
+    """Configuration for loading checkpoints.
+
+    TODO: Implement reset_scheduler and reset_ema
+    """
+
+    path: PathLike
+    reset_optimizer: bool = False
+    weight_loading_config: WeightLoadingConfig | None = None
+    parameter_freezing_config: ParameterFreezingConfig | None = None

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/xpu/__init__.py

@@ -0,0 +1,27 @@
+"""XPU utilities for Intel GPU support.
+
+XPU support in PyTorch is now native (torch.xpu.is_available()), but Lightning Fabric
+requires custom Accelerator, Strategy, and Precision plugins for proper XPU handling.
+
+These components are used directly (not via registry) when XPU is detected:
+- XPUAccelerator: Custom accelerator for XPU devices
+- SingleXPUStrategy: Strategy for single-device XPU training/inference
+- XPUMixedPrecision: Precision plugin with proper XPU autocast support
+
+Usage:
+    from foundry.utils.xpu import XPUAccelerator, SingleXPUStrategy, XPUMixedPrecision
+
+    # Check availability
+    if XPUAccelerator.is_available():
+        strategy = SingleXPUStrategy(precision_plugin=XPUMixedPrecision("bf16-mixed"))
+
+Note:
+    The FabricTrainer automatically uses these components when XPU is detected.
+    You typically don't need to use them directly unless customizing behavior.
+"""
+
+from .single_xpu_strategy import SingleXPUStrategy
+from .xpu_accelerator import XPUAccelerator
+from .xpu_precision import XPUMixedPrecision
+
+__all__ = ["SingleXPUStrategy", "XPUAccelerator", "XPUMixedPrecision"]

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/xpu/single_xpu_strategy.py

@@ -0,0 +1,47 @@
+"""Lightning Fabric strategy for single XPU device.
+
+https://docs.pytorch.org/docs/stable/notes/get_start_xpu.html
+"""
+
+import torch
+from lightning.fabric.plugins import CheckpointIO
+from lightning.fabric.plugins.precision import Precision
+from lightning.fabric.strategies import SingleDeviceStrategy
+from lightning.fabric.utilities.types import _DEVICE
+
+
+class SingleXPUStrategy(SingleDeviceStrategy):
+    """Strategy for training/inference on a single Intel XPU device.
+
+    This strategy extends SingleDeviceStrategy to properly handle XPU devices.
+    """
+
+    strategy_name = "xpu_single"
+
+    def __init__(
+        self,
+        device: _DEVICE = "xpu:0",
+        checkpoint_io: CheckpointIO | None = None,
+        precision_plugin: Precision | None = None,
+    ) -> None:
+        """Initialize the single XPU strategy.
+
+        Args:
+            device: The XPU device to use. Defaults to "xpu:0".
+            checkpoint_io: Plugin for checkpoint I/O.
+            precision_plugin: Plugin for precision handling (set via _precision property).
+
+        Raises:
+            RuntimeError: If XPU devices are not available.
+        """
+        if not (hasattr(torch, "xpu") and torch.xpu.is_available()):
+            msg = "`SingleXPUStrategy` requires XPU devices to run"
+            raise RuntimeError(msg)
+
+        super().__init__(
+            device=device,
+            checkpoint_io=checkpoint_io,
+        )
+        # Precision is handled via the _precision property in newer Lightning versions
+        if precision_plugin is not None:
+            self._precision = precision_plugin

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/xpu/xpu_accelerator.py

@@ -0,0 +1,91 @@
+"""XPU Accelerator for Intel XPU devices."""
+
+from typing import Any
+
+import torch
+from lightning.fabric.accelerators import Accelerator
+
+
+class XPUAccelerator(Accelerator):
+    """Accelerator for Intel XPU devices.
+
+    This accelerator enables training and inference on Intel GPUs using
+    PyTorch's native XPU support (torch.xpu).
+    """
+
+    @staticmethod
+    def name() -> str:
+        """Return the name of this accelerator."""
+        return "xpu"
+
+    @staticmethod
+    def setup_device(device: torch.device) -> None:
+        """Set up the specified XPU device.
+
+        Args:
+            device: The torch device to set up.
+
+        Raises:
+            RuntimeError: If device is not an XPU device.
+        """
+        if device.type != "xpu":
+            msg = f"Device should be xpu, got {device} instead"
+            raise RuntimeError(msg)
+
+        torch.xpu.set_device(device)
+
+    @staticmethod
+    def parse_devices(devices: str | list | torch.device) -> list:
+        """Parse devices specification for XPU training.
+
+        Args:
+            devices: Device specification (int, list of ints, or string).
+
+        Returns:
+            List of device indices.
+        """
+        if isinstance(devices, list):
+            return devices
+        return [devices]
+
+    @staticmethod
+    def get_parallel_devices(devices: list) -> list[torch.device]:
+        """Generate a list of parallel XPU devices.
+
+        Args:
+            devices: List of device indices.
+
+        Returns:
+            List of torch.device objects for XPU.
+        """
+        return [torch.device("xpu", idx) for idx in devices]
+
+    @staticmethod
+    def auto_device_count() -> int:
+        """Return the number of available XPU devices."""
+        return torch.xpu.device_count()
+
+    @staticmethod
+    def is_available() -> bool:
+        """Check if XPU is available."""
+        return hasattr(torch, "xpu") and torch.xpu.is_available()
+
+    @staticmethod
+    def get_device_stats(device: str | torch.device) -> dict[str, Any]:
+        """Return XPU device statistics.
+
+        Currently returns an empty dict as XPU stats API may vary.
+
+        Args:
+            device: The device to get stats for.
+
+        Returns:
+            Dictionary of device statistics.
+        """
+        del device  # Unused
+        return {}
+
+    def teardown(self) -> None:
+        """Clean up XPU accelerator resources."""
+        # Empty implementation required by base class
+        pass

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/utils/xpu/xpu_precision.py

@@ -0,0 +1,72 @@
+"""XPU Precision Plugin for Lightning Fabric."""
+
+from contextlib import contextmanager
+from typing import Any, Generator, Literal
+
+import torch
+from lightning.fabric.plugins.precision import MixedPrecision
+from torch import Tensor
+
+
+class XPUMixedPrecision(MixedPrecision):
+    """Mixed precision plugin for Intel XPU devices.
+
+    This overrides the default MixedPrecision plugin to use 'xpu' as the
+    device type for torch.autocast instead of 'cuda'.
+    """
+
+    def __init__(
+        self,
+        precision: Literal["16-mixed", "bf16-mixed"] = "bf16-mixed",
+    ) -> None:
+        """Initialize XPU mixed precision.
+
+        Args:
+            precision: The precision mode. "16-mixed" uses float16,
+                "bf16-mixed" uses bfloat16. Defaults to "bf16-mixed".
+
+        Raises:
+            ValueError: If precision is not "16-mixed" or "bf16-mixed".
+        """
+        # Determine dtype from precision string
+        if precision == "16-mixed":
+            dtype = torch.float16
+        elif precision == "bf16-mixed":
+            dtype = torch.bfloat16
+        else:
+            msg = f"Invalid precision: {precision}. Must be '16-mixed' or 'bf16-mixed'"
+            raise ValueError(msg)
+
+        # Initialize with xpu device type
+        super().__init__(precision=precision, device="xpu")
+        self._desired_input_dtype = dtype
+
+    @contextmanager
+    def forward_context(self) -> Generator[None, None, None]:
+        """Context manager for forward pass with XPU autocast."""
+        with torch.autocast(device_type="xpu", dtype=self._desired_input_dtype):
+            yield
+
+    def convert_input(self, data: Any) -> Any:
+        """Convert input data to the appropriate precision.
+
+        Args:
+            data: Input data to convert.
+
+        Returns:
+            Converted data.
+        """
+        return self._convert_fp_tensor(data)
+
+    def _convert_fp_tensor(self, data: Any) -> Any:
+        """Convert floating point tensors to the desired dtype.
+
+        Args:
+            data: Data to convert.
+
+        Returns:
+            Converted data if it's a floating point tensor, otherwise unchanged.
+        """
+        if isinstance(data, Tensor) and data.is_floating_point():
+            return data.to(self._desired_input_dtype)
+        return data

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3/src/foundry/version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '0.0.1.dev1+gb02eed6a6.d20260916'
+__version_tuple__ = version_tuple = (0, 0, 1, 'dev1', 'gb02eed6a6.d20260916')
+
+__commit_id__ = commit_id = None

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3_collect.py

@@ -0,0 +1,247 @@
+#!/usr/bin/env python
+"""Convert RFdiffusion3 inference output into a protein-design submission.
+
+Pairs with `rfd3_inputs.py`: that builds the specs, `rfd3 design` runs upstream
+inference, this turns the result back into what the grader reads. View-agnostic -
+it works on fit, tune or the evaluation view alike.
+
+RFD3 writes one gzipped mmCIF per design, holding everything it was given: the designed
+chain, the fixed target chain for a binder, and the ligand. The task's grader wants the
+opposite - one PDB per design containing ONLY the designed chain, exactly
+`design_length` residues, every atom name valid for its residue in the atom14 table
+(`tests/geometry.py::parse_allatom_pdb`) - plus a `<track>.jsonl` index.
+
+For the enzyme track it also wants `motif_map`: which design position each motif residue
+landed on. That is the whole point of the unindexed setting - the model chooses - so the
+mapping is recovered from the output by matching the motif's fixed atoms, which RFD3
+holds at noise level zero and therefore reproduces exactly.
+"""
+
+import argparse
+import gzip
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+# The starter's `residues.py` is asserted byte-identical to the grader's
+# (tests/test_task.py::test_starter_and_grader_share_one_atom14_table), so the
+# atom14 table used to write a submission is the one used to read it back.
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from residues import ATOM14, ATOM14_WIDTH, atom_slot          # noqa: E402
+
+BACKBONE = (0, 1, 2, 3)
+
+
+def read_cif(path):
+    """Parse one RFD3 output into per-chain residue lists.
+
+    Returns {chain: [(residue_number, residue_name, {atom_name: (x, y, z)}), ...]}.
+    """
+    from biotite.structure.io.pdbx import CIFFile, get_structure
+    with gzip.open(path, "rt") as handle:
+        structure = get_structure(CIFFile.read(handle), model=1)
+    chains = {}
+    for atom in structure:
+        if atom.element == "H":
+            continue
+        key = str(atom.chain_id)
+        residues = chains.setdefault(key, {})
+        entry = residues.setdefault(int(atom.res_id), [str(atom.res_name), {}])
+        entry[1][str(atom.atom_name)] = tuple(float(value) for value in atom.coord)
+    return {chain: [(number, *residues[number]) for number in sorted(residues)]
+            for chain, residues in chains.items()}
+
+
+def design_chain(chains, design_length):
+    """The designed chain is the amino-acid chain with exactly `design_length` residues.
+
+    Cheap and unambiguous: a binder's target chain is a different length by construction,
+    and the ligand is not an amino-acid chain at all.
+    """
+    candidates = [(chain, residues) for chain, residues in chains.items()
+                  if len(residues) == design_length
+                  and all(name in ATOM14 for _, name, _ in residues)]
+    if len(candidates) != 1:
+        raise ValueError(f"expected one chain of {design_length} residues, "
+                         f"found {[(c, len(r)) for c, r in chains.items()]}")
+    return candidates[0][1]
+
+
+def to_atom14(residues):
+    """[L, 14, 3] coordinates and an [L, 14] mask, dropping atoms atom14 has no slot for."""
+    length = len(residues)
+    coordinates = np.zeros((length, ATOM14_WIDTH, 3))
+    mask = np.zeros((length, ATOM14_WIDTH), dtype=bool)
+    names = []
+    for index, (_, residue_name, atoms) in enumerate(residues):
+        names.append(residue_name)
+        for atom, position in atoms.items():
+            slot = atom_slot(residue_name, atom)
+            if slot is None:                 # OXT, virtual slots, anything non-atom14
+                continue
+            coordinates[index, slot] = position
+            mask[index, slot] = True
+    return coordinates, mask, names
+
+
+def recover_motif_map(metadata, names, context, coordinates, mask):
+    """Which design residue each motif position landed on.
+
+    Upstream reports this itself: the output metadata carries `diffused_index_map`,
+    input residue -> output residue, which for an unindexed motif is precisely the
+    placement decision the model made. The context lists its motif residues in the same
+    order as the spec's `unindex` field, and the result is checked against the residue
+    identities before it is trusted; if anything disagrees, fall back to matching the
+    motif's own atoms in the output.
+    """
+    motif_types = [str(name) for name in context["motif_restypes"]]
+    index_map = metadata.get("diffused_index_map") or {}
+    unindexed = str(metadata.get("specification", {}).get("unindex", "")).split(",")
+    unindexed = [item.strip() for item in unindexed if item.strip()]
+    if len(unindexed) == len(motif_types) and index_map:
+        mapping = []
+        for source in unindexed:
+            target = lookup(index_map, source)
+            position = int("".join(c for c in str(target) if c.isdigit())) - 1 if target else -1
+            mapping.append(position)
+        if (all(0 <= position < len(names) for position in mapping)
+                and len(set(mapping)) == len(mapping)
+                and [names[position] for position in mapping] == motif_types):
+            return mapping
+    return match_motif_by_coordinates(coordinates, mask, names, context)
+
+
+def lookup(index_map, source):
+    """`diffused_index_map` keyed by input residue, tolerating upstream's truncation.
+
+    Upstream writes four-digit residue ids short - a motif residue `B1029` comes back as
+    the key `B102` - so an exact lookup silently misses and the design gets dropped.
+    Fall back to a prefix match, and only when it is unambiguous.
+    """
+    if source in index_map:
+        return index_map[source]
+    hits = [value for key, value in index_map.items()
+            if source.startswith(key) or key.startswith(source)]
+    return hits[0] if len(hits) == 1 else None
+
+
+def match_motif_by_coordinates(coordinates, mask, names, context):
+    """Fallback placement: the closest residue of the right identity, greedily assigned."""
+    motif = context["motif_coords"]
+    motif_mask = context["motif_mask"].astype(bool)
+    motif_types = [str(name) for name in context["motif_restypes"]]
+    scores = np.full((len(motif_types), len(names)), np.inf)
+    for i, residue_name in enumerate(motif_types):
+        shared = motif_mask[i][None, :] & mask                  # [L, 14]
+        for j in range(len(names)):
+            # A motif position carries only the atoms the context kept - for these
+            # benchmarks that is the 2-3 fixed tip atoms, NOT a whole backbone - so the
+            # overlap is whatever both sides have, and one atom is too few to place on.
+            if names[j] != residue_name or shared[j].sum() < 2:
+                continue
+            selected = shared[j]
+            difference = coordinates[j][selected] - motif[i][selected]
+            scores[i, j] = float(np.sqrt((difference ** 2).sum(axis=-1).mean()))
+    assignment, taken = [None] * len(motif_types), set()
+    for i in np.argsort(scores.min(axis=1)):
+        order = np.argsort(scores[i])
+        choice = next((int(j) for j in order
+                       if int(j) not in taken and np.isfinite(scores[i, j])), None)
+        if choice is None:
+            return None
+        assignment[int(i)] = choice
+        taken.add(choice)
+    return assignment
+
+
+def write_pdb(path, coordinates, mask, names, chain="A"):
+    """Canonical atom14 PDB, the same columns `tests/geometry.py` parses."""
+    lines, serial = [], 1
+    for index, residue_name in enumerate(names):
+        for slot, atom in enumerate(ATOM14[residue_name]):
+            if not mask[index, slot]:
+                continue
+            x, y, z = coordinates[index, slot]
+            lines.append(f"ATOM  {serial:>5d} {(' ' + atom):<4s} {residue_name:<3s} "
+                         f"{chain}{index + 1:>4d}    "
+                         f"{x:>8.3f}{y:>8.3f}{z:>8.3f}  1.00  0.00" + " " * 10
+                         + f"{atom[0]:>2s}")
+            serial += 1
+    lines.append("END")
+    path.write_text("\n".join(lines) + "\n")
+
+
+def outputs_for(track_dir, example):
+    """RFD3 names a design `<prefix><example>_<batch>_model_<i>.cif.gz`."""
+    return sorted(track_dir.glob(f"*{example}_*_model_*.cif.gz"))
+
+
+def collect(view, designs, out, tracks):
+    predictions = out / "predictions"
+    structures = predictions / "structures"
+    structures.mkdir(parents=True, exist_ok=True)
+    summary = {}
+
+    for track in tracks:
+        source = view / f"{track}.jsonl"
+        track_dir = designs / track
+        if not source.is_file() or not track_dir.is_dir():
+            continue
+        rows, kept, dropped = [], 0, {}
+        for line in source.read_text().splitlines():
+            if not line.strip():
+                continue
+            request = json.loads(line)
+            example, length = request["example_id"], int(request["design_length"])
+            context = dict(np.load(view / request["context_path"], allow_pickle=False))
+            records = []
+            for index, path in enumerate(outputs_for(track_dir, example)):
+                if index >= request["num_designs"]:
+                    break
+                try:
+                    residues = design_chain(read_cif(path), length)
+                    coordinates, mask, names = to_atom14(residues)
+                    if not mask[:, BACKBONE].all():
+                        raise ValueError("a residue is missing backbone atoms")
+                    record = {"design_index": index,
+                              "ranking_score": 1.0 - 0.01 * index,
+                              "structure_path": f"{example}-{index}.pdb"}
+                    if "motif_coords" in context:
+                        metadata = json.loads(path.with_suffix("").with_suffix(".json")
+                                              .read_text())
+                        motif_map = recover_motif_map(metadata, names, context,
+                                                      coordinates, mask)
+                        if motif_map is None:
+                            raise ValueError("could not locate the motif in the design")
+                        record["motif_map"] = motif_map
+                except (OSError, ValueError, KeyError) as error:
+                    dropped[str(error)[:90]] = dropped.get(str(error)[:90], 0) + 1
+                    continue
+                write_pdb(structures / record["structure_path"],
+                          coordinates, mask, names)
+                records.append(record)
+                kept += 1
+            rows.append({"example_id": example, "designs": records})
+        (predictions / f"{track}.jsonl").write_text(
+            "".join(json.dumps(row) + "\n" for row in rows))
+        summary[track] = {"targets": len(rows), "designs": kept, "dropped": dropped}
+        print(f"{track:15s} {len(rows):3d} targets, {kept:4d} designs"
+              + (f", dropped {dropped}" if dropped else ""))
+    (out / "collect.json").write_text(json.dumps(summary, indent=2) + "\n")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--view", required=True, type=Path)
+    parser.add_argument("--designs", required=True, type=Path)
+    parser.add_argument("--out", required=True, type=Path)
+    parser.add_argument("--tracks", nargs="*",
+                        default=["unconditional", "sm_binder", "ppi_binder", "enzyme"])
+    arguments = parser.parse_args()
+    collect(arguments.view, arguments.designs, arguments.out, arguments.tracks)
+
+
+if __name__ == "__main__":
+    main()

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3_infer.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# Designs from a trained upstream-RFD3 checkpoint, in the task's submission format.
+#
+#   bash rfd3_infer.sh <ckpt> <view> <out> ["<tracks>"] [timesteps] [subset]
+#   bash rfd3_infer.sh /workspace/research/ckpt/epoch-0060.ckpt /data/tune /tmp/run
+#
+# Three stages, with upstream's inference untouched in the middle:
+#   rfd3_inputs.py   request .npz  -> RFD3 InputSpecification + a conditioning structure
+#   rfd3 design      upstream, unmodified. Reduced widths come from the checkpoint's own
+#                    `train_cfg`, so no config is repeated here.
+#   rfd3_collect.py  output mmCIF  -> one PDB per design plus <track>.jsonl
+#
+# Then score it yourself - scoring is unrestricted, see evaluation/README.md:
+#   python /workspace/evaluation/score.py --input <view> --designs <out>/submission
+#
+# That is the real designability metric; there is no geometry-only shortcut any more.
+#
+# Run that score from a normal working directory, NOT from /tmp: a phantom `matplotlib`
+# directory there makes torchmetrics believe matplotlib is installed and then fail on
+# `matplotlib.axes`. The full scorer imports rf3, so it inherits that trap.
+set -euo pipefail
+
+CKPT=${1:?checkpoint path}
+VIEW=${2:?input view directory, e.g. /data/tune}
+OUT=${3:?output directory}
+TRACKS=${4:-"unconditional sm_binder ppi_binder enzyme"}
+STEPS=${5:-200}
+# Optional comma-separated example ids, for a cheap smoke run. Passed to hydra as
+# a bracketed list: a bare `a,b` is rejected as an ambiguous value.
+SUBSET=${6:-}
+
+# Designs per target = N_BATCHES x 4 diffusion samples. The default 25 gives the 100
+# designs per target that every task view requests and that RFdiffusion3's own protocol
+# specifies - the same sample size behind the reference row in ../evaluation/RESULTS.md.
+# Lower it only for a quick smoke test: at 4 designs per target the sm_binder and
+# ppi_binder tracks return 0.000 whatever the model does, because their pass rates are a
+# few percent over 4 and 5 targets. Budget ~110 s per design for the full scorer on top
+# of generation.
+N_BATCHES=${N_BATCHES:-25}
+
+HERE=$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)
+
+# Dataloader workers bind an AF_UNIX socket under TMPDIR, and the path has a 108-char
+# limit; a deep scratch path silently breaks inference rather than erroring clearly.
+export TMPDIR=${TMPDIR:-/tmp}
+export PYTORCH_CUDA_ALLOC_CONF=${PYTORCH_CUDA_ALLOC_CONF:-expandable_segments:True}
+
+# `rfd3` is a console script installed by `pip install rc-foundry`. The image vendors
+# the SOURCE and reaches it through PYTHONPATH instead, so that script does not exist
+# there - invoke the same Typer app as a module when it is missing.
+run_rfd3() {
+  if command -v rfd3 >/dev/null 2>&1; then
+    rfd3 "$@"
+  else
+    python -c 'from rfd3.cli import app; app()' "$@"
+  fi
+}
+
+mkdir -p "$OUT"
+python "$HERE/rfd3_inputs.py" --view "$VIEW" --out "$OUT/inputs" --tracks $TRACKS
+
+for TRACK in $TRACKS; do
+  [ -f "$OUT/inputs/$TRACK.json" ] || { echo "-- $TRACK: no targets, skipping"; continue; }
+  echo "=== designing $TRACK ($((N_BATCHES * 4)) designs per target)"
+  # A batch is 4 diffusion samples, so N_BATCHES=25 gives the 100 designs per target every
+  # view requests while keeping peak memory at a single batch.
+  run_rfd3 design \
+    out_dir="$OUT/designs/$TRACK" \
+    inputs="$OUT/inputs/$TRACK.json" \
+    ckpt_path="$CKPT" \
+    n_batches="$N_BATCHES" \
+    diffusion_batch_size=4 \
+    inference_sampler.num_timesteps="$STEPS" \
+    skip_existing=True \
+    prevalidate_inputs=True \
+    ${SUBSET:+json_keys_subset=[$SUBSET]}
+done
+
+echo "=== collecting"
+python "$HERE/rfd3_collect.py" --view "$VIEW" --designs "$OUT/designs" \
+    --out "$OUT/submission" --tracks $TRACKS
+
+echo "=== done: $OUT/submission"

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/rfd3_inputs.py

@@ -0,0 +1,334 @@
+#!/usr/bin/env python
+"""Turn any protein-design input view into RFdiffusion3 inference specs.
+
+The task hands out a request as a `<track>.jsonl` row plus an `.npz` conditioning
+context. Upstream RFD3 wants an `InputSpecification`: an input structure, a contig, and
+selections over that structure. This script writes both - a conditioning structure
+rebuilt from the context, and the spec that points at it.
+
+It works on **fit and tune**, which is what an agent actually has: `docker-compose.yaml`
+mounts only `development`, so `/data/fit` and `/data/tune` are the whole world inside the
+container. That is the difference between this and `environment/evaluation/benchmark/make_inputs.py`, which
+reuses upstream's published benchmark specs and therefore only works on the evaluation
+view the verifier holds.
+
+    python rfd3_inputs.py --view /data/tune --out /workspace/research/inputs
+
+Then design with upstream inference, and convert back with `rfd3_collect.py`:
+
+    rfd3 design out_dir=... inputs=.../enzyme.json ckpt_path=... \
+        n_batches=25 diffusion_batch_size=4 prevalidate_inputs=True
+"""
+
+import argparse
+import json
+import sys
+from pathlib import Path
+
+import numpy as np
+
+sys.path.insert(0, str(Path(__file__).resolve().parent))
+from residues import ATOM14  # noqa: E402
+
+# Chains in the conditioning structure we write. The designed chain is generated, so it
+# is not in this file at all; these hold only what the request fixes.
+MOTIF_CHAIN = "A"
+TARGET_CHAIN = "B"
+# Each ligand needs its OWN chain: atomworks refuses two ligand residues on one chain
+# ("Multiple ligand residues on chain L ... set 'allow_ligand_on_existing_chain: true'
+# to restore the old behaviour"). 29 of the 41 enzyme targets carry 2 or 3 ligands, so
+# hand out successive letters from L, skipping the motif and target chains.
+LIGAND_CHAINS = [c for c in "LMNOPQRSTUVWXYZ" if c not in (MOTIF_CHAIN, TARGET_CHAIN)]
+
+
+def ligand_atom_names(code, elements):
+    """Name a ligand's atoms by embedding its element sequence into the CCD's.
+
+    The context stores ligand coordinates and elements but no atom names, and RFD3 needs
+    names that match the chemical component so bonds and the reference conformer resolve.
+    Materialization keeps deposition order, which follows the CCD, so for a fully
+    resolved ligand the names are just the CCD's heavy atoms in order (checked: 22 of 24
+    sampled ligands match element-for-element).
+
+    The other two had *fewer* atoms than the CCD - unresolved density, not a reordering -
+    so positional assignment would slip after the first gap. Embedding the observed
+    element sequence as a subsequence of the CCD's, earliest match first, handles both.
+    Returns None if no embedding exists, so the caller can skip the target rather than
+    invent chemistry.
+    """
+    from biotite.structure.info import residue as ccd_residue
+
+    try:
+        component = ccd_residue(code)
+    except Exception:  # noqa: BLE001 - an unknown code is a skip, not a crash
+        return None
+    heavy = [(str(atom.atom_name), str(atom.element).upper())
+             for atom in component if str(atom.element).upper() != "H"]
+    names, cursor = [], 0
+    for element in (str(e).upper() for e in elements):
+        while cursor < len(heavy) and heavy[cursor][1] != element:
+            cursor += 1
+        if cursor == len(heavy):
+            return None
+        names.append(heavy[cursor][0])
+        cursor += 1
+    return names
+
+
+def split_ligands(context):
+    """Un-concatenate a context's ligands into
+    (code, names, elements, coordinates, pinned) tuples.
+
+    `ingest_targets.py` stores ALL of a target's ligands in one flat array each -
+    `ligand_coords` and `ligand_elements` concatenated, with `ligand_ccd` and
+    `ligand_atom_counts` saying where the boundaries are. 29 of the 41 enzyme targets
+    carry more than one ligand (a cofactor plus a substrate, often plus a metal,
+    e.g. MG + ADP + 3PG), so reading `ligand_ccd[0]` and handing it the whole
+    element array asks the CCD for a component that explains every ligand at once. That
+    never embeds, so the target was silently skipped - which cost 29 of 41 enzyme
+    targets, i.e. the agent-facing path could reach only 12 of them.
+
+    Returns None if any ligand's names cannot be resolved, so the caller still skips
+    rather than inventing chemistry.
+    """
+    codes = [str(code) for code in context["ligand_ccd"]]
+    counts = [int(n) for n in context["ligand_atom_counts"]]
+    elements = [str(e) for e in context["ligand_elements"]]
+    coordinates = context["ligand_coords"]
+    # Prefer the deposition names the context carries. Reconstructing them from the CCD
+    # by element subsequence works but is a guess, and it cannot recover WHICH atoms
+    # upstream pins - see `ligand_fixed_mask` below. Older contexts lack both keys, so
+    # the CCD path stays as the fallback.
+    supplied = ([str(n) for n in context["ligand_atom_names"]]
+                if "ligand_atom_names" in context else None)
+    pinned = (context["ligand_fixed_mask"].astype(bool).tolist()
+              if "ligand_fixed_mask" in context else None)
+    ligands, offset = [], 0
+    for code, count in zip(codes, counts):
+        chunk = elements[offset:offset + count]
+        names = (supplied[offset:offset + count] if supplied is not None
+                 else ligand_atom_names(code, chunk))
+        if names is None:
+            return None
+        keep = (pinned[offset:offset + count] if pinned is not None
+                else [True] * len(names))
+        ligands.append((code, names, chunk, coordinates[offset:offset + count], keep))
+        offset += count
+    return ligands
+
+
+class PDBWriter:
+    """Minimal PDB writer - only the columns atomworks reads back."""
+
+    def __init__(self):
+        self.lines = []
+        self.serial = 1
+
+    def residue(self, chain, number, name, coordinates, mask, record="ATOM  "):
+        """One amino acid, written in atom14 slot order."""
+        for slot, atom in enumerate(ATOM14[name]):
+            if not mask[slot]:
+                continue
+            self.atom(chain, number, name, atom, coordinates[slot], atom[0], record)
+
+    def atom(self, chain, number, residue_name, atom_name, position, element,
+             record="ATOM  "):
+        x, y, z = (float(value) for value in position)
+        # PDB column rule: a one- or two-letter atom name starts in column 14, so it is
+        # padded with a leading space. Four-character names (none in atom14) start at 13.
+        field = atom_name if len(atom_name) >= 4 else f" {atom_name:<3s}"
+        self.lines.append(
+            f"{record}{self.serial:>5d} {field} {residue_name:>3s} "
+            f"{chain}{number:>4d}    "
+            f"{x:>8.3f}{y:>8.3f}{z:>8.3f}  1.00  0.00          {element:>2s}")
+        self.serial += 1
+
+    def write(self, path):
+        path.write_text("\n".join(self.lines + ["END"]) + "\n")
+
+
+def fixed_atom_names(name, mask):
+    """The atom14 atoms a context actually carries for one residue."""
+    return [atom for slot, atom in enumerate(ATOM14[name]) if mask[slot]]
+
+
+def build_enzyme(context, length, structure_path):
+    """Motif geometry with no positions: upstream's unindexed / guidepost setting.
+
+    The request says which catalytic residues exist and where they sit relative to each
+    other and the ligand, but not which design positions they occupy - that is the
+    model's decision, and `motif_map` reports it back. So every motif residue goes into
+    `unindex`, and `select_fixed_atoms` pins exactly the atoms the context supplies,
+    which for this benchmark is a few tip atoms per residue rather than a backbone.
+    """
+    writer = PDBWriter()
+    types = [str(name) for name in context["motif_restypes"]]
+    masks = context["motif_mask"].astype(bool)
+    fixed = {}
+    for index, name in enumerate(types):
+        number = index + 1
+        writer.residue(MOTIF_CHAIN, number, name, context["motif_coords"][index],
+                       masks[index])
+        fixed[f"{MOTIF_CHAIN}{number}"] = ",".join(fixed_atom_names(name, masks[index]))
+
+    # Every ligand, each as its own residue with its own CCD code. Upstream's published
+    # specs for these same targets use exactly this shape - `"ligand": "ADP,MG,3PG"`
+    # with one select_fixed_atoms key per code (see data/targets/enzyme/input.yaml).
+    ligands = split_ligands(context)
+    if ligands is None:
+        return None
+    for chain, (code, names, elements, coordinates, keep) in zip(LIGAND_CHAINS, ligands):
+        for atom, position, element in zip(names, coordinates, elements):
+            writer.atom(chain, 1, code, atom, position, element, record="HETATM")
+        # Only the atoms upstream's spec pins, not every atom present. Every atom is
+        # still written to the PDB - the ligand's geometry is the conditioning - but
+        # pinning all of them posed a different, more constrained problem than the
+        # published benchmark does.
+        selected = [atom for atom, wanted in zip(names, keep) if wanted]
+        fixed[code] = ",".join(selected or names)
+
+    writer.write(structure_path)
+    return {"dialect": 2, "input": str(structure_path),
+            "ligand": ",".join(ligand[0] for ligand in ligands),
+            "unindex": ",".join(f"{MOTIF_CHAIN}{i + 1}" for i in range(len(types))),
+            "length": f"{length}-{length}", "select_fixed_atoms": fixed}
+
+
+def build_sm_binder(context, length, structure_path):
+    """A bare ligand: build a chain around it, with no pocket template."""
+    writer = PDBWriter()
+    ligands = split_ligands(context)
+    if ligands is None:
+        return None
+    for chain, (code, names, elements, coordinates, _) in zip(LIGAND_CHAINS, ligands):
+        for atom, position, element in zip(names, coordinates, elements):
+            writer.atom(chain, 1, code, atom, position, element, record="HETATM")
+    writer.write(structure_path)
+    # All four shipped sm_binder targets are single-ligand, but the concatenation is the
+    # same, so this goes through split_ligands too rather than keeping a second code path
+    # that would break the first time a multi-ligand sm target appears.
+    return {"dialect": 2, "input": str(structure_path),
+            "ligand": ",".join(ligand[0] for ligand in ligands),
+            "contig": f"{length}-{length}", "select_fixed_atoms": True}
+
+
+def build_ppi_binder(context, length, structure_path):
+    """A fixed target chain plus hotspots the binder should contact.
+
+    The contig is `<designed>,/0,<target range>`: `/0` is upstream's chain break, so the
+    designed chain and the target are separate chains rather than one fused polymer.
+    """
+    writer = PDBWriter()
+    types = [str(name) for name in context["target_restypes"]]
+    masks = context["target_mask"].astype(bool)
+    # Gap-preserving residue numbers where the context carries them: a break in the
+    # target's numbering is real structure, and numbering it `index + 1` would assert
+    # that residues either side of an unresolved stretch are adjacent. The development
+    # views have no such gaps to preserve, so they number sequentially.
+    resnums = ([int(n) for n in context["target_resnums"]]
+               if "target_resnums" in context else list(range(1, len(types) + 1)))
+    for index, name in enumerate(types):
+        writer.residue(TARGET_CHAIN, resnums[index], name,
+                       context["target_coords"][index], masks[index])
+    writer.write(structure_path)
+
+    # One contig range per contiguous run, so the spec states the same range structure
+    # `input.yaml` does (`B0-47,B53-64,B104-165` -> `B1-48,B54-65,B105-166`).
+    ranges, start = [], 0
+    for index in range(1, len(resnums) + 1):
+        if index == len(resnums) or resnums[index] != resnums[index - 1] + 1:
+            ranges.append(f"{TARGET_CHAIN}{resnums[start]}-{resnums[index - 1]}")
+            start = index
+    target_contig = ",".join(ranges)
+
+    # Atom-level hotspots where the context carries them, matching `input.yaml`, which
+    # names exactly two sidechain atoms per hotspot. A contig string is accepted too,
+    # but `canonicalize_` expands it to EVERY atom of the residue, so the per-atom
+    # `is_atom_level_hotspot` feature would be set on ~8-11 atoms instead of 2. The
+    # development views built by materialize.py derive hotspots from coordinates and
+    # have no published atom selection, so they fall back to the token-level form.
+    if "hotspot_atoms" in context:
+        hotspots = {f"{TARGET_CHAIN}{resnums[int(i)]}": str(atoms)
+                    for i, atoms in zip(context["hotspot_indices"],
+                                        context["hotspot_atoms"])}
+    else:
+        hotspots = ",".join(f"{TARGET_CHAIN}{resnums[int(i)]}"
+                            for i in context["hotspot_indices"])
+    return {"dialect": 2, "input": str(structure_path),
+            "contig": f"{length}-{length},/0,{target_contig}",
+            "select_fixed_atoms": True, "select_hotspots": hotspots,
+            # NOT optional. With both `ori_token` and `infer_ori_strategy` unset,
+            # `set_com` (`rfd3/utils/inference.py`) falls through to "COM of fixed
+            # motif"; here the whole target chain IS the fixed motif, so the origin
+            # becomes the TARGET's centre of mass and the binder is diffused from
+            # inside it. Measured on a run that omitted this: median minimum
+            # binder-target atom distance 0.25-0.45 A on all five targets, binder COM
+            # 2.4-6.7 A from the target COM, ipTM 0.19 and pass rate 0/500 - the track
+            # was not measuring the model at all. `protein_binder_design.md` recommends
+            # "hotspots", which puts the origin 10 A along the outward normal from the
+            # hotspot centroid. `benchmark/standard/make_specs.py` has always set this;
+            # the graded path did not, which is the whole discrepancy on this track.
+            "infer_ori_strategy": "hotspots"}
+
+
+BUILDERS = {"enzyme": build_enzyme, "sm_binder": build_sm_binder,
+            "ppi_binder": build_ppi_binder}
+
+
+def build(view, out, tracks):
+    out.mkdir(parents=True, exist_ok=True)
+    structures = out / "conditioning"
+    structures.mkdir(exist_ok=True)
+    counts, skipped = {}, {}
+
+    for track in tracks:
+        if track != "unconditional" and track not in BUILDERS:
+            raise SystemExit(f"unknown track {track!r}; expected one of "
+                             f"unconditional, {', '.join(sorted(BUILDERS))}")
+        source = view / f"{track}.jsonl"
+        if not source.is_file():
+            continue
+        rows = [json.loads(line) for line in source.read_text().splitlines()
+                if line.strip()]
+        if not rows:
+            continue
+        specs = {}
+        for request in rows:
+            example = request["example_id"]
+            length = int(request["design_length"])
+            if track == "unconditional":
+                # A length is the whole request - no structure, nothing to condition on.
+                specs[example] = {"length": f"{length}-{length}"}
+                continue
+            context = dict(np.load(view / request["context_path"], allow_pickle=False))
+            spec = BUILDERS[track](context, length, structures / f"{example}.pdb")
+            if spec is None:
+                skipped[track] = skipped.get(track, 0) + 1
+                continue
+            specs[example] = spec
+        if specs:
+            (out / f"{track}.json").write_text(json.dumps(specs, indent=2) + "\n")
+            counts[track] = len(specs)
+    return counts, skipped
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
+    parser.add_argument("--view", required=True, type=Path,
+                        help="an input view directory: /data/fit or /data/tune")
+    parser.add_argument("--out", required=True, type=Path)
+    parser.add_argument("--tracks", nargs="*",
+                        default=["unconditional", "sm_binder", "ppi_binder", "enzyme"])
+    arguments = parser.parse_args()
+    counts, skipped = build(arguments.view, arguments.out, set(arguments.tracks))
+    for track, number in sorted(counts.items()):
+        note = f"  ({skipped[track]} skipped)" if track in skipped else ""
+        print(f"{track:15s} {number:3d} targets -> "
+              f"{arguments.out / (track + '.json')}{note}")
+    if not counts:
+        raise SystemExit(f"no targets found under {arguments.view}")
+
+
+if __name__ == "__main__":
+    main()

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/sampling.json

@@ -0,0 +1 @@
+{"timesteps": 24, "batch_size": 4, "step_scale": 1.5, "recycles": 1, "seed": 20261022}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/submission/training_record.json

@@ -0,0 +1,9 @@
+{
+  "optimizer_steps": 32,
+  "epoch": 0,
+  "weight_selection": "online",
+  "parameters": 12445554,
+  "training_corpus": "fit/structures",
+  "pretrained_weights": false,
+  "checkpoint_sha256": "e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779"
+}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/finalization/trajectory.jsonl

@@ -0,0 +1,48 @@
+{"type":"thread.started","thread_id":"01a1618d-8956-7b80-9cc4-d67245b7663a"}
+{"type":"item.completed","item":{"id":"item_0","type":"error","message":"`[features].use_legacy_landlock` is deprecated and will be removed soon. (Remove this setting to stop opting into the legacy Linux sandbox behavior.)"}}
+{"type":"turn.started"}
+{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"I’m stopping research and finalizing from the existing results. I’ll preserve the fully replayed trained-generator package: the later deployable experiments showed no measured improvement, and the hybrid’s required assets remain unavailable. I’ll use only static checks and atomic publication.\n"}}
+{"type":"item.started","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/harness.json'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.started","item":{"id":"item_3","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/RESULTS.md'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.started","item":{"id":"item_4","type":"command_execution","command":"/bin/sh -lc \"sed -n '1,240p' /workspace/baseline/rfd3-small/publish.py\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/harness.json'","aggregated_output":"{\n  \"schema\": \"protein-design-harness/v1\",\n  \"kind\": \"trained_generator\",\n  \"entry_point\": \"infer.sh\",\n  \"pretrained_assets\": [],\n  \"learned_components\": [\n    {\n      \"path\": \"generator.ckpt\",\n      \"sha256\": \"e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779\",\n      \"parameters\": 12445554,\n      \"trained_in_session\": true\n    }\n  ]\n}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_5","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/MEASUREMENTS.json'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_3","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/RESULTS.md'","aggregated_output":"# rfd3-small: results\n\nThe reproduced numbers for this baseline. The criteria behind them, the enzyme-target\ndistribution and the full write-up of how the graded and operator paths were reconciled are\nin [../../evaluation/RESULTS.md](../../evaluation/RESULTS.md).\n\n## What this baseline is\n\nUpstream RFdiffusion3, vendored at `rfd3/` from\n[RosettaCommons/foundry](https://github.com/RosettaCommons/foundry) `b02eed6a` and reduced in\n**layer widths only** to **12,445,554** parameters against upstream `pretrain`'s 168,038,994\n(7.4 %). Every depth is upstream's — 18 diffusion transformer blocks, 2 + 2 pairformer,\n3 + 3 atom encoder/decoder, `n_recycle` 2 — as are the crop, the losses, the AF-3\noptimizer/schedule and EMA. See [README.md](README.md) for the eight width leaves that change\nand how to run it.\n\n## Transfer (verifier, 51-target evaluation view)\n\nCheckpoint `epoch-0100.ckpt`, the real protocol of 51 targets × 100 designs.\n`conditioning_satisfied` is 100 % on all four tracks.\n\n| track | `pass_rate` | `diversity` | operator harness |\n|---|---:|---:|---:|\n| enzyme | 0.0624 | 0.341 | 0.054 |\n| sm_binder | 0.0275 | 0.750 | 0.030 |\n| ppi_binder | 0.002 | 0.200 | 0.004 |\n| unconditional | 0.420 | 1.000 | 0.410 |\n\nThe two paths agree within sampling noise, on counts of 12 vs 11, 1 vs 2, 220 vs 256 and\n41 vs 42 passing designs. Reaching that agreement required fixing five divergences in which\nthe graded path posed a different problem from the published specs; `input.yaml` is the source\nof truth and residue renumbering is the only licensed difference. The five are written up in\n[../../evaluation/RESULTS.md](../../evaluation/RESULTS.md).\n\n**This row is accepted from the task author's report rather than reproduced in this setup**,\nbecause the checkpoint is not distributable.\n\n## Anchors\n\n| system | enzyme | sm_binder | ppi_binder | unconditional |\n|---|---:|---:|---:|---:|\n| trivial generator (extended backbone, reduced view) | 0.000 | 0.000 | 0.000 | 0.000 |\n| `rfd3-small` above | 0.0624 | 0.0275 | 0.002 | 0.420 |\n\nThe trivial row is a **partial** null system: one target per track and two designs each, run\nthrough the real scorer, where nothing was designable on any track. The full\nnull row over all 51 targets is still open, and matters most on `enzyme`, where 28 of 41\ntargets score exactly 0.\n\n## Reading the numbers\n\n- `ppi_binder` is measurable, not good: 1 of 500 is not distinguishable from zero\n  (P(0 of 500 | true rate 0.004) ≈ 13 %). What the cross-check establishes is that the number\n  is produced by the model rather than by a spec bug, which was not true of any earlier run.\n- Thresholds come from RFdiffusion3's `success.txt`, which was calibrated with AlphaFold;\n  scoring here uses RoseTTAFold3. Numbers are internally comparable and **not** comparable with\n  the published table.\n- 5 designs of 5,100 never reached the grader, each carrying a single `UNK` residue that\n  `rfd3_collect.py` rejects. They count as failed designs, which shifts pass rates by ≤ 0.1 %.\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_4","type":"command_execution","command":"/bin/sh -lc \"sed -n '1,240p' /workspace/baseline/rfd3-small/publish.py\"","aggregated_output":"#!/usr/bin/env python3\n\"\"\"Publish a package directory to /workspace/submission atomically.\n\n    python /workspace/baseline/rfd3-small/publish.py SRC [--exclude GLOB ...] [--check]\n\nThe verifier may snapshot /workspace/submission at any moment, so the package must never be\nhalf-written. This copies SRC into a staging directory next to the target (training-only\nfiles excluded), optionally checks the harness manifest the way the verifier does, then swaps\nit in with one rename.\n\"\"\"\nimport argparse\nimport errno\nimport fnmatch\nimport os\nimport shutil\nimport sys\nimport tempfile\nfrom pathlib import Path\n\nDEFAULT_EXCLUDES = [\"__pycache__\", \"*.pyc\", \"*.ckpt.tmp\", \"optimizer.pt\", \"events.out.tfevents.*\"]\n\n\ndef ignore_for(source: Path, patterns: list[str]):\n    def ignore(directory: str, names: list[str]) -> set[str]:\n        relative = Path(directory).relative_to(source)\n        return {name for name in names\n                if any(fnmatch.fnmatch(name, p) or fnmatch.fnmatch((relative / name).as_posix(), p)\n                       for p in patterns)}\n    return ignore\n\n\ndef swap_into(staged: Path, final: Path) -> None:\n    old = final.with_name(f\".{final.name}.old-{os.getpid()}\")\n    if final.exists():\n        try:\n            os.replace(final, old)\n        except OSError as error:\n            # A directory from a lower image layer cannot be renamed on overlayfs (EXDEV): move\n            # its contents aside instead; the swap below is still a single rename.\n            if error.errno != errno.EXDEV:\n                raise\n            shutil.copytree(final, old, symlinks=True)\n            shutil.rmtree(final)\n    os.replace(staged, final)\n    shutil.rmtree(old, ignore_errors=True)\n\n\ndef main() -> None:\n    parser = argparse.ArgumentParser(description=__doc__.split(\"\\n\\n\")[0])\n    parser.add_argument(\"source\", type=Path)\n    parser.add_argument(\"--output\", type=Path, default=Path(\"/workspace/submission\"))\n    parser.add_argument(\"--exclude\", action=\"append\", default=[],\n                        help=f\"glob (name or path relative to SRC) to leave out; always excluded: {DEFAULT_EXCLUDES}\")\n    parser.add_argument(\"--check\", action=\"store_true\",\n                        help=\"validate harness.json against the staged copy, as the verifier does\")\n    args = parser.parse_args()\n    source, final = args.source.resolve(), args.output.resolve()\n    for required in (\"infer.sh\", \"harness.json\", \"README.md\"):\n        if not (source / required).is_file():\n            sys.exit(f\"{source} has no {required} (see /workspace/contract.md)\")\n    final.parent.mkdir(parents=True, exist_ok=True)\n    staged = Path(tempfile.mkdtemp(prefix=f\".{final.name}.stage-\", dir=final.parent))\n    try:\n        shutil.copytree(source, staged, symlinks=False, dirs_exist_ok=True,\n                        ignore=ignore_for(source, DEFAULT_EXCLUDES + args.exclude))\n        if args.check:\n            sys.path.insert(0, \"/workspace/evaluation/lib\")\n            from common import validate_harness  # the verifier's own check\n            validate_harness(staged, Path(\"/pretrained\"))\n        staged.chmod(0o755)\n        swap_into(staged, final)\n    except BaseException:\n        shutil.rmtree(staged, ignore_errors=True)\n        raise\n    print(f\"published {source} -> {final}\")\n\n\nif __name__ == \"__main__\":\n    main()\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_5","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/MEASUREMENTS.json'","aggregated_output":"{\n  \"protocol\": \"First-ID tune target per track; two emitted designs, twenty requested per target. Missing eighteen designs remain failures. Diagnostic screen, not a full-rate estimate.\",\n  \"checkpoint_steps\": 32,\n  \"weight_selection\": \"online\",\n  \"postprocessing\": \"input-frame restoration and residue-constrained unindexed motif assignment\",\n  \"tracks\": {\n    \"enzyme\": {\n      \"designs_requested\": 20,\n      \"designs_returned\": 2,\n      \"designs_valid\": 2,\n      \"designs_designable\": 0,\n      \"conditioning_satisfied\": 2,\n      \"failures\": {\n        \"not designable (scRMSD 26.27, ipTM 0.48, PAE 8.23, motif 21.95, no sequence satisfied the criterion)\": 1,\n        \"not designable (scRMSD 53.47, ipTM 0.38, PAE 9.65, motif 45.15, no sequence satisfied the criterion)\": 1\n      },\n      \"designs_novel\": 0,\n      \"pass_rate\": 0.0,\n      \"diversity\": 0.0,\n      \"invalid_reason\": null\n    },\n    \"ppi_binder\": {\n      \"conditioning_satisfied\": 2,\n      \"designs_designable\": 0,\n      \"designs_novel\": 0,\n      \"designs_requested\": 20,\n      \"designs_returned\": 2,\n      \"designs_valid\": 2,\n      \"diversity\": 0.0,\n      \"failures\": {\n        \"not designable (scRMSD 11.77, ipTM 0.21, PAE 14.18, no sequence satisfied the criterion)\": 1,\n        \"not designable (scRMSD 13.47, ipTM 0.11, PAE 19.94, no sequence satisfied the criterion)\": 1\n      },\n      \"invalid_reason\": null,\n      \"pass_rate\": 0.0\n    },\n    \"sm_binder\": {\n      \"conditioning_satisfied\": 2,\n      \"designs_designable\": 0,\n      \"designs_novel\": 0,\n      \"designs_requested\": 20,\n      \"designs_returned\": 2,\n      \"designs_valid\": 2,\n      \"diversity\": 0.0,\n      \"failures\": {\n        \"not designable (scRMSD 83.21, ipTM 0.27, PAE 12.71, ligRMSD 127.52, no sequence satisfied the criterion)\": 1,\n        \"not designable (scRMSD 83.58, ipTM 0.34, PAE 11.58, ligRMSD 38.29, no sequence satisfied the criterion)\": 1\n      },\n      \"invalid_reason\": null,\n      \"pass_rate\": 0.0\n    },\n    \"unconditional\": {\n      \"conditioning_satisfied\": 2,\n      \"designs_designable\": 0,\n      \"designs_novel\": 0,\n      \"designs_requested\": 20,\n      \"designs_returned\": 2,\n      \"designs_valid\": 2,\n      \"diversity\": 0.0,\n      \"failures\": {\n        \"not designable (scRMSD 10.85, ipTM 0.00, no sequence satisfied the criterion)\": 1,\n        \"not designable (scRMSD 11.00, ipTM 0.00, no sequence satisfied the criterion)\": 1\n      },\n      \"invalid_reason\": null,\n      \"pass_rate\": 0.0\n    }\n  }\n}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_6","type":"command_execution","command":"/bin/sh -lc \"sed -n '1,180p' /workspace/submission/README.md\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_6","type":"command_execution","command":"/bin/sh -lc \"sed -n '1,180p' /workspace/submission/README.md\"","aggregated_output":"# Shared all-atom conditional diffusion\n\nRun `bash infer.sh INPUT_ROOT OUTPUT_ROOT`. The package owns all imported model\nsource and its checkpoint; it needs the image's Python dependencies and one GPU.\nNo network, training corpus, external cache, or pretrained weights are used at\ninference. The exact checkpoint digest is in `harness.json`.\n\nOne 12,445,554-parameter RFdiffusion3 network serves every track. Unconditional\nrequests supply only length. Small-molecule requests supply a bare ligand. PPI\nrequests supply a target and hotspot features, with the diffusion origin near the\nhotspots. Enzyme requests supply unindexed catalytic residues and ligand atoms;\nRFD3 chooses motif placement during all-atom diffusion. All use the same network,\nfeaturization, losses, and sampler. There are no per-track models or retrieved folds.\n\nSource derives from the mounted rfd3-small starter (Foundry b02eed6a). RF3 source\nutilities are included because a shared logging module imports them. No RF3 or\nLigandMPNN checkpoint is included or used by the generator.\n\nThe model is initialized randomly and trained in this session on fit structures\nwith the upstream all-atom EDM and sequence losses, PPI conditioning enabled,\n128-token crops, eight noise draws per structure, one structure per optimizer\nstep, a 100-step warmup, and peak learning rate 0.001. Training uses one H100.\n`training_record.json` states the actual optimizer-step count and whether online\nor moving-average weights were exported. Optimizer state is excluded.\n\n`sampling.json` records sampler settings. The initial research candidate uses 24\ndiffusion steps and one recycle to make full-suite contract replay affordable.\nThe explicit diffusion-origin translation is restored before writing each design.\nGuidepost insertion is constrained to distinct generated protein residues, fixing\nan upstream atomwise-assignment failure. Generated coordinates outside the\ninserted guideposts are preserved; unknown sequence\nhead outputs are represented as glycine backbone atoms for inverse folding.\nEach request receives its requested sample count, unless a documented sample or\nrequest error occurs. Errors are written to the output's failures.jsonl and do not\nabort the remaining batch. Ranking is neutral (0.0); no native structures are used.\n\nLimitations: the initial 32-step checkpoint is a pipeline smoke test, not a claim\nof designability or improvement over the reported reference. Contract replay and\nscientific evaluation are separate. Only the official LigandMPNN/RoseTTAFold3\ncriteria plus Foldseek novelty establish passing designs. The initial\nmeasured screen has zero passing designs on every track (two designs emitted and\ntwenty requested per target); see MEASUREMENTS.json. This is a diagnostic screen,\nnot a full-rate estimate. Early training is severely underfit.\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_7","type":"command_execution","command":"/bin/sh -lc \"rg -n '240|replay|check_package' /workspace/research/NOTES.md | head -n 28\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_7","type":"command_execution","command":"/bin/sh -lc \"rg -n '240|replay|check_package' /workspace/research/NOTES.md | head -n 28\"","aggregated_output":"39:The first full replay was intentionally interrupted to restart with the fix.\n43:Full replay is running before atomic initial publication. Concurrent training\n77:The 240-request replay passed all unconditional, small-molecule and PPI requests,\n84:in place; this does not rebuild the generated chain. Targeted replay covers the\n86:the required full replay.\n88:The independent length-boundary replay (40 and 400 residues for all tracks, one\n91:Targeted motif regression replay passed 4/4 requests with two valid samples each.\n92:The preceding full replay finished 232/240; all eight failures were enzyme motif\n93:assignment failures. A fresh full replay of the corrected package is running.\n134:Corrected full replay passed 240/240 tune requests, two designs each. Supplied\n171:004 (160 steps, 200 sampler steps) scored 0/20 on every track, 2 emitted each; no improvement over 24 steps. PPI RMSD 5.88/infinite with high PAE; enzyme both raw ligand clashes. 002 training finished all 928 steps and saved epoch-0007. The running shell reported a trailing parse error because its script was edited while running; checkpoint saved normally, current script passes bash -n. Exported 005 online928, sampler24, and replayed smoke4/4; official screen now running.\n306:Queued matched ONLINE 5,024-step screens 025-shortcrop5024 and 026-fullcrop5024 in session 4328, log 025-026-workflow.log. They wait for each epoch0039 saved marker, use the same 200-step sampler and the existing two-design/four-track panel, and never publish automatically. Training orchestration remains session 48099. Required full 240-request replay still precedes any future publication.\n346:The slow fit8er8 transform was a quadratic missing-central-atom loop in util_transforms.py, not RDKit or CIF parsing. Replaced with grouped reduction/expansion preserving the original fast path.34equivalence cases against pinned baseline matched retained atom IDs and coordinates; exact captured RNG/sample replay processed151360->59200atoms in~.11s, full dataset item5.318s. Both arms resumed their epoch36/global4640states with the fixed source and traced loader, active session76756. Old processes stopped cleanly; original orchestration48099exit1 and firstshortrecovery44899exit143 are intentional historical interruptions. New resultswillbe023-024-filter-recovery-results.json. Both realtrainers completed formerlystuck8er8 in4.55/4.93s.025/026queued screenpaths unchanged.\n430:Reference source defaults use2400examples/epoch,3accumulation passes and16noise draws/example; current research blocks use128examples/epoch,1pass and8draws. Epoch labels are not comparable. The5024-step research parent has5024training examples and40192noise draws in its optimizer history (examples can repeat structures). These reference defaults do NOT establish the actual exposure used for the author's accepted results; no baseline reproduction performed. Reporttraining-exposure-context.json. This supports planning a sustained continuation after recipe selection rather than treating a short pilot as a converged model.\n434:All old processes were confirmed absent; H100 idle. Operator reported158078researchsecondsremaining. Credentials were not inspected. 030compact saved6048/epoch47; final checkpoint hasfiniteweights, Adamcounter6048 andLR.001, SHA04a4d066842bc60f18fb9a6f163153d11b71a7e7bf01d6dade5ff8c26ffaa1d5. Exitstatuswasnotpersisted. 029control resumes5792/epoch45->6048 innewsession27677; preservedcheckpointSHA507b9804200f2fa8d6a8051181830dcdcc9b85b1672b7839b936f4804380e458. Onlycontrolgetsnewworker-RNGreset; unsavedupdatesreplay. Record029-030-second-pause-recovery.json.\n452:Operator reported157031researchseconds remaining. Old research processes confirmed absent, H100 idle; credentials not inspected. Both034/035 were interrupted at epoch48/batch100 before any new checkpoint. Restarted both from original verified6048states with their exact recorded commands, preserving matched loader reset and replaying unsaved updates. Session5207; recover_third_pause.py train;034-035-third-pause-recovery.json. Completed029/030 and denoising diagnostics are retained.\n705:Prepared a separate research ablation of the SAME generator: one frozen inverse-fold/refold projection, shared by allfourtracks. Session32255 runs run_refinement_probe.py, waits041summary, then takes official-scoring.lock so it cannot overlap another instrument job. Name046-shared-refold9120, log046-workflow.log. It holds041's eight generated seeds fixed, uses the first of4MPNN sequences(T.1,seed37), oneRF3prediction at independent seed20261024, and restores the supplied conditioning frame. Failed/invalid refolds fall back to the unchanged seed. Then contracts and the UNCHANGED official four-track score run with20requested/target and ALLfit novelty. It is a retained-output ablation, not a published/replayable hybrid package.\n709:Assetprovenance inrefinement-asset-proposal.json includes exactSHA256,licenses androles forRF3 andbothMPNN checkpoints. /pretrained remainsEMPTY. Using /assets is permitted for this research probe, but a hybrid CANNOTbe published under the current asset store. No weights copied/mounted and no harness/submission changed. Any future hybrid needs declared assets in/pretrained, live generator+refiner packaging, full240request replay, thenatomicpublication. Evaluation against the sameRF3checkpoint can inflate in-silico consistency; keep this recorded.\n759:Prepared but NOTexecuted: proposals/hybrid_design.py andbuild_hybrid_candidate.py. Theywould package livegenerationthenonepersistentfrozenrefiner,explicit/pretrainedassetsbydigest,noevaluationimports, no weightcopies/downloads, independentrequestfailurelogging/fallback. Builderrequires completedpositivefour-trackprobeandportableaudit; itdoesnotpublish orclaimfullreplay. Noassetsrequested/mounted yet, no draftcandidatebuilt. Fullcount054 and all240requestpackage replay remainnecessary before anypublicationdecision.\n789:Research asset adapter does NOT replace mandatory infer.sh full-tune replay.\n807:This is fresh live generator+refiner research, not /pretrained deployment replay.\n831:and mandatory full actual infer.sh replay. Operator question remains unanswered.\n866:records/31screens. Still research /assets adapter, NOTmandatorydeploymentreplay;\n984:CPU source/interface audit passed on all4tracks and repeated exactly: fixed supplied context, all preexisting feature tensors, global RNG and ground-truth metadata unchanged. Initial unindexed enzyme guideposts remain separate. Source hashes are frozen in060plan. Geometry-only audit spans40..400residues with correct alpha phi/psi and closed loops; none of this is a designability claim. 060runs actualinfer.sh on8samples, then officialall4score. Noautomaticpublication; anypositive needsbroadermeasurement/full240replay.\n998:Started audit_helical_tune_coverage.py(session65429), one procedural initialization perrequest acrossall240tune requests, CPUonly/no denoiser. Current83/240,zeroerrors. Purpose is catch unsupportedlength/context/layout cases whileofficialGPUscoringruns. This cannot replace actualinfer.sh fullreplay ordesignability. Perrequestjournal andfinalsummary retained separately. Existinghelical-prior-{length}-audit.npz geometry files preceded theCBvirtual-padding adjustment; their realbackbone atoms are unchanged. Finalinitializedinputs/sourcehashes are audited byhelical-initialization-audit.json and frozenin060plan.\n1006:The full CPU initialization sweep completed240/240 requests,0errors (session65429closed0), reporthelical-tune-initialization-coverage-summary.json; source hashes helical_prior.py762d51f1e9e42a3d471b09ccc82000cbf4e1478574f7885ed9868f18769800be andhelical_initialization.py41f32bbf4843a6fa79afd63259ed8f1d90191cd7897c55e910c4abb7307f7cbb. JournalSHAb32d691ea521d714975e7b8a386b1bc9c2355e874c0183439334320e8e8d0fea. This is initializationcoverage only, not learnedoutputvalidity/refolding/fullpackage replay. Largest input5035atoms (PPI4nee,design142). No deploymentchange.\n1016:Exportauditpassed807shadowtensors: exactequalitytosourceEMA, online/shadowprefixesaliasONEselectedstorage, finiteweights,nooptimizerstate. Comparedsource043packagechangesareonlygenerator.ckpt,harness.json,training_record.json,README.md,MEASUREMENTS.json. Docsnowdescribethisactualcandidate ratherthancopiedinitial32-stepstate. LearnedcomponentSHA: 1f49387a77968081b613bcb7483802f180e21663ae669fb71b226ebf551caeb4. Planfreezesallfiles. Driverwillscoreall4tracks, write043-061-late-ema-result.json andrefreshindex, neverpublish. Fullactualtune replay remainsrequiredifselected.\n1018:Reference source reread confirmsdefault2400examples/epoch,16noise draws and3accumulationpasses; currentstudy16examples/epoch,8draws,1structure/update. Actualauthorreportexposurecannotbeinferredfromdefaultswithoutoperatorinvocation/reproductionlogs(whicharenotsupplied). Thisrepeats earliertraining-exposure-context.json conclusion; no baseline retrainingperformed. Do notcompareepochnumbersorclaimconvergencefromshortzero-passscreens.\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_8","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json\nfrom pathlib import Path\nr=Path('/workspace/research/experiments')\np=r/'094-teacher-data43280-recovery2-workflow.json';w=json.loads(p.read_text())\nprint(json.dumps({'workflow_error':w.get('error'),'finished_utc':w.get('finished_utc'),'stages':{k:{x:v.get(x) for x in ['returncode','started_utc','finished_utc']} for k,v in w['stages'].items()}},indent=2))\nfor name in ['095-teacher-data-control43280','096-teacher-data-control43280-broader','097-teacher-data43280','098-teacher-data43280-broader']:\n for p in sorted(r.glob(name+'*summary*')):\n  print(str(p));print(p.read_text()[:16000])\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_8","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nimport json\nfrom pathlib import Path\nr=Path('/workspace/research/experiments')\np=r/'094-teacher-data43280-recovery2-workflow.json';w=json.loads(p.read_text())\nprint(json.dumps({'workflow_error':w.get('error'),'finished_utc':w.get('finished_utc'),'stages':{k:{x:v.get(x) for x in ['returncode','started_utc','finished_utc']} for k,v in w['stages'].items()}},indent=2))\nfor name in ['095-teacher-data-control43280','096-teacher-data-control43280-broader','097-teacher-data43280','098-teacher-data43280-broader']:\n for p in sorted(r.glob(name+'*summary*')):\n  print(str(p));print(p.read_text()[:16000])\nPY\"","aggregated_output":"{\n  \"workflow_error\": \"KeyboardInterrupt('Workflow received signal 15')\",\n  \"finished_utc\": null,\n  \"stages\": {\n    \"training\": {\n      \"returncode\": null,\n      \"started_utc\": \"2026-10-26T14:49:10.254525+00:00\",\n      \"finished_utc\": null\n    }\n  }\n}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_9","type":"command_execution","command":"/bin/sh -lc \"sed -n '110,148p' /workspace/research/NOTES.md\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.started","item":{"id":"item_10","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/infer.sh'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_9","type":"command_execution","command":"/bin/sh -lc \"sed -n '110,148p' /workspace/research/NOTES.md\"","aggregated_output":"\n## Experiment 003: expose structured-fold conditioning at inference\n\nSame 160-step checkpoint, 24 diffusion steps, one recycle, and seed as experiment\n002 probe. The only inference change is `is_non_loopy: true` on every track.\nThis feature is supervised on 99% of training examples, while the omitted\ninference setting is represented by zero. All four tracks will be scored on the\nsame first-ID panel. This is independent of the pending bare-ligand training\nchange; the ongoing long training run remains on experiment 001's recipe.\n\nScoring helper now logs unmodified per-design and per-track verdicts as they\nfinish. Future invocations reuse an official Foldseek database of the immutable\nfit corpus, keyed by corpus_entries.json and the Foldseek executable digests.\nOnly resource use and logging change; the scoring functions, search flags,\nthresholds, requested-design denominators, and all novelty criteria are unchanged.\nThis cache is development-only and is not used by or copied into the package.\n\nCorrected-matcher 32-step enzyme rescore also finished 0/20 (0/2 emitted),\ndiversity 0. Motif RMSDs were 21.95 and 45.15 A. Current candidate measurements\ncombine that enzyme rescore with the unaffected three tracks from the first\nofficial screen, and are recorded explicitly in shared_rfd3/MEASUREMENTS.json.\n\n## First publication, 03:27 UTC\n\nCorrected full replay passed 240/240 tune requests, two designs each. Supplied\npublish.py --check atomically installed the 32-step package at /workspace/submission.\nPost-publication harness verification passed. Checkpoint sha256:\ne79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779.\nThis is a validated initial candidate; all four diagnostic pass rates remain zero.\nResearch continues with the live longer training and isolated non-loopy comparison.\n\n## Experiment 004: resolve sampler discretization\n\nSame 160-step online checkpoint and original omitted non-loopy flag as experiment\n002 probe. Change only diffusion timesteps 24 -> 200; recycling remains 1 and\nstep_scale remains 1.5. Early atom geometry may reflect a coarse sampler as well\nas undertraining. Generate the same four-track panel and score every affected\ntrack before drawing conclusions. The published package stays unchanged.\n\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_10","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/infer.sh'","aggregated_output":"#!/usr/bin/env bash\nset -euo pipefail\nif [[ $# -ne 2 ]]; then\n    echo 'usage: infer.sh INPUT_ROOT OUTPUT_ROOT' >&2\n    exit 2\nfi\nhere=\"$(cd \"$(dirname \"${BASH_SOURCE[0]}\")\" && pwd)\"\nexport PROJECT_ROOT=\"$here/rfd3\"\nexport PYTHONPATH=\"$here:$here/rfd3/src:$here/rfd3/models/rfd3/src:$here/rfd3/models/rf3/src\"\nexport OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1\nexport PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True\nexec python \"$here/design.py\" \"$1\" \"$2\"\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_11","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport json\nfor s in ['rf3/rf3_foundry_01_24_latest_remapped.ckpt','ligandmpnn_params/ligandmpnn_v_32_010_25.pt','ligandmpnn_params/proteinmpnn_v_48_020.pt']:\n print(json.dumps({'asset_id':s,'present':(Path('/pretrained')/s).is_file()}))\np=Path('/workspace/submission')\nprint('files',sum(1 for f in p.rglob('*') if f.is_file()))\nprint('bytes',sum(f.stat().st_size for f in p.rglob('*') if f.is_file()))\nprint('symlinks',[str(f.relative_to(p)) for f in p.rglob('*') if f.is_symlink()])\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_11","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport json\nfor s in ['rf3/rf3_foundry_01_24_latest_remapped.ckpt','ligandmpnn_params/ligandmpnn_v_32_010_25.pt','ligandmpnn_params/proteinmpnn_v_48_020.pt']:\n print(json.dumps({'asset_id':s,'present':(Path('/pretrained')/s).is_file()}))\np=Path('/workspace/submission')\nprint('files',sum(1 for f in p.rglob('*') if f.is_file()))\nprint('bytes',sum(f.stat().st_size for f in p.rglob('*') if f.is_file()))\nprint('symlinks',[str(f.relative_to(p)) for f in p.rglob('*') if f.is_symlink()])\nPY\"","aggregated_output":"{\"asset_id\": \"rf3/rf3_foundry_01_24_latest_remapped.ckpt\", \"present\": false}\n{\"asset_id\": \"ligandmpnn_params/ligandmpnn_v_32_010_25.pt\", \"present\": false}\n{\"asset_id\": \"ligandmpnn_params/proteinmpnn_v_48_020.pt\", \"present\": false}\nfiles 309\nbytes 52329451\nsymlinks []\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_12","type":"command_execution","command":"/bin/sh -lc \"rg --files --maxdepth 2 /workspace/research | rg '(package.*check|replay|check.*package|publication|publish)' | head -n 65\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_12","type":"command_execution","command":"/bin/sh -lc \"rg --files --maxdepth 2 /workspace/research | rg '(package.*check|replay|check.*package|publication|publish)' | head -n 65\"","aggregated_output":"/workspace/research/replay_recorded_verdicts.py\n/workspace/research/shared_rfd3/publish.py\n/workspace/research/__pycache__/replay_recorded_verdicts.cpython-311.pyc\n/workspace/research/experiments/054-071-live-replay-result.json\n/workspace/research/experiments/001-publish.log\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_13","type":"agent_message","text":"The saved workflow confirms the teacher experiment was interrupted before scoring, so it provides no measured replacement. I’m keeping the previously replayed model and correcting the package’s results document to report its own zero-pass development screen clearly, separately from the author’s baseline results.\n"}}
+{"type":"item.started","item":{"id":"item_14","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/training_record.json'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_14","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/submission/training_record.json'","aggregated_output":"{\n  \"optimizer_steps\": 32,\n  \"epoch\": 0,\n  \"weight_selection\": \"online\",\n  \"parameters\": 12445554,\n  \"training_corpus\": \"fit/structures\",\n  \"pretrained_weights\": false,\n  \"checkpoint_sha256\": \"e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779\"\n}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_15","type":"command_execution","command":"/bin/sh -lc \"rg -n 'workspace/research|/assets|/data|pretrained|torch.load|checkpoint' /workspace/submission/design.py /workspace/submission/shared_engine.py\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_15","type":"command_execution","command":"/bin/sh -lc \"rg -n 'workspace/research|/assets|/data|pretrained|torch.load|checkpoint' /workspace/submission/design.py /workspace/submission/shared_engine.py\"","aggregated_output":"rg: /workspace/submission/shared_engine.py: No such file or directory (os error 2)\n","exit_code":2,"status":"failed"}}
+{"type":"item.started","item":{"id":"item_16","type":"command_execution","command":"/bin/sh -lc \"rg --files --maxdepth 1 /workspace/research/experiments | rg '/001|check|validat' | head -n 70\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_16","type":"command_execution","command":"/bin/sh -lc \"rg --files --maxdepth 1 /workspace/research/experiments | rg '/001|check|validat' | head -n 70\"","aggregated_output":"/workspace/research/experiments/whole-crop-hydra-validation.log\n/workspace/research/experiments/023-checkpoint-stability-audit.json\n/workspace/research/experiments/export_checkpoint.py-failure.json\n/workspace/research/experiments/central-filter-validation.log\n/workspace/research/experiments/lr-resume-validation.log\n/workspace/research/experiments/059-071-live-checkpoint-fullcount-result.json\n/workspace/research/experiments/compact-assembly-config-validation.json\n/workspace/research/experiments/central-filter-validation.json\n/workspace/research/experiments/001-score.log\n/workspace/research/experiments/export_checkpoint.py-first-audit.json\n/workspace/research/experiments/034-035-short-epoch-validation.json\n/workspace/research/experiments/report-comparison-validation-036-037.json\n/workspace/research/experiments/001-smoke.log\n/workspace/research/experiments/001-motif-fixed.log\n/workspace/research/experiments/001-frame-infer.log\n/workspace/research/experiments/001-publish.log\n/workspace/research/experiments/001-contract.log\n/workspace/research/experiments/spec-check.log\n/workspace/research/experiments/001-boundaries.log\n/workspace/research/experiments/lr-resume-validation.json\n/workspace/research/experiments/001-current-enzyme-score.log\n/workspace/research/experiments/001-infer.log\n/workspace/research/experiments/001-contract-final.log\n/workspace/research/experiments/lr-resume-validation.ckpt\n/workspace/research/experiments/001-contract-fixed.log\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_17","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/research/experiments/001-publish.log'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.started","item":{"id":"item_18","type":"command_execution","command":"/bin/sh -lc 'tail -n 12 /workspace/research/experiments/001-contract-final.log'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_17","type":"command_execution","command":"/bin/sh -lc 'cat /workspace/research/experiments/001-publish.log'","aggregated_output":"published /run-state/workspace/research/shared_rfd3 -> /workspace/submission\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_18","type":"command_execution","command":"/bin/sh -lc 'tail -n 12 /workspace/research/experiments/001-contract-final.log'","aggregated_output":"03:26:57 INFO rfd3.engine: [rank: 0] Finished inference batch in 2.57 seconds.\nSERVED enzyme enzyme-5k18-0057: 2/2 in 3.3s\n03:26:58 WARNING atomworks.io: We can't fix formal charges without building from templates, as we need to know the true number of hydrogens bonded to a given atom, not the inferred number. This may lead to occasional inaccuracies after adding inter-residue bonds. To avoid this and fix formal charges, set `add_missing_atoms = True`.\n03:26:58 WARNING atomworks.io: The `extra_fields` argument will be ignored if there is no CIF file input.\n03:27:01 INFO rfd3.engine: [rank: 0] Finished inference batch in 2.44 seconds.\nSERVED enzyme enzyme-1v0c-0058: 2/2 in 3.2s\n03:27:01 WARNING atomworks.io: We can't fix formal charges without building from templates, as we need to know the true number of hydrogens bonded to a given atom, not the inferred number. This may lead to occasional inaccuracies after adding inter-residue bonds. To avoid this and fix formal charges, set `add_missing_atoms = True`.\n03:27:01 WARNING atomworks.io: The `extra_fields` argument will be ignored if there is no CIF file input.\n03:27:01 WARNING atomworks.ml.transforms.rdkit_utils: Initial conformer generation based on distance geometry failed. Successful: 0. Falling back to generating a conformer starting from random coordinates.\n03:27:04 INFO rfd3.engine: [rank: 0] Finished inference batch in 2.49 seconds.\nSERVED enzyme enzyme-5k04-0059: 2/2 in 3.3s\n240/240 requests have a valid design\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_19","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nfrom datetime import datetime,timezone\nimport hashlib,json,shutil\nsrc=Path('/workspace/submission'); root=Path('/workspace/finalization'); dst=root/'selected-package'\nroot.mkdir(parents=True,exist_ok=True)\nassert not dst.exists()\ndef sha(p):\n h=hashlib.sha256()\n with p.open('rb') as f:\n  for b in iter(lambda:f.read(1<<20),b''):h.update(b)\n return h.hexdigest()\ndef inventory(p):\n return {str(f.relative_to(p)):sha(f) for f in sorted(p.rglob('*')) if f.is_file() and '__pycache__' not in f.parts and f.suffix\"'!='\"'.pyc'}\nbefore=inventory(src)\nassert not any(p.is_symlink() for p in src.rglob('*'))\nassert before['generator.ckpt']=='e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779'\nshutil.copytree(src,dst,ignore=shutil.ignore_patterns('__pycache__','*.pyc'))\nassert inventory(dst)==before\nreplay=Path('/workspace/research/experiments/001-contract-final.log')\nlog=replay.read_text()\nassert '240/240 requests have a valid design' in log\nserved=[line for line in log.splitlines() if line.startswith('SERVED ')]\nassert len(served)==240 and all(': 2/2 ' in line for line in served)\n(dst/'RESULTS.md').write_text('''# Results for the submitted package\n\nThis package contains the 32-update, 12,445,554-parameter shared RFdiffusion3 model\nidentified in harness.json. These are its own development measurements.\n\n| Track | Pass rate | Diversity | Returned / requested |\n|---|---:|---:|---:|\n| unconditional | 0/20 | 0 | 2/20 |\n| sm_binder | 0/20 | 0 | 2/20 |\n| ppi_binder | 0/20 | 0 | 2/20 |\n| enzyme | 0/20 | 0 | 2/20 |\n\nEach row uses the first-ID tune target for that track. All eight emitted structures\nwere contract-valid, but none passed designability. The eighteen missing designs\nper target remain in the denominator. This small diagnostic screen is not a\nfull-output pass-rate estimate. MEASUREMENTS.json retains the detailed results.\n\nThe existing full check_package.py replay served all 240 tune requests with two\ndesigns each and reported 240/240 requests with a valid design. Contract replay\nestablishes invocation and output validity; it does not establish designability.\n\nLater completed deployable experiments did not demonstrate a pass-rate improvement.\nThe positive research hybrids require pretrained inference assets that are absent\nfrom /pretrained and were never fully replayed for deployment. The final teacher-data\ncontinuation was interrupted before its registered evaluations. None replaces this\npreviously replayed package during finalization.\n\nNo inference, evaluation, simulation or training was run in the submission-only\nwindow. Only documentation was updated; model weights, inference source, sampler\nand harness are unchanged. FINALIZATION.json records static verification and the\nexisting replay evidence. Reported author-baseline numbers are not results of this\nsubmitted checkpoint.\n''')\np=dst/'README.md'\np.write_text(p.read_text()+'''\nFinal selection: this previously replayed package is retained using existing\nresearch results. Finalization changed documentation only. No new training,\ninference or evaluation was performed; see RESULTS.md and FINALIZATION.json.\n''')\nafter=inventory(dst)\nchanged=sorted(k for k in before if before[k]\"'!=after[k])\nassert changed==['\"'README.md','RESULTS.md']\nrecord={'utc':datetime.now(timezone.utc).isoformat(),'selected_kind':'trained_generator','checkpoint_sha256':before['generator.ckpt'],'checkpoint_optimizer_steps':32,'selection':'Retain the existing fully replayed portable package; no measured stronger deployable replacement is available.','scientific_method_changed':False,'weights_runtime_sampler_harness_unchanged':True,'changed_existing_files':changed,'new_training_inference_evaluations_simulations':0,'existing_replay':{'source':'research/experiments/001-contract-final.log','sha256':sha(replay),'requests':240,'served_two_designs_each':240,'valid_requests':240,'final_line':'240/240 requests have a valid design'},'existing_measurements_sha256':before['MEASUREMENTS.json'],'source_package_files_sha256':before,'finalization_policy':'Reuse existing replay evidence for unchanged scientific code and weights; current submission-only instruction prohibits a new replay.','pretrained_assets':[]}\n(dst/'FINALIZATION.json').write_text(json.dumps(record,indent=2)+'\\\\n')\n(root/'selected-package-files.json').write_text(json.dumps(inventory(dst),indent=2)+'\\\\n')\nprint(json.dumps({'staged':str(dst),'files':len(inventory(dst)),'changed_existing_files':changed,'checkpoint_sha256':before['generator.ckpt'],'existing_replay_valid_requests':240}))\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_19","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nfrom datetime import datetime,timezone\nimport hashlib,json,shutil\nsrc=Path('/workspace/submission'); root=Path('/workspace/finalization'); dst=root/'selected-package'\nroot.mkdir(parents=True,exist_ok=True)\nassert not dst.exists()\ndef sha(p):\n h=hashlib.sha256()\n with p.open('rb') as f:\n  for b in iter(lambda:f.read(1<<20),b''):h.update(b)\n return h.hexdigest()\ndef inventory(p):\n return {str(f.relative_to(p)):sha(f) for f in sorted(p.rglob('*')) if f.is_file() and '__pycache__' not in f.parts and f.suffix\"'!='\"'.pyc'}\nbefore=inventory(src)\nassert not any(p.is_symlink() for p in src.rglob('*'))\nassert before['generator.ckpt']=='e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779'\nshutil.copytree(src,dst,ignore=shutil.ignore_patterns('__pycache__','*.pyc'))\nassert inventory(dst)==before\nreplay=Path('/workspace/research/experiments/001-contract-final.log')\nlog=replay.read_text()\nassert '240/240 requests have a valid design' in log\nserved=[line for line in log.splitlines() if line.startswith('SERVED ')]\nassert len(served)==240 and all(': 2/2 ' in line for line in served)\n(dst/'RESULTS.md').write_text('''# Results for the submitted package\n\nThis package contains the 32-update, 12,445,554-parameter shared RFdiffusion3 model\nidentified in harness.json. These are its own development measurements.\n\n| Track | Pass rate | Diversity | Returned / requested |\n|---|---:|---:|---:|\n| unconditional | 0/20 | 0 | 2/20 |\n| sm_binder | 0/20 | 0 | 2/20 |\n| ppi_binder | 0/20 | 0 | 2/20 |\n| enzyme | 0/20 | 0 | 2/20 |\n\nEach row uses the first-ID tune target for that track. All eight emitted structures\nwere contract-valid, but none passed designability. The eighteen missing designs\nper target remain in the denominator. This small diagnostic screen is not a\nfull-output pass-rate estimate. MEASUREMENTS.json retains the detailed results.\n\nThe existing full check_package.py replay served all 240 tune requests with two\ndesigns each and reported 240/240 requests with a valid design. Contract replay\nestablishes invocation and output validity; it does not establish designability.\n\nLater completed deployable experiments did not demonstrate a pass-rate improvement.\nThe positive research hybrids require pretrained inference assets that are absent\nfrom /pretrained and were never fully replayed for deployment. The final teacher-data\ncontinuation was interrupted before its registered evaluations. None replaces this\npreviously replayed package during finalization.\n\nNo inference, evaluation, simulation or training was run in the submission-only\nwindow. Only documentation was updated; model weights, inference source, sampler\nand harness are unchanged. FINALIZATION.json records static verification and the\nexisting replay evidence. Reported author-baseline numbers are not results of this\nsubmitted checkpoint.\n''')\np=dst/'README.md'\np.write_text(p.read_text()+'''\nFinal selection: this previously replayed package is retained using existing\nresearch results. Finalization changed documentation only. No new training,\ninference or evaluation was performed; see RESULTS.md and FINALIZATION.json.\n''')\nafter=inventory(dst)\nchanged=sorted(k for k in before if before[k]\"'!=after[k])\nassert changed==['\"'README.md','RESULTS.md']\nrecord={'utc':datetime.now(timezone.utc).isoformat(),'selected_kind':'trained_generator','checkpoint_sha256':before['generator.ckpt'],'checkpoint_optimizer_steps':32,'selection':'Retain the existing fully replayed portable package; no measured stronger deployable replacement is available.','scientific_method_changed':False,'weights_runtime_sampler_harness_unchanged':True,'changed_existing_files':changed,'new_training_inference_evaluations_simulations':0,'existing_replay':{'source':'research/experiments/001-contract-final.log','sha256':sha(replay),'requests':240,'served_two_designs_each':240,'valid_requests':240,'final_line':'240/240 requests have a valid design'},'existing_measurements_sha256':before['MEASUREMENTS.json'],'source_package_files_sha256':before,'finalization_policy':'Reuse existing replay evidence for unchanged scientific code and weights; current submission-only instruction prohibits a new replay.','pretrained_assets':[]}\n(dst/'FINALIZATION.json').write_text(json.dumps(record,indent=2)+'\\\\n')\n(root/'selected-package-files.json').write_text(json.dumps(inventory(dst),indent=2)+'\\\\n')\nprint(json.dumps({'staged':str(dst),'files':len(inventory(dst)),'changed_existing_files':changed,'checkpoint_sha256':before['generator.ckpt'],'existing_replay_valid_requests':240}))\nPY\"","aggregated_output":"{\"staged\": \"/workspace/finalization/selected-package\", \"files\": 310, \"changed_existing_files\": [\"README.md\", \"RESULTS.md\"], \"checkpoint_sha256\": \"e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779\", \"existing_replay_valid_requests\": 240}\n","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_20","type":"command_execution","command":"/bin/sh -lc 'python /workspace/baseline/rfd3-small/publish.py /workspace/finalization/selected-package --check'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_20","type":"command_execution","command":"/bin/sh -lc 'python /workspace/baseline/rfd3-small/publish.py /workspace/finalization/selected-package --check'","aggregated_output":"published /workspace/finalization/selected-package -> /workspace/submission\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_21","type":"agent_message","text":"The package has been atomically published to `/workspace/submission`. Its weights, inference code, sampler, and harness are unchanged from the package that passed the 240-request replay. I’m checking the published file digests now; no new inference or evaluation was run.\n"}}
+{"type":"item.started","item":{"id":"item_22","type":"command_execution","command":"/bin/sh -lc 'bash -n /workspace/submission/infer.sh'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_22","type":"command_execution","command":"/bin/sh -lc 'bash -n /workspace/submission/infer.sh'","aggregated_output":"","exit_code":0,"status":"completed"}}
+{"type":"item.started","item":{"id":"item_23","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport hashlib,json,stat\nroot=Path('/workspace/submission')\nexpected=json.loads(Path('/workspace/finalization/selected-package-files.json').read_text())\ndef sha(p):\n h=hashlib.sha256()\n with p.open('rb') as f:\n  for b in iter(lambda:f.read(1<<20),b''):h.update(b)\n return h.hexdigest()\nactual={str(p.relative_to(root)):sha(p) for p in sorted(root.rglob('*')) if p.is_file() and '__pycache__' not in p.parts and p.suffix\"'!='\"'.pyc'}\nassert actual==expected\nassert not any(p.is_symlink() for p in root.rglob('*'))\nassert all(p.stat().st_mode & stat.S_IROTH for p in root.rglob('*') if p.is_file())\nassert all(p.stat().st_mode & stat.S_IXOTH for p in [root,*[q for q in root.rglob('*') if q.is_dir()]])\nh=json.loads((root/'harness.json').read_text())\nassert h['pretrained_assets']==[]\nassert actual[h['learned_components'][0]['path']]==h['learned_components'][0]['sha256']\nreport={'published_package':'/workspace/submission','files_verified':len(actual),'static_checks':'passed','weights_runtime_sampler_harness_unchanged':True,'new_experiments':0,'checkpoint_sha256':h['learned_components'][0]['sha256']}\nPath('/workspace/finalization/publication-verification.json').write_text(json.dumps(report,indent=2)+'\\\\n')\nprint(json.dumps(report))\nPY\"","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_23","type":"command_execution","command":"/bin/sh -lc \"python - <<'PY'\nfrom pathlib import Path\nimport hashlib,json,stat\nroot=Path('/workspace/submission')\nexpected=json.loads(Path('/workspace/finalization/selected-package-files.json').read_text())\ndef sha(p):\n h=hashlib.sha256()\n with p.open('rb') as f:\n  for b in iter(lambda:f.read(1<<20),b''):h.update(b)\n return h.hexdigest()\nactual={str(p.relative_to(root)):sha(p) for p in sorted(root.rglob('*')) if p.is_file() and '__pycache__' not in p.parts and p.suffix\"'!='\"'.pyc'}\nassert actual==expected\nassert not any(p.is_symlink() for p in root.rglob('*'))\nassert all(p.stat().st_mode & stat.S_IROTH for p in root.rglob('*') if p.is_file())\nassert all(p.stat().st_mode & stat.S_IXOTH for p in [root,*[q for q in root.rglob('*') if q.is_dir()]])\nh=json.loads((root/'harness.json').read_text())\nassert h['pretrained_assets']==[]\nassert actual[h['learned_components'][0]['path']]==h['learned_components'][0]['sha256']\nreport={'published_package':'/workspace/submission','files_verified':len(actual),'static_checks':'passed','weights_runtime_sampler_harness_unchanged':True,'new_experiments':0,'checkpoint_sha256':h['learned_components'][0]['sha256']}\nPath('/workspace/finalization/publication-verification.json').write_text(json.dumps(report,indent=2)+'\\\\n')\nprint(json.dumps(report))\nPY\"","aggregated_output":"{\"published_package\": \"/workspace/submission\", \"files_verified\": 310, \"static_checks\": \"passed\", \"weights_runtime_sampler_harness_unchanged\": true, \"new_experiments\": 0, \"checkpoint_sha256\": \"e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779\"}\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_24","type":"agent_message","text":"Published [the package](/workspace/submission/README.md) atomically. Static checks passed; the existing replay validated all 240 requests. No new experiments were run.\n\nThe retained development screen recorded zero passing designs across all four tracks, documented in [RESULTS.md](/workspace/submission/RESULTS.md)."}}
+{"type":"turn.completed","usage":{"input_tokens":734107806,"cached_input_tokens":722095327,"cache_write_input_tokens":11692426,"output_tokens":3590214,"reasoning_output_tokens":1972465}}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/codex.stderr

@@ -0,0 +1,21 @@
+2026-10-22T03:02:48.457954Z ERROR codex_core::tools::router: error=apply_patch verification failed: invalid patch: multiple operations target /workspace/research/shared_rfd3/infer.sh
+2026-10-22T03:04:10.649595Z ERROR codex_core::tools::router: error=apply_patch verification failed: invalid patch: multiple operations target /workspace/research/shared_rfd3/README.md
+2026-10-22T03:27:49.631184Z ERROR codex_core::tools::router: error=apply_patch verification failed: Failed to find expected lines in /workspace/research/NOTES.md:
+enzyme result with the three unaffected initial track results. This is a small
+2026-10-22T03:35:19.900912Z ERROR codex_core::tools::router: error=apply_patch verification failed: Failed to find expected lines in /workspace/research/NOTES.md:
+More denoising steps alone
+2026-10-22T05:02:12.308861Z ERROR codex_models_manager::manager: failed to refresh available models: request timed out
+2026-10-24T22:45:04.291445Z ERROR codex_models_manager::manager: failed to refresh available models: request timed out
+2026-10-25T21:01:47.057633Z ERROR codex_models_manager::manager: failed to refresh available models: request timed out
+2026-10-26T03:34:26.766771Z ERROR codex_core::util: Custom tool call output is missing for call id: call_iGwMB7s1JRqPB4GvUyyVBt33
+2026-10-26T03:34:37.312604Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 7914
+2026-10-26T03:34:37.313294Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 5098
+2026-10-26T03:34:37.570868Z ERROR codex_core::util: Custom tool call output is missing for call id: call_iGwMB7s1JRqPB4GvUyyVBt33
+2026-10-26T03:34:49.764965Z ERROR codex_core::util: Custom tool call output is missing for call id: call_iGwMB7s1JRqPB4GvUyyVBt33
+2026-10-26T06:47:32.180947Z ERROR codex_core::util: Custom tool call output is missing for call id: call_QnECbXnGTJXAuzaqD01dc3dI
+2026-10-26T06:47:43.552606Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 38473
+2026-10-26T06:47:43.820806Z ERROR codex_core::util: Custom tool call output is missing for call id: call_QnECbXnGTJXAuzaqD01dc3dI
+2026-10-26T06:50:10.411194Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 38473
+2026-10-26T10:10:15.555933Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 44604
+2026-10-26T16:01:47.671801Z ERROR codex_core::session: failed to record rollout items: thread 01a1618d-8956-7b80-9cc4-d67245b7663a not found
+2026-10-26T16:02:31.003966Z ERROR codex_core::tools::router: error=write_stdin failed: Unknown process id 72390

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/preflight.jsonl

@@ -0,0 +1,8 @@
+{"type":"thread.started","thread_id":"01a177af-d7d2-7ea3-aeef-071dcf0fdca6"}
+{"type":"item.completed","item":{"id":"item_0","type":"error","message":"`[features].use_legacy_landlock` is deprecated and will be removed soon. (Remove this setting to stop opting into the legacy Linux sandbox behavior.)"}}
+{"type":"turn.started"}
+{"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"I’ll run the environment check.\n"}}
+{"type":"item.started","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc 'python /opt/speedrun/probe.py'","aggregated_output":"","exit_code":null,"status":"in_progress"}}
+{"type":"item.completed","item":{"id":"item_2","type":"command_execution","command":"/bin/sh -lc 'python /opt/speedrun/probe.py'","aggregated_output":"Environment variable CCD_MIRROR_PATH not set. Will not be able to use function requiring this variable. To set it you may:\n  (1) add the line 'export VAR_NAME=path/to/variable' to your .bashrc or .zshrc file\n  (2) set it in your current shell with 'export VAR_NAME=path/to/variable'\n  (3) write it to a .env file in the root of the atomworks.io repository\nEnvironment variable PDB_MIRROR_PATH not set. Will not be able to use function requiring this variable. To set it you may:\n  (1) add the line 'export VAR_NAME=path/to/variable' to your .bashrc or .zshrc file\n  (2) set it in your current shell with 'export VAR_NAME=path/to/variable'\n  (3) write it to a .env file in the root of the atomworks.io repository\n{\"gpu_name\": \"NVIDIA H100 80GB HBM3\", \"visible_gpus\": 1, \"cuda_ok\": true, \"imports_ok\": true, \"network_blocked\": true, \"ipv4_blocked\": true, \"ipv6_blocked\": true, \"unix_ipc_ok\": true, \"network_error\": \"[Errno 1] Operation not permitted\", \"task\": \"protein-design\", \"development_data_ok\": true, \"data_readonly\": true, \"development_mounts\": [\"fit\", \"tune\"], \"evaluation_roles_absent\": true, \"research_storage_free_bytes\": 8691251236864, \"cpu_affinity_count\": 180, \"atomic_exchange_ok\": true, \"gpu_device_access_isolated\": true, \"denied_gpu_device_count\": 0}\n","exit_code":0,"status":"completed"}}
+{"type":"item.completed","item":{"id":"item_3","type":"agent_message","text":"PREFLIGHT_OK"}}
+{"type":"turn.completed","usage":{"input_tokens":21846,"cached_input_tokens":10674,"cache_write_input_tokens":11166,"output_tokens":70,"reasoning_output_tokens":0}}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/sessions/2026/10/22/rollout-2026-10-22T03-00-28-01a1618d-8956-7b80-9cc4-d67245b7663a.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17607efe54a5c46e4ebd1d4bea366a536a5541d1cb9fdf8e35d20778d3208870
+size 111948226

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/logs/trajectory.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e63b4b1514bf173359b83072398cc301fd211beb74d8cb130606ca32a86b5189
+size 25933501

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Institute for Protein Design, University of Washington
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/MEASUREMENTS.json

@@ -0,0 +1,68 @@
+{
+  "protocol": "First-ID tune target per track; two emitted designs, twenty requested per target. Missing eighteen designs remain failures. Diagnostic screen, not a full-rate estimate.",
+  "checkpoint_steps": 32,
+  "weight_selection": "online",
+  "postprocessing": "input-frame restoration and residue-constrained unindexed motif assignment",
+  "tracks": {
+    "enzyme": {
+      "designs_requested": 20,
+      "designs_returned": 2,
+      "designs_valid": 2,
+      "designs_designable": 0,
+      "conditioning_satisfied": 2,
+      "failures": {
+        "not designable (scRMSD 26.27, ipTM 0.48, PAE 8.23, motif 21.95, no sequence satisfied the criterion)": 1,
+        "not designable (scRMSD 53.47, ipTM 0.38, PAE 9.65, motif 45.15, no sequence satisfied the criterion)": 1
+      },
+      "designs_novel": 0,
+      "pass_rate": 0.0,
+      "diversity": 0.0,
+      "invalid_reason": null
+    },
+    "ppi_binder": {
+      "conditioning_satisfied": 2,
+      "designs_designable": 0,
+      "designs_novel": 0,
+      "designs_requested": 20,
+      "designs_returned": 2,
+      "designs_valid": 2,
+      "diversity": 0.0,
+      "failures": {
+        "not designable (scRMSD 11.77, ipTM 0.21, PAE 14.18, no sequence satisfied the criterion)": 1,
+        "not designable (scRMSD 13.47, ipTM 0.11, PAE 19.94, no sequence satisfied the criterion)": 1
+      },
+      "invalid_reason": null,
+      "pass_rate": 0.0
+    },
+    "sm_binder": {
+      "conditioning_satisfied": 2,
+      "designs_designable": 0,
+      "designs_novel": 0,
+      "designs_requested": 20,
+      "designs_returned": 2,
+      "designs_valid": 2,
+      "diversity": 0.0,
+      "failures": {
+        "not designable (scRMSD 83.21, ipTM 0.27, PAE 12.71, ligRMSD 127.52, no sequence satisfied the criterion)": 1,
+        "not designable (scRMSD 83.58, ipTM 0.34, PAE 11.58, ligRMSD 38.29, no sequence satisfied the criterion)": 1
+      },
+      "invalid_reason": null,
+      "pass_rate": 0.0
+    },
+    "unconditional": {
+      "conditioning_satisfied": 2,
+      "designs_designable": 0,
+      "designs_novel": 0,
+      "designs_requested": 20,
+      "designs_returned": 2,
+      "designs_valid": 2,
+      "diversity": 0.0,
+      "failures": {
+        "not designable (scRMSD 10.85, ipTM 0.00, no sequence satisfied the criterion)": 1,
+        "not designable (scRMSD 11.00, ipTM 0.00, no sequence satisfied the criterion)": 1
+      },
+      "invalid_reason": null,
+      "pass_rate": 0.0
+    }
+  }
+}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/README.md

@@ -0,0 +1,43 @@
+# Shared all-atom conditional diffusion
+
+Run `bash infer.sh INPUT_ROOT OUTPUT_ROOT`. The package owns all imported model
+source and its checkpoint; it needs the image's Python dependencies and one GPU.
+No network, training corpus, external cache, or pretrained weights are used at
+inference. The exact checkpoint digest is in `harness.json`.
+
+One 12,445,554-parameter RFdiffusion3 network serves every track. Unconditional
+requests supply only length. Small-molecule requests supply a bare ligand. PPI
+requests supply a target and hotspot features, with the diffusion origin near the
+hotspots. Enzyme requests supply unindexed catalytic residues and ligand atoms;
+RFD3 chooses motif placement during all-atom diffusion. All use the same network,
+featurization, losses, and sampler. There are no per-track models or retrieved folds.
+
+Source derives from the mounted rfd3-small starter (Foundry b02eed6a). RF3 source
+utilities are included because a shared logging module imports them. No RF3 or
+LigandMPNN checkpoint is included or used by the generator.
+
+The model is initialized randomly and trained in this session on fit structures
+with the upstream all-atom EDM and sequence losses, PPI conditioning enabled,
+128-token crops, eight noise draws per structure, one structure per optimizer
+step, a 100-step warmup, and peak learning rate 0.001. Training uses one H100.
+`training_record.json` states the actual optimizer-step count and whether online
+or moving-average weights were exported. Optimizer state is excluded.
+
+`sampling.json` records sampler settings. The initial research candidate uses 24
+diffusion steps and one recycle to make full-suite contract replay affordable.
+The explicit diffusion-origin translation is restored before writing each design.
+Guidepost insertion is constrained to distinct generated protein residues, fixing
+an upstream atomwise-assignment failure. Generated coordinates outside the
+inserted guideposts are preserved; unknown sequence
+head outputs are represented as glycine backbone atoms for inverse folding.
+Each request receives its requested sample count, unless a documented sample or
+request error occurs. Errors are written to the output's failures.jsonl and do not
+abort the remaining batch. Ranking is neutral (0.0); no native structures are used.
+
+Limitations: the initial 32-step checkpoint is a pipeline smoke test, not a claim
+of designability or improvement over the reported reference. Contract replay and
+scientific evaluation are separate. Only the official LigandMPNN/RoseTTAFold3
+criteria plus Foldseek novelty establish passing designs. The initial
+measured screen has zero passing designs on every track (two designs emitted and
+twenty requested per target); see MEASUREMENTS.json. This is a diagnostic screen,
+not a full-rate estimate. Early training is severely underfit.

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/RESULTS.md

@@ -0,0 +1,59 @@
+# rfd3-small: results
+
+The reproduced numbers for this baseline. The criteria behind them, the enzyme-target
+distribution and the full write-up of how the graded and operator paths were reconciled are
+in [../../evaluation/RESULTS.md](../../evaluation/RESULTS.md).
+
+## What this baseline is
+
+Upstream RFdiffusion3, vendored at `rfd3/` from
+[RosettaCommons/foundry](https://github.com/RosettaCommons/foundry) `b02eed6a` and reduced in
+**layer widths only** to **12,445,554** parameters against upstream `pretrain`'s 168,038,994
+(7.4 %). Every depth is upstream's — 18 diffusion transformer blocks, 2 + 2 pairformer,
+3 + 3 atom encoder/decoder, `n_recycle` 2 — as are the crop, the losses, the AF-3
+optimizer/schedule and EMA. See [README.md](README.md) for the eight width leaves that change
+and how to run it.
+
+## Transfer (verifier, 51-target evaluation view)
+
+Checkpoint `epoch-0100.ckpt`, the real protocol of 51 targets × 100 designs.
+`conditioning_satisfied` is 100 % on all four tracks.
+
+| track | `pass_rate` | `diversity` | operator harness |
+|---|---:|---:|---:|
+| enzyme | 0.0624 | 0.341 | 0.054 |
+| sm_binder | 0.0275 | 0.750 | 0.030 |
+| ppi_binder | 0.002 | 0.200 | 0.004 |
+| unconditional | 0.420 | 1.000 | 0.410 |
+
+The two paths agree within sampling noise, on counts of 12 vs 11, 1 vs 2, 220 vs 256 and
+41 vs 42 passing designs. Reaching that agreement required fixing five divergences in which
+the graded path posed a different problem from the published specs; `input.yaml` is the source
+of truth and residue renumbering is the only licensed difference. The five are written up in
+[../../evaluation/RESULTS.md](../../evaluation/RESULTS.md).
+
+**This row is accepted from the task author's report rather than reproduced in this setup**,
+because the checkpoint is not distributable.
+
+## Anchors
+
+| system | enzyme | sm_binder | ppi_binder | unconditional |
+|---|---:|---:|---:|---:|
+| trivial generator (extended backbone, reduced view) | 0.000 | 0.000 | 0.000 | 0.000 |
+| `rfd3-small` above | 0.0624 | 0.0275 | 0.002 | 0.420 |
+
+The trivial row is a **partial** null system: one target per track and two designs each, run
+through the real scorer, where nothing was designable on any track. The full
+null row over all 51 targets is still open, and matters most on `enzyme`, where 28 of 41
+targets score exactly 0.
+
+## Reading the numbers
+
+- `ppi_binder` is measurable, not good: 1 of 500 is not distinguishable from zero
+  (P(0 of 500 | true rate 0.004) ≈ 13 %). What the cross-check establishes is that the number
+  is produced by the model rather than by a spec bug, which was not true of any earlier run.
+- Thresholds come from RFdiffusion3's `success.txt`, which was calibrated with AlphaFold;
+  scoring here uses RoseTTAFold3. Numbers are internally comparable and **not** comparable with
+  the published table.
+- 5 designs of 5,100 never reached the grader, each carrying a single `UNK` residue that
+  `rfd3_collect.py` rejects. They count as failed designs, which shifts pass rates by ≤ 0.1 %.

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/TRAINING_DATA.md

@@ -0,0 +1,405 @@
+# Training data for the vendored RFdiffusion3
+
+The starter is upstream RFdiffusion3 (`starter/rfd3/`, pinned at `b02eed6a`), reduced in
+layer width and nothing else. This page is about the one thing that could not be
+vendored with it: **the data contract**.
+
+Upstream's own documentation stops short here. `models/rfd3/README.md` devotes two
+paragraphs to data - "update the path configs to point to the correct base directories
+for the metadata parquets" for the PDB case, and a single sentence for custom datasets
+that defers to a URL you cannot reach offline. The page that URL points at is vendored
+at `references/atomworks-datasets.md`, and it is genuinely useful: it explains
+`PandasDataset`, the loader factories, `ConcatDatasetWithID` and the weighted sampler.
+What it does not explain is the *schema* - which columns must exist, what `cluster`
+means, how interface clusters are keyed. That is what follows.
+
+**If you have network access, read §0 first.** Upstream publishes the real metadata
+tables, and downloading them is both faster and more faithful than rebuilding them.
+§1-§6 describe the offline path, which is what the graded image has.
+
+---
+
+## 0. With network: download the real corpus, do not rebuild it
+
+Upstream's metadata is a **public artifact**, which is not obvious from the rfd3 README -
+it only says "update the path configs". The download lives in the atomworks CLI, which is
+already installed alongside the vendored rfd3:
+
+```sh
+# 1. the two metadata tables (~975 MB archive -> ~3.8 GB of parquet)
+atomworks setup metadata /data/upstream/metadata
+
+# 2. the structures: RCSB divided mmCIF mirror (~100 GB), or a subset
+atomworks pdb sync /data/upstream/pdb
+atomworks pdb sync /data/upstream/pdb --pdb-ids-file ids.txt   # subset
+
+# 3. the chemical component dictionary (~2 GB)
+atomworks ccd sync /data/upstream/ccd
+```
+
+`output_dir` is a **positional argument** on `setup metadata`; the command's own docstring
+shows `--output-dir`, which does not exist and will error. Mirroring uses rsync to
+`rsync.wwpdb.org::ftp/data/structures/divided/mmCIF/` on **port 33444** (CCD:
+`rsync://ftp.ebi.ac.uk/pub/databases/msd/pdbechem_v2/ccd/`), so a site that blocks
+outbound rsync can fetch the metadata but not the structures.
+
+Verified 2026-09-22: `https://files.ipd.uw.edu/pub/atomworks/pdb_metadata_latest.tar.gz`,
+975,084,126 bytes, last-modified 2025-08-10, sha256
+`8f77156c978135bf5fb5cfff8595103c05dccbafa38c85f3e27385869b9db1a0`. It is a `_latest`
+URL, so treat that digest as a record of what was checked, not a pin that must hold.
+Same host and `/pub/` tree as the scorer weights in
+`environment/fetch_designability_weights.sh`.
+
+### Point the configs at it
+
+```yaml
+# configs/paths/data/<your>.yaml
+pdb_parquet_dir: /data/upstream/metadata
+pdb_data_dir:    /data/upstream/pdb
+```
+
+and export `PDB_MIRROR_PATH` / `CCD_MIRROR_PATH` for the atomworks side.
+
+**The mirror layout already matches.** `atomworks pdb sync` writes
+`a0/1a0i.cif.gz` - characters 2-3 of the id - which is exactly what
+`PNUnitsDFParser`'s default `path_template` resolves (§1) and the same layout IPD's own
+frozen PDB copy uses. These are plain asymmetric-unit mmCIFs; atomworks builds the
+assembly at load time, so **nothing needs pre-expanding** - unlike the offline path,
+which stages `-assembly1.cif.gz` files.
+
+**One filename mismatch to fix.** The archive ships `pn_units_df.parquet`, but
+`datasets/train/pdb/af3_train_pn_unit.yaml` reads
+`${paths.data.pdb_parquet_dir}/pn_units_df_train.parquet`. Symlink it, or override
+`dataset.dataset.data`. The interfaces name matches as shipped.
+
+### What you get, and how it differs from a local rebuild
+
+| | downloaded | `build_training_index.py` |
+| --- | --- | --- |
+| `pn_units_df` rows | 3,813,611 (whole PDB) | whatever you staged |
+| `interfaces_df` rows | 6,875,066 | derived |
+| required `columns_to_load` | **all present**, both tables | all present |
+| `cluster` | upstream's own 40% MMseqs2 hash | 30% RCSB substitute (§3) |
+| `q_pn_unit_is_loi` | populated, 7.1% True | always False (§4) |
+| entry dates / resolution | in the table | need `entries.idx` (§4) |
+
+So the download **retires every compromise in §3 and §4** for PDB data. Rebuild only for
+structures that are not in the PDB.
+
+### The split and the target holdout are filters, not files
+
+The published tables are whole-PDB (max deposition date 2025-06-24). Train/val and the
+benchmark holdout are `filters` in the dataset configs, so they are reproducible from the
+repo alone. `datasets/train/pdb/rfd3_train_{pn_unit,interface}.yaml` carry
+
+```yaml
+- 'pdb_id not in ["7rte", "7m5w", "7n5u"]'
+- 'pdb_id not in ["3di3", "5o45", "1z92", "2gy5", "4zxb"]'   # the five ppi eval targets
+- "deposition_date < '2024-12-16'"
+```
+
+while `af3_train_*.yaml` cut at `2021-09-30`. Applying RFD3's own filters to the
+downloaded tables gives:
+
+| cut | pn_units | interfaces | total examples |
+| --- | ---: | ---: | ---: |
+| `< 2021-09-30` | 2,395,525 | 4,045,470 | **6,440,995** |
+| `< 2024-12-16` | 3,258,883 | 5,632,469 | **8,891,352** |
+
+**Beware a trap if you compare against runs on IPD paths.** Their `pn_units_df_train.parquet`
+already has the 2021 cut baked in (max date 2021-09-20), so `rfd3_train_*`'s
+`< '2024-12-16'` is a **no-op there** - those runs saw a 2021 corpus. Use the 2021 cut to
+reproduce them, and expect a ~10% superset anyway from the newer snapshot.
+
+Cluster **labels** are not portable across snapshots: on the 2.41M example ids shared with
+the IPD tables the string matches for 86%, the rest being hash relabelings as new members
+join a cluster. The partition is the same scheme; the ids are not join keys.
+
+---
+
+## 1. What RFD3 actually trains on
+
+Not design requests. The four per-track `.npz` contexts under `/data/*/contexts/` are
+inference inputs - a length, a motif, a ligand. Upstream trains on **whole structures**
+and samples its own crops and conditioning from them. That is where the tipatom regime
+(53% of pretraining) and the unindexed regime come from: they are re-rolled on every
+draw, not stored.
+
+So training needs two things:
+
+| what | where | who makes it |
+| --- | --- | --- |
+| mmCIF assemblies | `/data/development/fit/structures/<xx>/<id>.cif.gz` | operator (`materialize.py --corpus-targets`) |
+| two index tables | `/data/development/fit/index/*.parquet` | `data/build_training_index.py` |
+
+The `<xx>` shard is characters 2-3 of the PDB id (`1a0i` -> `a0/1a0i.cif.gz`). That is
+the RCSB divided layout, which is what `PNUnitsDFParser`'s default `path_template`
+(`{base_dir}/{pdb_id[1:3]}/{pdb_id}{file_extension}`) already resolves - so no path
+override is needed.
+
+**An example is a row, not a file.** `pn_units_df_train.parquet` has one row per PN unit
+(one polymer or non-polymer unit of one assembly); `interfaces_df_train.parquet` has one
+row per contacting pair. A single entry therefore contributes several examples.
+
+---
+
+## 2. The schema
+
+Three consumers fix it, and every column below exists because one of them reads it.
+
+### `pn_units_df_train.parquet`
+
+| column | dtype | meaning |
+| --- | --- | --- |
+| `example_id` | str | `{['pdb', 'pn_units']}{1owi}{1}{['A_1']}` - build it with `atomworks.ml.example_id.generate_example_id`, never by hand |
+| `pdb_id` | str | lower-case, resolves the file through the path template |
+| `assembly_id` | str | which assembly to build |
+| `deposition_date` | datetime64 | read by the `filters` |
+| `resolution` | float | read by the `filters`; NaN is allowed and passes `< 9.0` as False |
+| `num_polymer_pn_units` | int | read by the `filters` (`<= 300`) |
+| `method` | str | `X-RAY_DIFFRACTION`, underscored |
+| `cluster` | str | see §3 - the sampler's homology balance |
+| `n_prot`, `n_nuc`, `n_ligand`, `n_peptide` | int | AF-3 composition weights; exactly one is 1 |
+| `total_num_atoms_in_unprocessed_assembly` | int | loaded by the config, not filtered on |
+| `q_pn_unit_iid` | str | **the query unit - this is what the crop is centred on** |
+| `q_pn_unit_non_polymer_res_names` | str or None | CCD codes; the AF-3 excluded-ligand filter matches on it |
+| `all_pn_unit_iids_after_processing` | JSON str | which units survive clash resolution |
+| `q_pn_unit_is_loi` | bool | ligand of interest; see §4 |
+
+### `interfaces_df_train.parquet`
+
+Same common columns, then `pn_unit_1_iid` / `pn_unit_2_iid` (both query units - the crop
+is centred on the interface), `pn_unit_1_non_polymer_res_names` /
+`pn_unit_2_non_polymer_res_names`, `is_inter_molecule` (bool, filtered on) and
+`involves_loi`. The composition counts are summed over **both** units, so a
+protein-ligand interface is `n_prot=1, n_ligand=1`.
+
+The consumers:
+
+* `atomworks.ml.datasets.parsers.PNUnitsDFParser` / `InterfacesDFParser` - find the file,
+  pick the assembly, choose the crop centre.
+* `atomworks.ml.samplers.calculate_af3_example_weights` - **asserts** on
+  `["n_prot", "n_nuc", "n_ligand", "cluster_size"]`. `cluster_size` is not a column you
+  write: the sampler derives it from `cluster` and asserts it is never NaN.
+* the dataset configs' `filters` - `deposition_date`, `resolution`,
+  `num_polymer_pn_units`, `cluster.notnull()`, the `*_non_polymer_res_names` regex, and
+  `is_inter_molecule` for interfaces.
+
+### How the weights use it
+
+```
+w  ∝  (β / N_cluster) · (a_prot·n_prot + a_peptide·n_peptide + a_nuc·n_nuc
+                         + a_ligand·n_ligand + a_loi·is_loi)
+```
+
+with `beta: 0.5` and `a_prot 3.0 / a_nuc 0.0 / a_ligand 1.0 / a_loi 5.0`
+(`datasets/train/pdb/base.yaml`). The two tables are concatenated, their weight vectors
+are concatenated with them, and one `WeightedRandomSampler(..., replacement=True)`
+covers the whole thing. There is **no fixed interface:pn_unit ratio** - the mix falls
+out of the weights.
+
+Two consequences worth internalising:
+
+1. **Sampling is with replacement and an "epoch" is just a counter**
+   (`n_examples_per_epoch`). Nothing is exhausted, so a small corpus needs no structural
+   change - it is revisited sooner, and each revisit re-rolls the crop and the
+   conditioning, so a repeat is not the same example.
+2. **`cluster` is the only thing clustering feeds**, and it enters as a scalar divisor.
+   Without it, `datasets/train/pdb/base_no_weights.yaml` gives uniform sampling.
+   Training still runs; you lose homology balancing.
+
+---
+
+## 3. The cluster conventions
+
+Nothing documents these and nothing errors if you get them wrong - the weights just come
+out wrong, silently. All three were established by reading upstream's parquets.
+
+1. **Polymers are keyed by a clustering, not by the entity.** Upstream uses a
+   representative-sequence hash from a 40%-identity MMseqs2 clustering
+   (`3ad9e8af6a4`). This task substitutes **RCSB's 30% entity clusters**
+   (`rcsb30:57016`), because that is a public, digest-pinned input the task already
+   downloads *and* it is the partition the fit/evaluation split is made disjoint on -
+   so the sampler's balancing and the split agree instead of fighting. Where an entity
+   is missing from the cluster file we fall back to atomworks' exact-sequence hash,
+   which under-clusters but never collides.
+2. **Non-polymers are keyed by CCD code.** A bare ligand unit's cluster is literally
+   `426` or `HEM`. So all heme sites in the PDB are one cluster and are damped together.
+3. **Interface clusters are the two sides joined by `+`** - `2eeec33883b+SPM`,
+   `HEM+rcsb30:57016`. Sorted, so the key does not depend on which side was listed
+   first. Get this wrong and interface homology silently collapses to single-chain
+   clustering.
+
+Why MMseqs2 is not an option here: it is not in the image, `PIP_NO_INDEX=1` and no
+network mean it cannot be installed, and clustering ~16k entries by pairwise alignment
+does not fit the budget. The RCSB clusters are already a task input
+(`data/sources.json`, `rcsb_clusters_30`), pinned by digest.
+
+---
+
+## 4. Building the index offline
+
+This is the path for the graded image, which has no network, and for structures that are
+not in the PDB. **For PDB data with network access, §0 is both cheaper and more faithful.**
+
+```sh
+python /workspace/data/build_training_index.py \
+    --structures /data/development/fit/structures \
+    --clusters   /data/sources/clusters-by-entity-30.txt \
+    --entry-index /data/sources/entries.idx \
+    --output     /data/development/fit/index \
+    --workers    $(nproc)
+```
+
+Four things that will bite if you write your own instead:
+
+1. **`DataPreprocessor(from_rcsb=False)` is mandatory offline.** The default
+   (`from_rcsb=True`) POSTs to `data.rcsb.org/graphql` for ligand validity scores with
+   **no try/except around the request**, so it raises `ConnectionError` rather than
+   degrading. The cost of `False` is that `is_loi` is False everywhere, which switches
+   off the `a_loi: 5.0` term - about 2.9% of upstream's rows carry it.
+2. **An `-assembly1.cif.gz` download carries no entry metadata.** Its `metadata.id` is
+   the literal `xxxx`, and deposition date, release date and resolution all parse as
+   None. They have to come from `entries.idx`, which is why `--entry-index` exists. Skip
+   it and every date filter drops every row.
+3. **Give each structure a timeout.** Cost is not proportional to file size: `4nlm` is
+   175 KB and ran for over ten minutes, while the median entry is ~2 s. The builder
+   budgets 120 s per structure and records the skips in `index_report.json`.
+4. **Cast the PN unit ids to `str`.** atomworks returns numpy `str_`, and
+   `generate_example_id` formats the list with `repr`, so a numpy scalar is written into
+   the id as `np.str_('A_1')` - and `parse_example_id`, which `eval`s that field, then
+   fails on it.
+
+To build a corpus of your own from scratch, the preprocessing half is
+`atomworks.ml.preprocessing.get_pn_unit_data_from_structure` - pure Python over biotite,
+no binaries, no network. It gives you per-unit records (sequences, sequence hashes,
+contacting units, residue counts, clash severity); the cluster join and the interface
+derivation are what `build_training_index.py` adds on top.
+
+### Measured cost
+
+On one core, preprocessing runs at **~2 s per structure** (median; mean is higher
+because of a long tail). The transform pipeline that runs at *training* time - parse,
+assembly build, crop, condition sampling, featurisation - costs a **median 2.05 s and
+mean 2.50 s per drawn example** on one core, measured through upstream's own loader at
+crop 256 with 16 noise draws.
+
+That sets the shape of the problem: eight
+loader workers deliver roughly 3 examples/s, so the CPUs are not obviously the binding
+constraint, and the honest answer is that **you should measure GPU utilisation before
+assuming either side is**. Turning on `save_to_cache` for the parsed-CIF cache
+(`paths.data.cif_cache_dir`, see `configs/paths/data/task.yaml`) moves parse cost off
+the critical path on every revisit, which matters because sampling is with replacement.
+
+---
+
+## 5. Training
+
+```sh
+python /workspace/baseline/rfd3-small/rfd3/models/rfd3/src/rfd3/train.py experiment=pretrain_small_ppi
+```
+
+`pretrain_small_ppi` is upstream's recipe with the widths reduced and PPI conditioning
+on, and it already points at this container's data by default - there is nothing to
+override. It changes no other recipe leaf: 18 diffusion blocks, the condition mix
+(tipatom 5.0 / unconditional 2.0 / island 2.0 / sequence_design 0.5), the unindexed
+regime at `p_unindex_motif_tokens: 0.5` on island and tipatom, crop 256, the AF-3
+optimizer, schedule and EMA, and every loss weight.
+
+What it does change, and why:
+
+| change | reason |
+| --- | --- |
+| `paths/data: task` | upstream's defaults are IPD mounts that do not exist here |
+| parquet filenames + date filter | match what the index builder writes and the task's own split boundary |
+| `datasets.val: null` | upstream's validation sets read design-benchmark JSON that is not redistributed; a missing file fails at dataset construction. Score with `evaluation/score.py` on the tune view instead |
+| `calculate_hbonds: 0` | HBPLUS is not installed, and 0.2 raises at runtime. It is a free download - install it and restore 0.2 to get the channel back |
+| `grad_accum_steps: 3`, `devices_per_node: 1` | one GPU, so upstream's 3-structures-per-optimizer-step has to come from accumulation. Keeping it is what makes the AF-3 warmup and decay mean the same thing per unit of data |
+
+### Verified end to end
+
+Run 2026-09-17 on one RTX A4000, from an index this pipeline built over task-cache
+assemblies. `train.py` on this experiment reached 2 optimizer steps over 6 batches and
+saved a checkpoint, with:
+
+* **12,445,554 trainable parameters** - identical to the reference reduced run;
+* examples drawn from **both** tables (`pdb/pn_units` 66.7%, `pdb/interfaces` 33.3%) by
+  the weighted sampler, e.g. `{['pdb', 'interfaces']}{1a31}{1}{['B_1', 'C_1']}`;
+* `Mse Loss Mean` **1.0126** at step 0, which is what an EDM-preconditioned loss should
+  read for an untrained network - 1.0 is exactly a zero predictor;
+* **`lp_norm_unindexed_diffused` 0.6489, nonzero** - the unindexed regime is live and
+  contributing gradient, which is the whole reason for training upstream rather than the
+  port;
+* validation correctly skipped ("No validation datasets provided").
+
+Diffing the checkpoint's own resolved `train_cfg` against a fresh
+`compose(experiment=pretrain)` leaves **three** unexplained differing leaves once width
+cuts, data re-pointing, removed validation and the smoke run's own `max_epochs` /
+`n_examples_per_epoch` / `diffusion_batch_size_train` are set aside: two dataloader knobs
+passed on the command line, and `calculate_hbonds` (§5). Crop 256, `max_atoms_in_crop`
+2560, `grad_accum_steps` 3, 18 diffusion blocks, tipatom frequency 5.0 and
+`p_unindex_motif_tokens` 0.5 on both island and tipatom all match upstream exactly.
+
+### Known departures from upstream, all deliberate
+
+* **30% RCSB clusters instead of 40% MMseqs2** (§3) - a different, stricter partition.
+  Avoidable with network: the downloaded tables carry upstream's own clusters (§0).
+* **`is_loi` always False** (§4) - the `a_loi` term never fires. Also avoidable via §0,
+  where the column is populated.
+* **No hydrogen-bond conditioning** - HBPLUS absent.
+* **No MACE embedding cache** - `residue_cache_dir` starts empty and atomworks falls
+  back to RDKit reference conformers. Upstream hits the same fallback on this cluster
+  for any component its shared cache lacks.
+* **No validation loop** - the task's grader is the metric.
+
+---
+
+## 6. From checkpoint to submission
+
+`rfd3_infer.sh` closes the loop:
+
+```sh
+# 100 designs per target by default (N_BATCHES=25 x 4 diffusion samples); lower
+# N_BATCHES for a quicker, noisier read.
+bash rfd3_infer.sh <ckpt> /data/tune /workspace/research/run
+python /workspace/evaluation/score.py --input /data/tune \
+    --designs /workspace/research/run/submission --tracks enzyme
+```
+
+Three stages, with upstream's inference untouched in the middle:
+
+| stage | what |
+| --- | --- |
+| `rfd3_inputs.py` | request `.npz` -> `InputSpecification` + a conditioning structure rebuilt from the context |
+| `rfd3 design` | upstream, unmodified. Reduced widths come from the checkpoint's own `train_cfg` |
+| `rfd3_collect.py` | output mmCIF -> one PDB per design plus `<track>.jsonl`, with `motif_map` recovered for enzyme |
+
+`rfd3_inputs.py` works on **fit and tune**, which is what an agent has - the container
+mounts only `development`. It rebuilds the conditioning rather than reusing upstream's
+published benchmark specs, which exist only for the evaluation view the verifier holds
+(that path is `environment/evaluation/benchmark/` in the repo, operator-side). All 160 tune specs across the
+four tracks pass upstream's own CPU-only `DesignInputSpecification.safe_init`.
+
+Two details worth knowing before you modify it:
+
+* **Ligand atom names are reconstructed.** A context stores ligand coordinates and
+  elements but no names, and RFD3 needs names that match the chemical component or bonds
+  and the reference conformer will not resolve. Materialization keeps deposition order,
+  which follows the CCD, so the observed element sequence is embedded into the CCD's
+  heavy-atom sequence, earliest match first. 22 of 24 sampled ligands match
+  element-for-element; the other two have *fewer* atoms than the CCD (unresolved
+  density), which is exactly why a subsequence embedding is used rather than positional
+  assignment.
+* **Enzyme goes through `unindex`, not a contig.** The request gives motif geometry with
+  no positions, so the model chooses placement and `motif_map` reports it back. That is
+  upstream's guidepost setting and the reason for training upstream at all.
+
+Three bugs this path already cost, kept here so they are not rediscovered:
+
+1. A pinned contig of `150` parses as **residue index 150**, not a 150-residue design.
+   Write `150-150`.
+2. `diffused_index_map` keys come back **truncated** (`B1029` -> `B102`), so exact lookup
+   silently drops designs; match on unique prefix.
+3. The coordinate fallback must not demand all four backbone atoms - an enzyme context
+   carries only 2-3 fixed tip atoms per motif residue, so a four-atom requirement can
+   never fire.

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/design.py

@@ -0,0 +1,207 @@
+"""One shared, trained all-atom diffusion network for every conditioning track."""
+import gc
+import hashlib
+import json
+from pathlib import Path
+import sys
+import tempfile
+import time
+import traceback
+
+import numpy as np
+import torch
+from omegaconf import OmegaConf
+
+from rfd3.engine import RFD3InferenceConfig, RFD3InferenceEngine
+from rfd3.inference.datasets import ContigJsonDataset
+from rfd3.transforms.pipelines import build_atom14_base_pipeline
+from rfd3_collect import to_atom14, recover_motif_map, write_pdb
+from rfd3_inputs import BUILDERS
+from residues import ATOM14
+
+TRACKS = ('unconditional', 'sm_binder', 'ppi_binder', 'enzyme')
+HERE = Path(__file__).resolve().parent
+
+
+class SharedEngine(RFD3InferenceEngine):
+    def _construct_pipeline(self, cfg):
+        # Training has no validation dataset; inference uses its own transform and
+        # resolves no corpus, training log, benchmark or cached conformer paths.
+        self.inference_cfg = cfg
+        self.set_batch_size(self.transform_overrides['diffusion_batch_size'])
+
+    def set_batch_size(self, count):
+        cfg = self.inference_cfg
+        args = OmegaConf.to_container(cfg.datasets.global_transform_args, resolve=True)
+        args.pop('train_conditions', None)
+        args.pop('meta_conditioning_probabilities', None)
+        args.update(is_inference=True, return_atom_array=True,
+                    diffusion_batch_size=count, residue_cache_dir=None,
+                    sigma_data=float(cfg.model.net.diffusion_module.sigma_data),
+                    atom_1d_features=OmegaConf.to_container(
+                        cfg.model.net.token_initializer.atom_1d_features, resolve=True),
+                    token_1d_features=OmegaConf.to_container(
+                        cfg.model.net.token_initializer.token_1d_features, resolve=True))
+        self.pipeline = build_atom14_base_pipeline(**args)
+
+
+def conditioning_origin(track, context):
+    """An explicit diffusion origin whose translation is restored on output."""
+    if track == 'unconditional':
+        return np.zeros(3)
+    if track == 'ppi_binder':
+        target = context['target_coords']
+        mask = context['target_mask'].astype(bool)
+        points = []
+        for k, row in enumerate(context['hotspot_indices']):
+            row = int(row)
+            keep = mask[row].copy()
+            if 'hotspot_atoms' in context:
+                atoms = str(context['hotspot_atoms'][k]).split(',')
+                names = ATOM14[str(context['target_restypes'][row])]
+                selected = [a in atoms for a in names] + [False] * (14 - len(names))
+                keep &= np.array(selected, dtype=bool)
+            points.extend(target[row][keep])
+        hotspots = np.asarray(points)
+        atoms = target[mask]
+        nearby = ((atoms[:, None] - hotspots[None]) ** 2).sum(-1).min(-1) <= 144.
+        center = hotspots.mean(0)
+        normal = center - atoms[nearby].mean(0)
+        size = np.linalg.norm(normal)
+        return center + 10. * normal / max(size, 1e-8)
+    if track == 'sm_binder':
+        return context['ligand_coords'].mean(0)
+    pieces = [context['motif_coords'][context['motif_mask'].astype(bool)]]
+    if len(context.get('ligand_coords', [])):
+        lig = context['ligand_coords']
+        keep = context.get('ligand_fixed_mask', np.ones(len(lig), dtype=bool)).astype(bool)
+        pieces.append(lig[keep])
+    return np.concatenate(pieces).mean(0)
+
+
+def extract_design(output, request, context, origin):
+    arr = output.atom_array
+    chains = {}
+    for atom in arr:
+        if atom.element == 'H':
+            continue
+        res = chains.setdefault(str(atom.chain_id), {})
+        entry = res.setdefault(int(atom.res_id), [str(atom.res_name), {}])
+        entry[1][str(atom.atom_name)] = tuple(float(v) for v in atom.coord)
+    candidates = []
+    for chain, entries in chains.items():
+        if len(entries) != request['design_length']:
+            continue
+        residues = []
+        for number, (name, atoms) in entries.items():
+            if name == 'UNK' and all(a in atoms for a in ('N', 'CA', 'C', 'O')):
+                # MPNN supplies the scored sequence; no coordinates are rebuilt.
+                name, atoms = 'GLY', {a: atoms[a] for a in ('N', 'CA', 'C', 'O')}
+            residues.append((number, name, atoms))
+        if not all(name in ATOM14 for _, name, _ in residues):
+            continue
+        chosen = arr.chain_id == chain
+        fixed = (arr.is_motif_atom_with_fixed_coord[chosen].astype(bool).mean()
+                 if 'is_motif_atom_with_fixed_coord' in arr.get_annotation_categories()
+                 else 0.0)
+        candidates.append((float(fixed), chain, sorted(residues)))
+    if not candidates:
+        raise ValueError('no generated protein chain of the requested length')
+    _, _, residues = min(candidates, key=lambda v: (v[0], v[1]))
+    coords, mask, names = to_atom14(residues)
+    coords += origin
+    if not mask[:, :4].all() or not np.isfinite(coords[mask]).all():
+        raise ValueError('incomplete or nonfinite generated backbone')
+    mapping = None
+    if request['track'] == 'enzyme':
+        mapping = recover_motif_map(output.metadata, names, context, coords, mask)
+        if mapping is None:
+            raise ValueError('could not identify generated motif residues')
+    return coords, mask, names, mapping
+
+
+def main():
+    input_root, output_root = map(lambda p: Path(p).resolve(), sys.argv[1:3])
+    settings = json.loads((HERE / 'sampling.json').read_text())
+    torch.set_num_threads(4)
+    torch.set_float32_matmul_precision('high')
+    config = RFD3InferenceConfig(
+        ckpt_path=HERE / 'generator.ckpt', diffusion_batch_size=settings['batch_size'],
+        inference_sampler={'num_timesteps': settings['timesteps'],
+                           'step_scale': settings['step_scale'],
+                           'n_recycle': settings['recycles']},
+        seed=settings['seed'], prevalidate_inputs=False, global_prefix='',
+    )
+    engine = SharedEngine(**dict(config))
+    engine.initialize()
+    pred = output_root / 'predictions'
+    structures = pred / 'structures'
+    structures.mkdir(parents=True, exist_ok=True)
+    errors = output_root / 'failures.jsonl'
+    with tempfile.TemporaryDirectory(prefix='shared-rfd3-') as temporary:
+        temporary = Path(temporary)
+        for track in TRACKS:
+            source = input_root / f'{track}.jsonl'
+            if not source.exists():
+                continue
+            with (pred / f'{track}.jsonl').open('w') as index:
+                for line in source.read_text().splitlines():
+                    if not line.strip():
+                        continue
+                    request = json.loads(line)
+                    example, records = request['example_id'], []
+                    start = time.monotonic()
+                    try:
+                        context = dict(np.load(input_root / request['context_path'], allow_pickle=False))
+                        safe_name = hashlib.sha256(example.encode()).hexdigest()[:20]
+                        if track == 'unconditional':
+                            spec = {'length': f"{request['design_length']}-{request['design_length']}"}
+                        else:
+                            spec = BUILDERS[track](context, request['design_length'],
+                                                   temporary / f'{safe_name}.pdb')
+                        if spec is None:
+                            raise ValueError('conditioning chemistry could not be resolved')
+                        origin = conditioning_origin(track, context)
+                        if track != 'unconditional':
+                            spec['ori_token'] = origin.tolist()
+                            spec.pop('infer_ori_strategy', None)
+                        count = int(request['num_designs'])
+                        for offset in range(0, count, settings['batch_size']):
+                            batch_size = min(count - offset, settings['batch_size'])
+                            engine.set_batch_size(batch_size)
+                            dataset = ContigJsonDataset(
+                                data={f'{safe_name}_{offset}': dict(spec)},
+                                cif_parser_args=None, transform=engine.pipeline,
+                                name=track, subset_to_keys=None, eval_every_n=1)
+                            pipeline_input = dataset[0]
+                            outputs = engine._model_forward(pipeline_input)
+                            for sample, output in enumerate(outputs):
+                                number = offset + sample
+                                try:
+                                    coords, mask, names, mapping = extract_design(output, request, context, origin)
+                                    name = f'{safe_name}-{number}.pdb'
+                                    write_pdb(structures / name, coords, mask, names)
+                                    rec = {'design_index': number, 'ranking_score': 0.0,
+                                           'structure_path': name}
+                                    if mapping is not None:
+                                        rec['motif_map'] = mapping
+                                    records.append(rec)
+                                except (ValueError, KeyError, IndexError) as error:
+                                    with errors.open('a') as log:
+                                        log.write(json.dumps({'example_id': example,
+                                            'design_index': number, 'error': str(error)}) + '\n')
+                            del outputs, pipeline_input, dataset
+                    except Exception as error:
+                        traceback.print_exc()
+                        with errors.open('a') as log:
+                            log.write(json.dumps({'example_id': example, 'error': repr(error)}) + '\n')
+                        gc.collect()
+                        torch.cuda.empty_cache()
+                    index.write(json.dumps({'example_id': example, 'designs': records}) + '\n')
+                    index.flush()
+                    print(f"SERVED {track} {example}: {len(records)}/{request['num_designs']} "
+                          f"in {time.monotonic() - start:.1f}s", flush=True)
+
+
+if __name__ == '__main__':
+    main()

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/harness.json

@@ -0,0 +1,14 @@
+{
+  "schema": "protein-design-harness/v1",
+  "kind": "trained_generator",
+  "entry_point": "infer.sh",
+  "pretrained_assets": [],
+  "learned_components": [
+    {
+      "path": "generator.ckpt",
+      "sha256": "e79f4ba38486541ccd3e0129f65c0579475319567a5d01e2a92d62ec6027c779",
+      "parameters": 12445554,
+      "trained_in_session": true
+    }
+  ]
+}

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/infer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+if [[ $# -ne 2 ]]; then
+    echo 'usage: infer.sh INPUT_ROOT OUTPUT_ROOT' >&2
+    exit 2
+fi
+here="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+export PROJECT_ROOT="$here/rfd3"
+export PYTHONPATH="$here:$here/rfd3/src:$here/rfd3/models/rfd3/src:$here/rfd3/models/rf3/src"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1
+export PYTORCH_CUDA_ALLOC_CONF=expandable_segments:True
+exec python "$here/design.py" "$1" "$2"

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/publish.py

@@ -0,0 +1,79 @@
+#!/usr/bin/env python3
+"""Publish a package directory to /workspace/submission atomically.
+
+    python /workspace/baseline/rfd3-small/publish.py SRC [--exclude GLOB ...] [--check]
+
+The verifier may snapshot /workspace/submission at any moment, so the package must never be
+half-written. This copies SRC into a staging directory next to the target (training-only
+files excluded), optionally checks the harness manifest the way the verifier does, then swaps
+it in with one rename.
+"""
+import argparse
+import errno
+import fnmatch
+import os
+import shutil
+import sys
+import tempfile
+from pathlib import Path
+
+DEFAULT_EXCLUDES = ["__pycache__", "*.pyc", "*.ckpt.tmp", "optimizer.pt", "events.out.tfevents.*"]
+
+
+def ignore_for(source: Path, patterns: list[str]):
+    def ignore(directory: str, names: list[str]) -> set[str]:
+        relative = Path(directory).relative_to(source)
+        return {name for name in names
+                if any(fnmatch.fnmatch(name, p) or fnmatch.fnmatch((relative / name).as_posix(), p)
+                       for p in patterns)}
+    return ignore
+
+
+def swap_into(staged: Path, final: Path) -> None:
+    old = final.with_name(f".{final.name}.old-{os.getpid()}")
+    if final.exists():
+        try:
+            os.replace(final, old)
+        except OSError as error:
+            # A directory from a lower image layer cannot be renamed on overlayfs (EXDEV): move
+            # its contents aside instead; the swap below is still a single rename.
+            if error.errno != errno.EXDEV:
+                raise
+            shutil.copytree(final, old, symlinks=True)
+            shutil.rmtree(final)
+    os.replace(staged, final)
+    shutil.rmtree(old, ignore_errors=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("source", type=Path)
+    parser.add_argument("--output", type=Path, default=Path("/workspace/submission"))
+    parser.add_argument("--exclude", action="append", default=[],
+                        help=f"glob (name or path relative to SRC) to leave out; always excluded: {DEFAULT_EXCLUDES}")
+    parser.add_argument("--check", action="store_true",
+                        help="validate harness.json against the staged copy, as the verifier does")
+    args = parser.parse_args()
+    source, final = args.source.resolve(), args.output.resolve()
+    for required in ("infer.sh", "harness.json", "README.md"):
+        if not (source / required).is_file():
+            sys.exit(f"{source} has no {required} (see /workspace/contract.md)")
+    final.parent.mkdir(parents=True, exist_ok=True)
+    staged = Path(tempfile.mkdtemp(prefix=f".{final.name}.stage-", dir=final.parent))
+    try:
+        shutil.copytree(source, staged, symlinks=False, dirs_exist_ok=True,
+                        ignore=ignore_for(source, DEFAULT_EXCLUDES + args.exclude))
+        if args.check:
+            sys.path.insert(0, "/workspace/evaluation/lib")
+            from common import validate_harness  # the verifier's own check
+            validate_harness(staged, Path("/pretrained"))
+        staged.chmod(0o755)
+        swap_into(staged, final)
+    except BaseException:
+        shutil.rmtree(staged, ignore_errors=True)
+        raise
+    print(f"published {source} -> {final}")
+
+
+if __name__ == "__main__":
+    main()

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/residues.py

@@ -0,0 +1,66 @@
+"""Atom14 residue constants.
+
+Each residue is represented by up to 14 heavy atoms in a residue-type-specific order,
+the representation RFdiffusion3 uses. Slots 0-3 are always the backbone N, CA, C, O,
+so backbone-only logic stays valid on an all-atom array. Tryptophan fills all 14.
+"""
+
+ATOM14 = {
+    "ALA": ["N", "CA", "C", "O", "CB"],
+    "ARG": ["N", "CA", "C", "O", "CB", "CG", "CD", "NE", "CZ", "NH1", "NH2"],
+    "ASN": ["N", "CA", "C", "O", "CB", "CG", "OD1", "ND2"],
+    "ASP": ["N", "CA", "C", "O", "CB", "CG", "OD1", "OD2"],
+    "CYS": ["N", "CA", "C", "O", "CB", "SG"],
+    "GLN": ["N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "NE2"],
+    "GLU": ["N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "OE2"],
+    "GLY": ["N", "CA", "C", "O"],
+    "HIS": ["N", "CA", "C", "O", "CB", "CG", "ND1", "CD2", "CE1", "NE2"],
+    "ILE": ["N", "CA", "C", "O", "CB", "CG1", "CG2", "CD1"],
+    "LEU": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2"],
+    "LYS": ["N", "CA", "C", "O", "CB", "CG", "CD", "CE", "NZ"],
+    "MET": ["N", "CA", "C", "O", "CB", "CG", "SD", "CE"],
+    "PHE": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ"],
+    "PRO": ["N", "CA", "C", "O", "CB", "CG", "CD"],
+    "SER": ["N", "CA", "C", "O", "CB", "OG"],
+    "THR": ["N", "CA", "C", "O", "CB", "OG1", "CG2"],
+    "TRP": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "NE1", "CE2", "CE3",
+            "CZ2", "CZ3", "CH2"],
+    "TYR": ["N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "OH"],
+    "VAL": ["N", "CA", "C", "O", "CB", "CG1", "CG2"],
+}
+
+# OXT, the C-terminal carboxyl oxygen, is deliberately absent: it occurs once per
+# chain and AlphaFold's atom14 layout omits it too. Parsers skip it rather than fail.
+IGNORED_ATOMS = {"OXT"}
+
+ATOM14_WIDTH = 14
+BACKBONE_SLOTS = (0, 1, 2, 3)
+BACKBONE_ATOMS = ("N", "CA", "C", "O")
+
+RESTYPES = tuple(sorted(ATOM14))
+RESTYPE_INDEX = {name: index for index, name in enumerate(RESTYPES)}
+
+THREE_TO_ONE = {
+    "ALA": "A", "ARG": "R", "ASN": "N", "ASP": "D", "CYS": "C", "GLN": "Q",
+    "GLU": "E", "GLY": "G", "HIS": "H", "ILE": "I", "LEU": "L", "LYS": "K",
+    "MET": "M", "PHE": "F", "PRO": "P", "SER": "S", "THR": "T", "TRP": "W",
+    "TYR": "Y", "VAL": "V",
+}
+
+# Alternative naming for symmetric sidechain tips: these pairs are indistinguishable
+# by the physics, so a motif RMSD must take the better of the two assignments.
+SYMMETRIC_SWAPS = {
+    "ARG": [("NH1", "NH2")],
+    "ASP": [("OD1", "OD2")],
+    "GLU": [("OE1", "OE2")],
+    "PHE": [("CD1", "CD2"), ("CE1", "CE2")],
+    "TYR": [("CD1", "CD2"), ("CE1", "CE2")],
+}
+
+
+def atom_slot(residue_name, atom_name):
+    """Index of `atom_name` within the residue's atom14 layout, or None."""
+    names = ATOM14.get(residue_name)
+    if names is None or atom_name not in names:
+        return None
+    return names.index(atom_name)

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/LICENSE.md

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Institute for Protein Design, University of Washington
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of the copyright holder nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/callbacks/default.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - train_logging
+  - metrics_logging
+  - dump_validation_structures
+  - _self_

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/callbacks/dump_validation_structures.yaml

@@ -0,0 +1,6 @@
+dump_validation_structures_callback:
+    _target_: rf3.callbacks.dump_validation_structures.DumpValidationStructuresCallback
+    save_dir: ${paths.output_dir}/val_structures
+    dump_predictions: True
+    one_model_per_file: False
+    dump_trajectories: False

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/callbacks/metrics_logging.yaml

@@ -0,0 +1,10 @@
+store_validation_metrics_in_df_callback:
+    _target_: rf3.callbacks.metrics_logging.StoreValidationMetricsInDFCallback
+    save_dir: ${paths.output_dir}/val_metrics
+    metrics_to_save: "all"
+
+log_af3_validation_metrics_callback:
+    _target_: rf3.callbacks.metrics_logging.LogAF3ValidationMetricsCallback
+    # Only logs if present in the metric output dictionary
+    # Must be subset of metrics_to_save
+    metrics_to_log:  "all"

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/callbacks/train_logging.yaml

@@ -0,0 +1,16 @@
+log_af3_training_losses_callback:
+    _target_: foundry.callbacks.train_logging.LogAF3TrainingLossesCallback
+    log_every_n: 10
+    log_full_batch_losses: true
+
+log_learning_rate_callback:
+    _target_: foundry.callbacks.train_logging.LogLearningRateCallback
+    log_every_n: 10
+
+log_model_parameters_callback:
+    _target_: foundry.callbacks.train_logging.LogModelParametersCallback
+
+log_dataset_sampling_ratios_callback:
+    _target_: foundry.callbacks.train_logging.LogDatasetSamplingRatiosCallback
+
+

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/dataloader/default.yaml

@@ -0,0 +1,15 @@
+train: 
+  dataloader_params:
+    # These parameters will be unpacked as kwargs for the DataLoader
+    batch_size: 1
+    num_workers: 2
+    prefetch_factor: 3
+  n_fallback_retries: 4
+
+val: 
+  dataloader_params:
+    # These parameters will be unpacked as kwargs for the DataLoader
+    batch_size: 1
+    num_workers: 2
+    prefetch_factor: 3
+  n_fallback_retries: 0 # Disable fallback retries for validation

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/datasets/base.yaml

@@ -0,0 +1,31 @@
+# Base Transform defaults
+diffusion_batch_size_train: 48
+diffusion_batch_size_inference: 5
+
+n_recycles_train: 4
+n_recycles_validation: 10
+
+run_confidence_head: false
+
+# Conditioning
+p_unconditional: 0.9
+
+# Embeddings
+p_dropout_atom_level_embeddings: 0.5
+
+n_msa: 1024
+crop_size: 384
+max_atoms_in_crop: 5000 
+
+key_to_balance: n_tokens_total
+
+take_first_chiral_subordering: false
+use_element_for_atom_names_of_atomized_tokens: true
+mirror_prob: 0.02
+atomization_prob: 0.02
+ligand_dropout_prob: 0.0
+
+add_residue_is_paired_feature: true
+
+add_cyclic_bonds: true
+

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/datasets/pdb_and_distillation.yaml

@@ -0,0 +1,55 @@
+# AF3 dataset configuration with monomer distillation
+
+defaults:
+  - base
+  # The @ symbol specifies the tree under which the item will be attached to the config
+  - train/pdb/train_interface@train.pdb.sub_datasets.interface
+  - train/pdb/train_pn_unit@train.pdb.sub_datasets.pn_unit
+  - train:
+    - monomer_distillation
+    - na_complex_distillation
+    - disorder_distillation
+    # - rna_monomer_distillation
+  - val/af3_validation@val.af3_validation
+  - val/af3_validation@val.quick_af3_validation_with_templating
+  - _self_
+
+# Dataloading pipeline to use
+pipeline_target: rf3.data.pipelines.build_af3_transform_pipeline
+
+# Dataset weighting
+train: 
+  pdb:
+    probability: 0.50
+  monomer_distillation:
+    probability: 0.46
+  na_complex_distillation:
+    probability: 0.02
+  disorder_distillation:
+    probability: 0.02
+  # rna_monomer_distillation:
+  #   probability: 0.04
+
+val:
+  quick_af3_validation_with_templating:
+    dataset:
+      dataset:
+        filters:
+          # Only score examples with protein-ligand interfaces
+          - "interfaces_to_score.str.contains('protein-ligand')"
+          # Small examples only - very fast
+          - "n_tokens_total < 400"
+      transform:
+        # +-- Conditioning --+
+        p_unconditional: 0.0 # Always show conditioning
+        # (Templates)
+        template_noise_scales:
+          not_atomized: 1e-4 # No noise on polymer atoms (epsilon to avoid division by zero)
+          atomized: 1e-4 # No noise on ligand atoms (epsilon to avoid division by zero)
+        allowed_chain_types_for_conditioning:
+          _target_: atomworks.enums.ChainType.get_all_types
+        p_condition_per_token: 1.0 # Always condition
+        p_provide_inter_molecule_distances: 0.0 # No inter-chain distances
+        # (Reference conformer)
+        p_give_non_polymer_ref_conf: 1.0 # Always give non-polymer reference conformers
+        p_give_polymer_ref_conf: 1.0 # Always give polymer reference conformers

tasks/protein-design/protein-design-astra-xhigh-1h100-48h-20261022a/submissions/S001/rfd3/models/rf3/configs/datasets/pdb_only.yaml

@@ -0,0 +1,17 @@
+# AF3 dataset configuration with monomer distillation
+
+defaults:
+  - base
+  # The @ symbol specifies the tree under which the item will be attached to the config
+  - train/pdb/train_interface@train.pdb.sub_datasets.interface
+  - train/pdb/train_pn_unit@train.pdb.sub_datasets.pn_unit
+  - val/af3_validation@val.af3_validation
+  - _self_
+
+# Dataloading pipeline to use
+pipeline_target: rf3.data.pipelines.build_af3_transform_pipeline
+
+# Dataset weighting
+train: 
+  pdb:
+    probability: 1.0