Release GEOM scaffold substituent LoRA rank-16 checkpoint after 25 epochs

geom/scaffold_murcko_substituent_lora_r16/README.md

@@ -0,0 +1,40 @@
+# GEOM scaffold decoration: 25 completed fine-tuning epochs
+
+This is the original checkpoint from the latest GEOM Murcko scaffold fine-tuning run,
+with rank-16 LoRA, trainable output heads, and substituent-constrained insertion
+supervision. It starts from GEOM explicit-H epoch 100 EMA weights. The stored
+Lightning epoch is 24; 25 fine-tuning epochs have completed (199,100 steps).
+
+This conditional checkpoint requires a scaffold. Use its saved architecture and
+configuration; the unconditional `morph generate` interface/catalog does not load it.
+Both current and EMA networks and optimizer state are retained. EMA is used for evaluation.
+Scaffold atom identities, internal bonds and charges are preserved; positions can move.
+Substituent assignment affects training supervision and does not require hidden target
+bonds at generation time.
+
+## Files and reproduction
+
+- `epoch_025.ckpt`: unmodified original checkpoint; `metadata.json` records its SHA-256.
+- `training_config.yaml`: original composed training configuration, including provenance paths.
+- `config.yaml`: equivalent configuration with portable asset/data paths and base loading disabled.
+- Ordered atom/edge/charge vocabularies and `distributions.pt`: exact model assets.
+- `panels/`: fixed 512-scaffold validation and test selections, with eight attempts per scaffold.
+- `training_source.tar.gz`: original frozen training source, training manifest, and insertion-assignment audit.
+- `runtime/`: evaluation source snapshot, including corrected raw-graph RDKit stability.
+- `evaluate.py`: evaluation/preflight/aggregation driver; `manifest.json` hashes every release file.
+
+In an existing compatible Morph environment, set `PYTHONPATH` to `runtime/src:runtime`
+and run `evaluate.py preflight --bundle <this-folder> --data-root <GEOM-root>
+--output <results-folder>`. The GEOM root must contain the matching processed data and
+scaffold caches. The script sets portable asset environment variables itself.
+
+The cluster evaluation uses the held-out **test panel, 512 × 8 attempts × seeds 42/43/44**,
+100 integration steps, EMA weights, and no inference scaffold jitter. It reports native
+scaffold metrics, strict and scaffold-aware PoseBusters, raw-graph stability, chemistry,
+and distribution/geometry diagnostics. Native PoseBusters omits the separate full offline
+energy/flatness checks. All scalar metrics are aggregated into one `summary.csv`.
+
+The evaluation driver requires a completed upload-verification JSON before generation;
+this is a provenance guard for this release. Generated coordinates are not relaxed by this
+scaffold evaluation. The checkpoint/configuration hashes and original training archive
+allow the training and evaluation implementations to be distinguished.

geom/scaffold_murcko_substituent_lora_r16/atom_tokens.txt

@@ -0,0 +1,10 @@
+Br
+C
+Cl
+F
+H
+I
+N
+O
+P
+S

geom/scaffold_murcko_substituent_lora_r16/charge_tokens.txt

@@ -0,0 +1,5 @@
+-2
+-1
+0
+1
+2

geom/scaffold_murcko_substituent_lora_r16/config.yaml

@@ -0,0 +1,461 @@
+representation: molecule
+seed: 42
+heads:
+  heads:
+    _target_: morph.model.layers.heads.MultiHeadModule
+    output_init_std: ${model.head_initialization.output_std}
+    independent_adapters: ${oc.select:model.head_independent_adapters,false}
+    heads_configs:
+      graph_aggregation: mean
+      node_heads:
+        atom_type_head:
+          input_dim: ${model.head_node_dim}
+          output_dim: ${len:${data.vocab.atom_tokens}}
+          adapter_dim: ${model.head_node_adapter_dim}
+          group: state
+        charge_head:
+          input_dim: ${model.head_node_dim}
+          output_dim: ${len:${data.vocab.charge_tokens}}
+          adapter_dim: ${model.head_node_adapter_dim}
+          group: state
+        ins_rate_head:
+          input_dim: ${model.head_node_dim}
+          output_dim: 1
+          adapter_dim: ${model.head_node_adapter_dim}
+          group: edit
+          initial_rate: ${model.head_initialization.ins_rate}
+        do_del_head:
+          input_dim: ${model.head_node_dim}
+          output_dim: 1
+          adapter_dim: ${model.head_node_adapter_dim}
+          group: edit
+          initial_probability: ${model.head_initialization.do_del_probability}
+        do_sub_a_head:
+          input_dim: ${model.head_node_dim}
+          output_dim: 1
+          adapter_dim: ${model.head_node_adapter_dim}
+          group: edit
+          initial_probability: ${model.head_initialization.do_sub_a_probability}
+      edge_heads:
+        edge_type_head:
+          input_dim: ${model.head_edge_dim}
+          output_dim: ${len:${data.vocab.edge_tokens}}
+          adapter_dim: ${model.head_edge_adapter_dim}
+          group: state
+        do_sub_e_head:
+          input_dim: ${model.head_edge_dim}
+          output_dim: 1
+          adapter_dim: ${model.head_edge_adapter_dim}
+          group: state
+          initial_probability: ${model.head_initialization.do_sub_e_probability}
+  ins_edge_head:
+    _target_: morph.model.layers.heads.InsertionEdgeHead
+    _recursive_: false
+    hidden_dim: ${model.head_node_dim}
+    readout_dim: ${model.head_insertion_edge_dim}
+    output_init_std: ${model.head_initialization.output_std}
+    n_edge_types: ${len:${data.vocab.edge_tokens}}
+    n_atom_types: ${len:${data.vocab.atom_tokens}}
+    n_charge_types: ${len:${data.vocab.charge_tokens}}
+    rbf_embedding_args:
+      _target_: morph.model.layers.embedding.RBFEmbedding
+      num_rbf: 128
+      rbf_dmax: 3.5
+      out_dim: 64
+      dropout: 0.0
+      trainable: false
+insertion_head:
+  mode: unimodal
+  dimension: 3
+  num_components: 1
+  model:
+    _target_: morph.model.layers.heads.UnimodalInsertionHead
+    hidden_dim: ${model.head_node_dim}
+    readout_dim: ${model.head_insertion_adapter_dim}
+    output_init_std: ${model.head_initialization.output_std}
+    independent_adapters: ${oc.select:model.head_independent_adapters,false}
+    N_a: ${len:${data.vocab.atom_tokens}}
+    N_c: ${len:${data.vocab.charge_tokens}}
+model:
+  module:
+    optimizer_config:
+      implementation: torch
+      optimizer:
+        execution: ${oc.env:MORPH_MUON_EXECUTION,native}
+        lr: 0.001
+        momentum: 0.95
+        weight_decay: 0.0
+        nesterov: true
+        ns_steps: 5
+        eps: 1.0e-07
+        adjust_lr_fn: original
+      aux_optimizer:
+        lr: 0.0001
+        betas:
+        - 0.9
+        - 0.95
+        eps: 1.0e-10
+        weight_decay: 0.0
+      gradient_clip_val: 1.0
+      gradient_clip_algorithm: norm
+      scheduler:
+        _target_: morph.utils.lr_schedulers.MultiGroupCosineWarmupLR
+        warmup_steps: 2000
+        total_steps: 200000
+        min_lr_fraction: 0.05
+        last_epoch: -1
+      interval: step
+      monitor: null
+    loss_weights:
+      do_sub_a: 0.2
+      sub_a_class: 0.03
+      do_sub_e: 0.25
+      sub_e_class: 0.5
+      do_del: 0.4
+      ins_rate: 0.15
+      ins_state: 0.01
+      ins_e: 0.4
+      x: 2.0
+      c: 0.5
+      ins_e_ii: 0.03
+    _target_: morph.model.finetune.scaffold.LightningModuleRatesScaffoldFinetune
+    insertion_head_mode: ${insertion_head.mode}
+    ins_noise_scale: ${data.ins_noise_scale}
+    ema_decay: 0.999
+    ema_warmup_steps: 5000
+    use_ema_for_eval: true
+    time_dist: ${if:${eq:${model.sample_time_strategy}, log}, ${model.beta_sched},
+      ${model.linear_sched}}
+    integrator: ${model.integrator}
+    vocab: ${data.vocab}
+    use_learnable_loss_weights: false
+    use_time_weights: false
+    model:
+      _target_: morph.model.finetune.scaffold.ScaffoldConditionalDiTBackboneWithHeads
+      _recursive_: false
+      atom_type_embedding_args: ${embeddings.atom_type_embedding}
+      edge_type_embedding_args: ${embeddings.edge_type_embedding}
+      time_embedding_args: ${embeddings.time_embedding}
+      node_count_embedding_args: ${embeddings.node_count_embedding}
+      incident_bond_embedding: false
+      backbone_model_args: ${model.backbone}
+      heads_args: ${heads.heads}
+      insertion_head_args: ${insertion_head.model}
+      ins_edge_head_args: ${heads.ins_edge_head}
+      xattn_encoder_args: ${model.xattn_encoder}
+      use_distance_bias: true
+    pretrained_ckpt: null
+    pretrained_prefer_ema: true
+    freeze_pretrained_backbone: true
+    freeze_output_heads: false
+    exclude_scaffold_from_sub_loss: true
+    exclude_scaffold_from_x_loss: false
+    freeze_keep_positions: false
+    freeze_keep_charges: true
+  rotate: true
+  n_augmentations: 1
+  integrator: ${integrator.integrator}
+  beta_sched:
+    _target_: torch.distributions.Beta
+    concentration1: 2.0
+    concentration0: 1.0
+  linear_sched:
+    _target_: torch.distributions.Uniform
+    low: 0.0
+    high: 1.0
+  sample_time_strategy: linear
+  head_node_dim: ${model.backbone.out_node_nf}
+  head_edge_dim: ${model.backbone.out_edge_nf}
+  head_node_adapter_dim: 256
+  head_edge_adapter_dim: 256
+  head_insertion_adapter_dim: 256
+  head_insertion_edge_dim: 256
+  head_independent_adapters: true
+  head_initialization:
+    output_std: 0.001
+    coordinate_output_std: 0.0
+    do_del_probability: 0.5
+    do_sub_a_probability: 0.5
+    do_sub_e_probability: 0.5
+    ins_rate: 0.6931471805599453
+  token_weighting:
+    type_loss_token_weights: uniform
+    weight_alpha: 0.4
+  lora:
+    enabled: true
+    rank: 16
+    alpha: 16.0
+    dropout: 0.0
+    targets:
+    - qkv
+    - proj
+    - mlp.gate_value
+    - mlp.out_proj
+    freeze_base: true
+  backbone:
+    _target_: morph.model.backbones.conditional_dit.ConditionalDiTBackbone
+    _recursive_: false
+    d_input: ${embeddings.atom_type_embedding.out_dim}
+    d_cond: ${oc.eval:"${embeddings.time_embedding.out_dim} + ${embeddings.node_count_embedding.out_dim}"}
+    d_model: 512
+    out_node_nf: 256
+    out_edge_nf: 256
+    num_layers: 8
+    nhead: 16
+    mlp_ratio: 4.0
+    ffn_hidden_dim: null
+    ffn_multiple_of: 64
+    qk_norm: true
+    coordinate_output_init_std: ${model.head_initialization.coordinate_output_std}
+    center_coordinate_output: true
+    in_edge_nf: ${embeddings.edge_type_embedding.out_dim}
+    edge_pair_dim: 256
+    pair_bias_hidden_dim: 32
+    num_atom_types: ${len:${data.vocab.atom_tokens}}
+    lora: ${model.lora}
+    rbf_embedding_args:
+      _target_: morph.model.layers.embedding.RBFEmbedding
+      num_rbf: 128
+      rbf_dmax: 3.5
+      out_dim: 64
+      dropout: 0.0
+      trainable: false
+    ctx_dim: 128
+    use_cross_attn: true
+    use_node_cond: true
+    use_edge_cond: true
+  xattn_encoder:
+    _target_: morph.model.finetune.base.LightweightContextEncoder
+    num_atom_types: ${len:${data.vocab.atom_tokens}}
+    num_charges: ${len:${data.vocab.charge_tokens}}
+    atom_embed_dim: 64
+    charge_embed_dim: 16
+    pos_embed_dim: 32
+    ctx_dim: ${model.backbone.ctx_dim}
+    num_attn_layers: 4
+    nhead: 8
+    mlp_ratio: 4.0
+    dropout: 0.0
+    use_pair_bias: true
+    num_edge_types: ${len:${data.vocab.edge_tokens}}
+    edge_embed_dim: 32
+    num_rbf: 32
+    rbf_dmax: 5.0
+    pair_bias_hidden_dim: 32
+schedule:
+  _target_: morph.flow_matching.schedules.SmoothstepSchedule
+  shift: 0.8
+trainer:
+  trainer:
+    deterministic: warn
+    devices: 2
+    accelerator: gpu
+    strategy: ddp_find_unused_parameters_false
+    precision: bf16-mixed
+    max_epochs: 50
+    accumulate_grad_batches: 1
+    num_sanity_val_steps: 0
+    gradient_clip_val: null
+    gradient_clip_algorithm: norm
+    check_val_every_n_epoch: 1
+    num_val_samples: 4096
+    limit_val_batches: null
+    limit_predict_batches: 4
+    enable_progress_bar: false
+    max_time:
+      hours: 0
+      seconds: 169927
+  do_train: true
+  do_validate: false
+  do_predict: false
+  checkpoint_path: null
+  final_checkpoint_path: final.ckpt
+callbacks: {}
+logging:
+  enabled: false
+  project: morph-geom-scaffold-decoration
+  name: ${oc.env:MORPH_RUN_ID,base}
+  save_dir: .
+  offline: false
+  group: geom-e100-murcko-original-50ep-20261010
+  tags:
+  - substituent-insertion
+  - rank-16
+  - scaffold-decoration
+  - bemis-murcko
+  - geom-e100
+  - lora
+  - trainable-heads
+  - movable-scaffold
+  - jitter-0.1A
+  - scaffold-metrics
+integrator:
+  integrator:
+    _target_: morph.flow_matching.integration.RateIntegrator
+    vocab: ${data.vocab}
+    distributions: None
+    insertion_head_mode: ${insertion_head.mode}
+    insertion_dimension: ${insertion_head.dimension}
+    insertion_num_components: ${insertion_head.num_components}
+    time_strategy: log
+    time_beta_alpha: 2.0
+    time_beta_beta: 1.0
+    num_integration_steps: 100
+    ins_noise_scale: ${data.ins_noise_scale}
+    renoise_insertions: true
+    exact_schedule_integration: true
+    del_schedule: ${data.interpolator.del_schedule}
+    ins_schedule: ${data.interpolator.ins_schedule}
+    sub_schedule: ${data.interpolator.sub_schedule}
+    sub_e_schedule: ${data.interpolator.sub_e_schedule}
+data:
+  root_path: ${oc.env:PROJECT_ROOT}/data
+  preprocess_workers: 10
+  preprocess_chunk_size: 128
+  statistics_workers: ${data.preprocess_workers}
+  hydrogen_mode: explicit
+  cache_name: ${data.dataset_name}${if:${eq:${data.hydrogen_mode},implicit},_implicit_h,''}
+  source_dir: ${oc.env:GEOM_SOURCE_DIR,null}
+  max_atoms: 72
+  allowed_atom_symbols:
+  - H
+  - C
+  - 'N'
+  - O
+  - S
+  - F
+  - Cl
+  - Br
+  - P
+  - I
+  n_atoms_strategy: uniform
+  uniform_n_atoms_padding: 5
+  optimal_transport: equivariant
+  ins_noise_scale: 0.65
+  move_noise_scale: 0.5
+  allow_charged: true
+  preprocessing:
+    _target_: morph.dataset.core.preprocessing.Preprocessing
+    _recursive_: false
+    root: ${oc.env:MORPH_GEOM_ROOT}
+    num_workers: ${data.statistics_workers}
+    train_dataset: ${data.datamodule.datasets.train}
+    atom_tokens_path: ${oc.env:MORPH_SCAFFOLD_BUNDLE}/atom_tokens.txt
+    edge_tokens_path: ${oc.env:MORPH_SCAFFOLD_BUNDLE}/edge_tokens.txt
+    charge_tokens_path: ${oc.env:MORPH_SCAFFOLD_BUNDLE}/charge_tokens.txt
+    distributions_path: ${oc.env:MORPH_SCAFFOLD_BUNDLE}/distributions.pt
+  vocab: null
+  interpolator:
+    _target_: morph.flow_matching.interpolation.Interpolator
+    distributions: null
+    optimal_transport: ${data.optimal_transport}
+    ins_noise_scale: ${data.ins_noise_scale}
+    move_noise_scale: ${data.move_noise_scale}
+    atom_type_noise_prob: 0.0
+    pre_align_iters: 2
+    c_move: 1.0
+    c_sub: 0.0
+    c_ins: 6.125
+    c_del: 6.125
+    del_schedule: ${schedule}
+    ins_schedule: ${schedule}
+    sub_schedule:
+      _target_: morph.flow_matching.schedules.SmoothstepSchedule
+      shift: 1.5
+    sub_e_schedule:
+      _target_: morph.flow_matching.schedules.SmoothstepSchedule
+      shift: 1.5
+    jitter_scale: ${data.jitter_scale}
+    insertion_assignment: ${data.insertion_assignment}
+  datamodule:
+    _target_: morph.dataset.conditional.scaffold.datamodule.ScaffoldLightningDataModule
+    vocab: ${data.vocab}
+    distributions: null
+    representation: ${representation}
+    datasets:
+      train:
+        _target_: ${data.dataset_target}
+        root: ${data.preprocessing.root}
+        preprocess_workers: ${data.preprocess_workers}
+        preprocess_chunk_size: ${data.preprocess_chunk_size}
+        hydrogen_mode: ${data.hydrogen_mode}
+        source_dir: ${data.source_dir}
+        max_atoms: ${data.max_atoms}
+        allowed_atom_symbols: ${data.allowed_atom_symbols}
+        vocab: ${data.vocab}
+        distributions: null
+      val:
+      - _target_: ${data.dataset_target}
+        root: ${data.preprocessing.root}
+        preprocess_workers: ${data.preprocess_workers}
+        preprocess_chunk_size: ${data.preprocess_chunk_size}
+        hydrogen_mode: ${data.hydrogen_mode}
+        source_dir: ${data.source_dir}
+        max_atoms: ${data.max_atoms}
+        allowed_atom_symbols: ${data.allowed_atom_symbols}
+        vocab: ${data.vocab}
+        distributions: null
+      test:
+      - _target_: ${data.dataset_target}
+        root: ${data.preprocessing.root}
+        preprocess_workers: ${data.preprocess_workers}
+        preprocess_chunk_size: ${data.preprocess_chunk_size}
+        hydrogen_mode: ${data.hydrogen_mode}
+        source_dir: ${data.source_dir}
+        max_atoms: ${data.max_atoms}
+        allowed_atom_symbols: ${data.allowed_atom_symbols}
+        vocab: ${data.vocab}
+        distributions: null
+    interpolator: ${data.interpolator}
+    rotate: ${model.rotate}
+    n_augmentations: ${model.n_augmentations}
+    num_workers:
+      train: 20
+      val: 0
+      test: 0
+    batch_size:
+      train: 320
+      val: 32
+      test: 32
+    n_atoms_strategy: ${data.n_atoms_strategy}
+    uniform_n_atoms_padding: ${data.uniform_n_atoms_padding}
+    time_dist: ${model.module.time_dist}
+    scaffold_groups_dir: ${data.scaffold_groups_dir}
+    scaffold_kind: ${data.scaffold_kind}
+    enumerate_slicings: ${data.enumerate_slicings}
+    eval_panel: ${data.eval_panel}
+    train_prefetch_factor: 1
+  dataset_name: geom
+  dataset_target: morph.dataset.unconditional.geom.FlowMatchingGEOMDataset
+  scaffold_groups_dir: ${data.preprocessing.root}/processed/scaffold_groups
+  scaffold_kind: murcko
+  jitter_scale: 0.1
+  insertion_assignment: substituent
+  enumerate_slicings: false
+  eval_panel:
+    directory: ${oc.env:MORPH_SCAFFOLD_BUNDLE}/panels
+    n_scaffolds: 512
+    samples_per_scaffold: 8
+    seed: 42
+embeddings:
+  atom_type_embedding:
+    _target_: morph.model.layers.embedding.Embedding
+    num_embeddings: ${len:${data.vocab.atom_tokens}}
+    embedding_dim: 64
+    out_dim: 128
+  edge_type_embedding:
+    _target_: morph.model.layers.embedding.Embedding
+    num_embeddings: ${len:${data.vocab.edge_tokens}}
+    embedding_dim: 64
+    out_dim: 128
+  time_embedding:
+    _target_: morph.model.layers.embedding.TimeEmbedding
+    embedding_dim: 128
+    out_dim: 128
+  node_count_embedding:
+    _target_: morph.model.layers.embedding.ExtrapolatableCountEmbedding
+    embedding_dim: 64
+    out_dim: 128
+    min_period: 128.0
+    max_period: 1024.0
+    max_count: 96.0

geom/scaffold_murcko_substituent_lora_r16/distributions.pt

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

geom/scaffold_murcko_substituent_lora_r16/edge_tokens.txt

@@ -0,0 +1,4 @@
+<NO_BOND>
+1
+2
+3

geom/scaffold_murcko_substituent_lora_r16/epoch_025.ckpt

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

geom/scaffold_murcko_substituent_lora_r16/evaluate.py

@@ -0,0 +1,221 @@
+"""Evaluate the released scaffold checkpoint on a fixed panel for three seeds."""
+from __future__ import annotations
+
+import argparse
+import csv
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import statistics
+import time
+import types
+
+import pytorch_lightning as pl
+import torch
+from omegaconf import OmegaConf
+from rdkit import Chem, rdBase
+
+import morph.config  # noqa: F401
+from morph.inference.generate import _build_module, load_checkpoint
+
+
+def sha(path):
+    with Path(path).open("rb") as f:
+        return hashlib.file_digest(f, "sha256").hexdigest()
+
+
+def clean(value):
+    if isinstance(value, torch.Tensor):
+        return clean(value.item())
+    if isinstance(value, float) and not math.isfinite(value):
+        return None
+    if isinstance(value, dict):
+        return {key: clean(item) for key, item in value.items()}
+    if isinstance(value, (list, tuple)):
+        return [clean(item) for item in value]
+    return value
+
+
+def write_json(path, value):
+    path.write_text(json.dumps(clean(value), indent=2, allow_nan=False) + "\n")
+
+
+def configuration(bundle, data_root, seed, output):
+    os.environ["MORPH_SCAFFOLD_BUNDLE"] = str(bundle)
+    os.environ["MORPH_GEOM_ROOT"] = str(data_root)
+    os.environ.setdefault("PROJECT_ROOT", str(bundle / "runtime"))
+    os.environ.setdefault("HYDRA_JOBS", str(output))
+    cfg = OmegaConf.load(bundle / "config.yaml")
+    OmegaConf.set_struct(cfg, False)
+    cfg.seed = seed
+    cfg.callbacks = {}
+    cfg.logging.enabled = False
+    cfg.trainer.do_train = False
+    cfg.trainer.do_validate = True
+    cfg.trainer.do_predict = False
+    cfg.trainer.trainer.devices = 1
+    cfg.trainer.trainer.strategy = "auto"
+    cfg.trainer.trainer.enable_checkpointing = False
+    cfg.trainer.trainer.num_val_samples = 4096
+    cfg.trainer.trainer.limit_val_batches = 128
+    cfg.trainer.trainer.default_root_dir = str(output)
+    cfg.trainer.trainer.pop("max_time", None)
+    cfg.data.datamodule.num_workers.train = 0
+    cfg.data.datamodule.num_workers.val = 0
+    cfg.data.datamodule.num_workers.test = 0
+    return cfg
+
+
+def preflight(args):
+    torch.set_num_threads(1)
+    bundle = args.bundle.resolve()
+    metadata = json.loads((bundle / "metadata.json").read_text())
+    checkpoint = bundle / "epoch_025.ckpt"
+    assert sha(checkpoint) == metadata["checkpoint_sha256"]
+    raw = torch.load(checkpoint, map_location="cpu", weights_only=False, mmap=True)
+    assert raw["epoch"] == 24 and raw["global_step"] == 199100
+    assert any("lora_" in key for key in raw["state_dict"])
+    cfg = configuration(bundle, args.data_root.resolve(), 42, args.output.resolve())
+    assert cfg.model.lora.rank == 16 and cfg.data.insertion_assignment == "substituent"
+    assert cfg.model.module.pretrained_ckpt is None and cfg.model.module.use_ema_for_eval
+    assert cfg.model.module.freeze_keep_charges and not cfg.model.module.freeze_keep_positions
+    module, vocab, distributions = _build_module(cfg)
+    load_checkpoint(module, checkpoint)
+    assert len(vocab.atom_tokens) == 10
+    for name, expected in metadata["panel_sha256"].items():
+        assert sha(bundle / "panels" / name) == expected
+    write_json(args.output / "preflight.json", {
+        "status": "passed", "checkpoint_sha256": metadata["checkpoint_sha256"],
+        "epoch_zero_based": raw["epoch"], "completed_finetuning_epochs": 25,
+        "global_step": raw["global_step"], "strict_state_dict_load": True,
+        "ema_available": any(k.startswith("model_ema.") for k in raw["state_dict"]),
+        "lora_rank": 16, "insertion_assignment": "substituent",
+        "atom_tokens": list(vocab.atom_tokens), "rdkit_version": rdBase.rdkitVersion,
+    })
+    print("Preflight passed: epoch 25, rank-16 LoRA, strict checkpoint load, verified panels.", flush=True)
+
+
+class Population(pl.Callback):
+    def __init__(self, output):
+        self.output = output
+
+    def on_validation_batch_end(self, trainer, module, outputs, batch, batch_idx, dataloader_idx=0):
+        if batch_idx % 16 == 0:
+            print(f"Generated {len(module._scaffold_rows)}/4096 attempts", flush=True)
+
+    def on_validation_epoch_end(self, trainer, module):
+        rows = module._scaffold_rows
+        assert len(rows) == 4096 and {r["sample_id"] for r in rows} == set(range(4096))
+        assert len({r["scaffold_id"] for r in rows}) == 512
+        assert len(module._validation_rdkit_mols) == len(rows)
+        with (self.output / "attempts.jsonl").open("w") as f, Chem.SDWriter(str(self.output / "generated.sdf")) as writer:
+            for row, mol in zip(rows, module._validation_rdkit_mols, strict=True):
+                entry = dict(row)
+                entry["sdf_written"] = False
+                if mol is not None:
+                    mol.SetProp("_Name", f"sample_{row['sample_id']:05d}")
+                    try:
+                        writer.write(mol)
+                        entry["sdf_written"] = True
+                    except Exception as exc:
+                        entry["sdf_error"] = str(exc)
+                f.write(json.dumps(clean(entry), allow_nan=False) + "\n")
+        print("Saved all attempts and original generated SDFs; computing scaffold and chemistry scores.", flush=True)
+
+
+def evaluate(args):
+    from run import setup
+
+    start = time.monotonic()
+    bundle = args.bundle.resolve()
+    work = args.output.resolve()
+    upload = json.loads((work / "upload_verification.json").read_text())
+    assert upload["status"] == "passed", "Upload must be verified before evaluation"
+    output = work / f"seed_{args.seed}"
+    output.mkdir(parents=True, exist_ok=False)
+    (output / "chunks").mkdir()
+    metadata = json.loads((bundle / "metadata.json").read_text())
+    assert sha(bundle / "epoch_025.ckpt") == metadata["checkpoint_sha256"]
+    cfg = configuration(bundle, args.data_root.resolve(), args.seed, output)
+    module, datamodule, trainer = setup(cfg, extra_callbacks=[Population(output)])
+    datamodule.setup("test")
+    panel = datamodule.test_datasets[0]
+    assert len(panel) == 4096 and len(panel.entries) == 512 and panel.samples_per_scaffold == 8
+    assert Path(panel.path).name == "test_murcko_512_seed42.json"
+    assert sha(panel.path) == metadata["panel_sha256"]["test_murcko_512_seed42.json"]
+    assert module.use_ema_for_eval
+    # Save every raw graph before sanitization failures can remove it from SDFs.
+    original_update = module._update_task_metrics
+    chunks = []
+
+    def capture(self, context, mols, rdkit_mols):
+        path = output / "chunks" / f"batch_{len(chunks):04d}.pt"
+        torch.save(mols, path)
+        chunks.append(path.name)
+        return original_update(context, mols, rdkit_mols)
+
+    module._update_task_metrics = types.MethodType(capture, module)
+    OmegaConf.save(cfg, output / "config.yaml", resolve=True)
+    values = trainer.validate(module, dataloaders=datamodule.test_dataloader(), ckpt_path=str(bundle / "epoch_025.ckpt"))
+    assert len(values) == 1
+    metrics = {k.removeprefix("val/"): v for k, v in values[0].items()}
+    required = {"validity", "novelty", "rdkit-atom-stability", "rdkit-molecule-stability",
+                "posebusters/validity", "scaffold/posebusters/validity", "scaffold/retention",
+                "scaffold/recovery", "scaffold/unique_yield", "scaffold/rmsd_aligned"}
+    assert required <= metrics.keys(), sorted(required - metrics.keys())
+    for key, value in {"n_scaffolds": 512, "n_samples": 4096, "min_samples_per_scaffold": 8, "max_samples_per_scaffold": 8}.items():
+        assert metrics[f"scaffold/{key}"] == value
+    assert len(chunks) == 128
+    report = {
+        "status": "completed", "split": "test", "seed": args.seed,
+        "n_attempts": 4096, "n_scaffolds": 512, "samples_per_scaffold": 8,
+        "weights": "EMA", "integration_steps": 100, "checkpoint_sha256": metadata["checkpoint_sha256"],
+        "uploaded_revision": upload["revision"], "metrics": metrics,
+        "rdkit_stability_population": "all raw generated graphs",
+        "posebusters_protocol": "native scaffold evaluation: chemistry and distance geometry; scaffold-aware inherited-clash attribution; excludes full offline energy and flatness",
+        "raw_graph_chunks": chunks, "panel_sha256": sha(panel.path),
+        "elapsed_seconds": time.monotonic()-start, "job_id": os.environ.get("SLURM_JOB_ID"),
+    }
+    write_json(output / "metrics.json", report)
+    print(json.dumps(clean(report), indent=2), flush=True)
+
+
+def aggregate(args):
+    work = args.output.resolve()
+    reports = [json.loads((work / f"seed_{seed}/metrics.json").read_text()) for seed in (42, 43, 44)]
+    assert all(r["status"] == "completed" for r in reports)
+    keys = set(reports[0]["metrics"])
+    assert all(set(r["metrics"]) == keys for r in reports)
+    assert len({r["checkpoint_sha256"] for r in reports}) == 1
+    assert len({r["panel_sha256"] for r in reports}) == 1
+    with (work / "summary.csv").open("w", newline="") as f:
+        writer = csv.DictWriter(f, fieldnames=["model", "completed_epochs", "split", "metric", "seed_42", "seed_43", "seed_44", "mean", "std", "n_seeds"])
+        writer.writeheader()
+        for key in sorted(keys):
+            values = [r["metrics"][key] for r in reports]
+            finite = [x for x in values if x is not None and math.isfinite(x)]
+            writer.writerow({"model": "geom-scaffold-murcko-substituent-lora-r16", "completed_epochs": 25,
+                             "split": "test", "metric": key, **dict(zip(["seed_42", "seed_43", "seed_44"], values)),
+                             "mean": statistics.mean(finite) if finite else None,
+                             "std": statistics.stdev(finite) if len(finite)>1 else None, "n_seeds": len(finite)})
+    write_json(work / "verification.json", {"status": "passed", "n_seeds": 3, "n_attempts": 12288, "n_metrics": len(keys),
+               "summary_sha256": sha(work / "summary.csv"), "checkpoint_sha256": reports[0]["checkpoint_sha256"]})
+    print(f"Verified {len(keys)} metrics across 3 seeds; all metrics in {work / 'summary.csv'}", flush=True)
+
+
+def main():
+    p = argparse.ArgumentParser()
+    p.add_argument("mode", choices=["preflight", "evaluate", "aggregate"])
+    p.add_argument("--bundle", type=Path, required=True)
+    p.add_argument("--data-root", type=Path, required=True)
+    p.add_argument("--output", type=Path, required=True)
+    p.add_argument("--seed", type=int, choices=[42, 43, 44], default=42)
+    args = p.parse_args()
+    args.output.mkdir(parents=True, exist_ok=True)
+    {"preflight": preflight, "evaluate": evaluate, "aggregate": aggregate}[args.mode](args)
+
+
+if __name__ == "__main__":
+    main()

geom/scaffold_murcko_substituent_lora_r16/manifest.json

@@ -0,0 +1,750 @@
+{
+  "README.md": {
+    "bytes": 2752,
+    "sha256": "3879125c6ede15b8b268f316c5c2163b1af0fb795582c3e4685acb029f52b74f"
+  },
+  "atom_tokens.txt": {
+    "bytes": 22,
+    "sha256": "c9b712563ad2509593aa48fddbb5145aa42a70c4791255b8eea2984f549cae6a"
+  },
+  "charge_tokens.txt": {
+    "bytes": 12,
+    "sha256": "e2533aa090751f1006a74d165aa2d4a7ac23dbf73a65eb624c2a81216cc7dff5"
+  },
+  "config.yaml": {
+    "bytes": 14715,
+    "sha256": "9db9f6c09bc55fb7b39b3b3b37155cefcf3255a8c5eb899fd80c08edf71aa7f1"
+  },
+  "distributions.json": {
+    "bytes": 220286,
+    "sha256": "17bcf85c09486e5070aa8b3be4f4411fa01e6b3cf1b39c5488a5f46149f52e0f"
+  },
+  "distributions.pt": {
+    "bytes": 63581,
+    "sha256": "40a31704ab58d0349daff35083d43dcf4771ef368fd9c8a8503c94fe844016c5"
+  },
+  "edge_tokens.txt": {
+    "bytes": 16,
+    "sha256": "42b635ef938d2ec5a601044e4b01f3f84ed121f1bfaac984d86f180a8ccba3fd"
+  },
+  "epoch_025.ckpt": {
+    "bytes": 638268597,
+    "sha256": "0f3b9d75897c951fdfe437bb10735fb371ea2f5e9ea982471c3c7bd73a160484"
+  },
+  "evaluate.py": {
+    "bytes": 10649,
+    "sha256": "ad57177b2289610ec10983c9f20480adca7e393166ffec78e9641d3546bc433c"
+  },
+  "metadata.json": {
+    "bytes": 1511,
+    "sha256": "f1200bd618873ce5ba3e1d0a3569cd852c6b1fbe6c7523863dfb567541228c1d"
+  },
+  "panels/test_murcko_512_seed42.json": {
+    "bytes": 226522,
+    "sha256": "5df2f8b632dd261098ee86581b748487163b10893d2a4462f3e52cd25130905b"
+  },
+  "panels/val_murcko_512_seed42.json": {
+    "bytes": 224341,
+    "sha256": "b30a2063ba1c74414a2bda387f9dc42ade8c82540d6ec36c58956c12bee64e44"
+  },
+  "panels/verification.json": {
+    "bytes": 282,
+    "sha256": "b8a24405b78b49524bd09fd2593f8686b7910680709aed1956b140c45ffbd342"
+  },
+  "runtime/README.md": {
+    "bytes": 8819,
+    "sha256": "5214473be19c41f94f4bace3188e2620cbff69610ee15d495aa97934bd7b30eb"
+  },
+  "runtime/configs/callbacks/callbacks.yaml": {
+    "bytes": 699,
+    "sha256": "dce0adebf5956dce687d64a074238f9c12866373bfe21df6658d967d6bfd1f90"
+  },
+  "runtime/configs/data/chembl3d/chembl3d.yaml": {
+    "bytes": 278,
+    "sha256": "a96974d90353a850c4a1d0bac27de5f1fc8724b81cc5bbc122aab6f76f3051c5"
+  },
+  "runtime/configs/data/chembl3d/implicit_h.yaml": {
+    "bytes": 81,
+    "sha256": "08da196d0288cf1fe4dba8dd407c49d9bee003607504beb59f79e5d6b9eaef0c"
+  },
+  "runtime/configs/data/chembl3d/max100.yaml": {
+    "bytes": 246,
+    "sha256": "052dba7b3f3efce990019518823476bd6bf1381bb5f606822c9fc7a485e6d0bf"
+  },
+  "runtime/configs/data/chembl3d/max100_implicit_h.yaml": {
+    "bytes": 79,
+    "sha256": "152325f11c7d1500469d4ee381100ae12247e6a2e0b90e5ef7501b405144bb2d"
+  },
+  "runtime/configs/data/crossdocked/finetune.yaml": {
+    "bytes": 2709,
+    "sha256": "ba3da996e4c0fd720d6403974f3a3ae851d5defb32a705e931a7bf3f031421f4"
+  },
+  "runtime/configs/data/crossdocked/scaffold_decoration.yaml": {
+    "bytes": 1171,
+    "sha256": "4498b88a65912705d49b4a3bf583f41329bbf9637f7250ee85bfbd677a8cb22d"
+  },
+  "runtime/configs/data/geom/geom.yaml": {
+    "bytes": 428,
+    "sha256": "736c04e86c029bed65ce3ed022f937dd418ddc70d4b9fc064b38d979bf29ee6d"
+  },
+  "runtime/configs/data/geom/implicit_h.yaml": {
+    "bytes": 73,
+    "sha256": "c6b3ff5496af997de0c28e5aa7265903d6d0c8b59aab001ab21d6a64baeb772a"
+  },
+  "runtime/configs/data/geom/scaffold_decoration.yaml": {
+    "bytes": 1630,
+    "sha256": "46ca8472be2cd145e526555c0130ccfbfa797c056f4000a9db382dc00edfbed4"
+  },
+  "runtime/configs/data/molecular.yaml": {
+    "bytes": 5005,
+    "sha256": "f79ade5ddbf7d08f2eecbb2aa9c3e6b182b8a8e7e48960aff5e5edda5601bdc9"
+  },
+  "runtime/configs/data/qm9/qm9.yaml": {
+    "bytes": 3648,
+    "sha256": "3beea93868a1e889b049dcc2ccbc3b7489fa4672e964138654bc512ea01ab9f2"
+  },
+  "runtime/configs/data/qm9/scaffold_decoration.yaml": {
+    "bytes": 1202,
+    "sha256": "54cf67421a15625ed9e53e1cb959dc5210106004715cbf6169c9d1bce0a87cfa"
+  },
+  "runtime/configs/default.yaml": {
+    "bytes": 1294,
+    "sha256": "bcf9744acbf53afa4305ffd6e9cf95e6f99571750488eaa8cad85896a51aca66"
+  },
+  "runtime/configs/defaults/chembl3d/chembl3d.yaml": {
+    "bytes": 90,
+    "sha256": "f09553bc670e6c87ac8c1f8bbd0a8df73f1e83b02a3dcf9d6d06b915ac3bce93"
+  },
+  "runtime/configs/defaults/chembl3d/implicit_h.yaml": {
+    "bytes": 102,
+    "sha256": "a0ee1440984eb4c9d3c96a5d1c18df9f59b8e42c499f8a340ccd8deb8c454cd8"
+  },
+  "runtime/configs/defaults/chembl3d/implicit_h_2x4090.yaml": {
+    "bytes": 331,
+    "sha256": "518571405333a40e1602ee4c77fd153b56fd53e77aaa2aaf530796142f58d4b8"
+  },
+  "runtime/configs/defaults/chembl3d/train_2x4090.yaml": {
+    "bytes": 826,
+    "sha256": "0e6b01b264ab1ae70ae7f144ecd0a03d242e24f02feb087e3d5e2b7bc24790da"
+  },
+  "runtime/configs/defaults/core.yaml": {
+    "bytes": 431,
+    "sha256": "0dcfb68e2fece1dc277f647d3b3769af882cf8175e0c3b479bc50029e2538b1c"
+  },
+  "runtime/configs/defaults/crossdocked/finetune.yaml": {
+    "bytes": 364,
+    "sha256": "d244463c3049387369b5d1d709986246e7cc6a77218a2147df0820b9fd8c5173"
+  },
+  "runtime/configs/defaults/crossdocked/scaffold_decoration.yaml": {
+    "bytes": 240,
+    "sha256": "db421328b9df620fee7f19c99cf10bc6a492f6eb81e17df67e72c7f1bd1da70f"
+  },
+  "runtime/configs/defaults/crossdocked/scaffold_decoration_2x4090.yaml": {
+    "bytes": 1187,
+    "sha256": "e6b3e0d004213db5d1291db43c21e8ada0f8b3be4b634a2615eb3a0fb58c7d23"
+  },
+  "runtime/configs/defaults/geom/geom.yaml": {
+    "bytes": 425,
+    "sha256": "f447a1bdd39e211b5cf43c4cce56e708da6472d58f79e87885621ec4899c1c8e"
+  },
+  "runtime/configs/defaults/geom/implicit_h.yaml": {
+    "bytes": 98,
+    "sha256": "9d3a188e6bd2a2b01609ba0d652184bb8a2f7e27fd89d4a3031568051cae605e"
+  },
+  "runtime/configs/defaults/geom/scaffold_decoration.yaml": {
+    "bytes": 1192,
+    "sha256": "dda529d12a8dfd3131dddc3baf7893ea6443c5f9fc9736704d8198f669ae4b7b"
+  },
+  "runtime/configs/defaults/geom/scaffold_decoration_2x4090.yaml": {
+    "bytes": 692,
+    "sha256": "301bf8d7446a6d9c10064ffc6c73b704ef15b4fe9bcc48aa8ce89ff732c632a1"
+  },
+  "runtime/configs/defaults/geom/scaffold_decoration_scratch_2x4090.yaml": {
+    "bytes": 955,
+    "sha256": "728e19428775722e8107f5ee069be1f9533bd43b22061648978369f686bad887"
+  },
+  "runtime/configs/defaults/qm9/qm9.yaml": {
+    "bytes": 429,
+    "sha256": "46070ea792300c0817c0acdff256181b21ef17dfe9f72070bb12da27dc28d534"
+  },
+  "runtime/configs/defaults/qm9/scaffold_decoration.yaml": {
+    "bytes": 694,
+    "sha256": "0fecd61454aec70caf87aa397e01eb0eaa2eb5072256d75c6c541196c5aedaa4"
+  },
+  "runtime/configs/defaults/qm9/train_2x4090.yaml": {
+    "bytes": 554,
+    "sha256": "43a835246afb7126786e8ffa71c8b80ed9db1ef3a16e5240f1eec7882a4ef5ba"
+  },
+  "runtime/configs/embeddings/geom.yaml": {
+    "bytes": 803,
+    "sha256": "06793f4d446d899197e3db28d064592af9049612ee78cb0718a63e3d6fdc3151"
+  },
+  "runtime/configs/embeddings/qm9.yaml": {
+    "bytes": 849,
+    "sha256": "de57af7f1ff9b44dbb952f852c0177789196105b77f396298ff8e0218c0626b7"
+  },
+  "runtime/configs/heads/head.yaml": {
+    "bytes": 2475,
+    "sha256": "238e2346041e0aedccd16a6ed4066e163004c0e45a2cbc6fd1f6d17e16eb44ed"
+  },
+  "runtime/configs/insertion_head/gmm.yaml": {
+    "bytes": 488,
+    "sha256": "1e26914eed9b4971e0f6ff0b61bbdb34103233d346719a55ba6273dd3d785c05"
+  },
+  "runtime/configs/insertion_head/unimodal.yaml": {
+    "bytes": 495,
+    "sha256": "547a6391c3b341e3e369f8f4c7aab9752c67dfbbb533388d25956e9011b305e8"
+  },
+  "runtime/configs/integrator/integrator.yaml": {
+    "bytes": 1580,
+    "sha256": "8f0d9aafb0b2727cd58154e1fd97df693c8b7d4f5a3fb5efcb9188553f54660f"
+  },
+  "runtime/configs/logging/wandb_logger.yaml": {
+    "bytes": 139,
+    "sha256": "a9a2787e048d4eb70f2ff3c49d4355f1a5a382047c8619203b1f9131d829928d"
+  },
+  "runtime/configs/loss_weights/calibrated_geom.yaml": {
+    "bytes": 644,
+    "sha256": "d4763c84aa9e1eb77fb2b456384332a4b3a84b072d560918b2357222a43f4ca1"
+  },
+  "runtime/configs/loss_weights/calibrated_geom_frozen.yaml": {
+    "bytes": 1141,
+    "sha256": "a08acb61d67a852051dbded08f8bb67f21101888fd0a22a96a522781d28c570d"
+  },
+  "runtime/configs/loss_weights/tuned_weights.yaml": {
+    "bytes": 420,
+    "sha256": "2bb5884465666d6fc638f787fd79257e4126c69a5cc55b55615fc45e02e65894"
+  },
+  "runtime/configs/loss_weights/uniform.yaml": {
+    "bytes": 336,
+    "sha256": "3c14d6443048f69d436fe03792703a33c67f368ecbb349de2fd145da4c96eabc"
+  },
+  "runtime/configs/model/backbones/dit.yaml": {
+    "bytes": 4039,
+    "sha256": "65b0f08be8fb307b8b01e7b460fd083fe60d48148fbece378d7e5a23dd4a9fb0"
+  },
+  "runtime/configs/model/finetune/lora_finetune.yaml": {
+    "bytes": 443,
+    "sha256": "973cb978622d19e08a762acf9e918a2279f02ad8501b33d3adb3476ca450726c"
+  },
+  "runtime/configs/model/finetune/pocket_finetune.yaml": {
+    "bytes": 959,
+    "sha256": "4d17768a2a884b6e083f06103c5220a737f68cfea87fa4882f112d79a3e54bfa"
+  },
+  "runtime/configs/model/finetune/scaffold_finetune.yaml": {
+    "bytes": 6097,
+    "sha256": "dbe7adc88454cc52ea4aab9d420b93d5efa78e03003e5e85de6b6733fa1046b3"
+  },
+  "runtime/configs/model/finetune/scaffold_pocket_finetune.yaml": {
+    "bytes": 634,
+    "sha256": "b09d57280abc777773bba4c3d1b8c947b85b2fa73c2e7ea21924c49691a98d93"
+  },
+  "runtime/configs/optimizer/muon_aux_adam.yaml": {
+    "bytes": 1212,
+    "sha256": "3b0a6189f3ba81f85f7d26c6f6ad7f64dcb25098a14e411211d7a62983a7180c"
+  },
+  "runtime/configs/schedule/beta.yaml": {
+    "bytes": 78,
+    "sha256": "75c485edfd70016b255282adcf5de25dfb95c9e32bb6587017fb8935ffe64eaa"
+  },
+  "runtime/configs/schedule/cubic.yaml": {
+    "bytes": 54,
+    "sha256": "a998a2d3390ab5daf4df079852ae8daa907687cf059f55c500409c9493949c0c"
+  },
+  "runtime/configs/schedule/fast_power.yaml": {
+    "bytes": 126,
+    "sha256": "22f36106bd43ca253ffea412e00539f2b07efbc49109b97c1232df6a827a2baf"
+  },
+  "runtime/configs/schedule/linear.yaml": {
+    "bytes": 55,
+    "sha256": "f7881af26080ab5569e67b39f6eae2733c033b9623020e6271959f09fac45fa0"
+  },
+  "runtime/configs/schedule/smoothstep.yaml": {
+    "bytes": 70,
+    "sha256": "f6e8651953d93f0d18c997d40c199b3d80ddd352a2041cc51e29adc9a7f22778"
+  },
+  "runtime/configs/trainer/trainer.yaml": {
+    "bytes": 1402,
+    "sha256": "6f78e83ad46529bee7a2878b20727ff403420a515c1629bd73a608a2fb654f5f"
+  },
+  "runtime/pyproject.toml": {
+    "bytes": 4537,
+    "sha256": "d88a9882c2e441ce342ac72907b38585a6d9f8e45474b9417020bb3ecfa47ef2"
+  },
+  "runtime/run.py": {
+    "bytes": 9958,
+    "sha256": "1911e4fc827f2dd0344ab5a508faeb43cd364fc88c3a547223e34704aa7142c0"
+  },
+  "runtime/src/morph/__init__.py": {
+    "bytes": 79,
+    "sha256": "bb402ea5c6f79e569205cc2bf4168d06430753ce8499ca4ffb8614743626fd59"
+  },
+  "runtime/src/morph/__main__.py": {
+    "bytes": 149,
+    "sha256": "95a7983479559ca2b15c7afa3881b3142ef4636583501184469b972df7646d4f"
+  },
+  "runtime/src/morph/_vendor/__init__.py": {
+    "bytes": 72,
+    "sha256": "8480cd966a03870a7142e1763094bf00e221d2c3c2b1af1d4d458fb8b7f37a20"
+  },
+  "runtime/src/morph/_vendor/geom_drugs_preprocessing.py": {
+    "bytes": 11328,
+    "sha256": "33a9c21d29df269a5f342a0b0e8bced0fc620559f0cb3a7a4cfabd5c369ceccb"
+  },
+  "runtime/src/morph/_vendor/muon.py": {
+    "bytes": 16405,
+    "sha256": "c61af8c2c4a635cc682b84e279851cb54fedc6fb935d8eb11aafbeb1c5e81fc6"
+  },
+  "runtime/src/morph/cli.py": {
+    "bytes": 9723,
+    "sha256": "27eee3fd6d6410747f12b19b670a74f50a51b842a50b1eff4e75c46d0d08a986"
+  },
+  "runtime/src/morph/config.py": {
+    "bytes": 704,
+    "sha256": "bd3562c030611f87cc514308f155ad93740dd59927732f71b2e15009012d78ff"
+  },
+  "runtime/src/morph/dataset/__init__.py": {
+    "bytes": 620,
+    "sha256": "44ae493354fed0fec4b410f46e0c1fb0351b5fbe5f404ff50f77181e60a39cee"
+  },
+  "runtime/src/morph/dataset/conditional/__init__.py": {
+    "bytes": 316,
+    "sha256": "8152efe1b0878297add6646862f56304e38459b894a77817adbd652bee7e334a"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/README.md": {
+    "bytes": 19246,
+    "sha256": "2d2d8e20160e5554b40cc54258e43a05938c40bd5232565b47494b94259e562c"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/__init__.py": {
+    "bytes": 190,
+    "sha256": "c69f5024a5a90a02f08b31402e16e6eac8598b55e9c6433bda72c0394abd0963"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/build.py": {
+    "bytes": 13844,
+    "sha256": "fa645b28b00a39b8abd3550d3e4d2988b6c89e8cd5fac4b52e764877d8661759"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/crossdocked.py": {
+    "bytes": 12798,
+    "sha256": "9eab93363712132e5b1062d808bc935558b35fb5869ef6b2a638aef98470067b"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/datamodule.py": {
+    "bytes": 4261,
+    "sha256": "cfdcedea2b96b96261af5a17eb4dddc7f471e2b0b7b444b630139d3103f82349"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/evaluation.py": {
+    "bytes": 9050,
+    "sha256": "270574b07aa19667f97336a6a38e6e9c93a7e09fde82f80d409640b27762adc6"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/processing.py": {
+    "bytes": 7734,
+    "sha256": "eb9059ea7e240995992a86920e9e4e77b1fa6130d63327fa82a86239ff766250"
+  },
+  "runtime/src/morph/dataset/conditional/pocket/scaffold_pocket.py": {
+    "bytes": 5518,
+    "sha256": "987fc333b34e3e2d25ed7407a5228696573f1c39ef93901c201f7957dde4fa39"
+  },
+  "runtime/src/morph/dataset/conditional/replay.py": {
+    "bytes": 7061,
+    "sha256": "fc8ef66f1be371c4252015d8f4b7e555a976e669cf3b2606a44403552bfc0554"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/__init__.py": {
+    "bytes": 229,
+    "sha256": "ef9b1d37a3a18e820dd1b9afefe1849d066d70cbdd93a02b87c09f76e0a9b3b0"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/cutters.py": {
+    "bytes": 15539,
+    "sha256": "08c3992621a3f930d2595361a86e13280f2f0045c6875eb5c0045ccb9946e5bf"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/datamodule.py": {
+    "bytes": 2182,
+    "sha256": "3a1c4ffb8599970e6fe81cd9d462dcabcb44091e446b4eb045868022cb1b19a1"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/libinvent_filter_conditions.json": {
+    "bytes": 560,
+    "sha256": "ac33112e64f47991be40259aa694219a7f1d47f36a4a130cf329aa98205529b2"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/libinvent_reactions.smirks": {
+    "bytes": 4272,
+    "sha256": "0eaf5444865fef1c5c6d5b87ec97f9480a4765fde97cfa6dbbe57d718f9f74ef"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/lmdb.py": {
+    "bytes": 4864,
+    "sha256": "18ee5fcb3fd7ecad0b0b5e1f2bb25e5196e05e492a5e061ef17139a2efcdadc3"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/panel.py": {
+    "bytes": 9440,
+    "sha256": "54aa9377cfd0b3a6883adc6955b7b7164bfc030a20fd901d75c221f551b61036"
+  },
+  "runtime/src/morph/dataset/conditional/scaffold/wrappers.py": {
+    "bytes": 8473,
+    "sha256": "69d58714aef4dbf3d4fb953ff62befc64f021eb9afc5fbc04dd9e7f7f8638ecc"
+  },
+  "runtime/src/morph/dataset/core/__init__.py": {
+    "bytes": 376,
+    "sha256": "7bab9c675f0850efc50e14a9898accfde5f8d1c1e2420414ac8c0986822d27e0"
+  },
+  "runtime/src/morph/dataset/core/atomic_data.py": {
+    "bytes": 708,
+    "sha256": "7d59ec16ed5b3cf82b57b49dd4d7799862709353a65f4d473d4571ba91b86fa6"
+  },
+  "runtime/src/morph/dataset/core/batch.py": {
+    "bytes": 23924,
+    "sha256": "7b2b2afd749b621b1ca890d192e4dc9378b61ead9ef34b90f04dc449e6bad369"
+  },
+  "runtime/src/morph/dataset/core/containers.py": {
+    "bytes": 19637,
+    "sha256": "adae656c3fbbe5cfe32f378a419c7e1076f653163ffe7d2c1d1d0abc71a99cd7"
+  },
+  "runtime/src/morph/dataset/core/conversion.py": {
+    "bytes": 2224,
+    "sha256": "0842565c503048a86a517c202dd0cc7c07e9296a841601b178ec38c43f903a6a"
+  },
+  "runtime/src/morph/dataset/core/flow_matching_wrapper.py": {
+    "bytes": 8406,
+    "sha256": "650d791f765f90f5f86353d3edbeb65f2d44bc9089b9123ec407c970c144beb0"
+  },
+  "runtime/src/morph/dataset/core/insertion_data.py": {
+    "bytes": 14393,
+    "sha256": "7e99e4d59b29ea537708b5f7887ed3e61b4b31ebf80d55fe5a0c6823ff8a439c"
+  },
+  "runtime/src/morph/dataset/core/insertion_targets.py": {
+    "bytes": 6614,
+    "sha256": "2e62e89125310572735d916e97c8a544cfb3eb76fb167ecd134b5f8b0424df8c"
+  },
+  "runtime/src/morph/dataset/core/lightning_datamodule.py": {
+    "bytes": 7495,
+    "sha256": "1facb3c332fd3d306631c84aede122be89b54bafbd17eeab25981b1e4a6af7f3"
+  },
+  "runtime/src/morph/dataset/core/lmdb.py": {
+    "bytes": 10111,
+    "sha256": "748b7a10f8fb20f74c267de393cc3e1933ea86debde99d8fdaaef94e0a9afd29"
+  },
+  "runtime/src/morph/dataset/core/preprocessing.py": {
+    "bytes": 20145,
+    "sha256": "da9cffd6beb6da63ee749dd8b60d4d0509bcd937778014739b04ffc599dde066"
+  },
+  "runtime/src/morph/dataset/core/properties.py": {
+    "bytes": 1952,
+    "sha256": "4dc63574f5fde284245078adf50fb2d8a9ac16443b8276154c03b7703cc2e937"
+  },
+  "runtime/src/morph/dataset/core/representation.py": {
+    "bytes": 6591,
+    "sha256": "0ecac55e1faf9748826ec8f4c7f1a274263214ea3f68cc69de7047b55dd6a65f"
+  },
+  "runtime/src/morph/dataset/core/tokenized_decode.py": {
+    "bytes": 6559,
+    "sha256": "483afb3d468113da33cc8699998e6439fcde2264ee7ca479724206360584a2b8"
+  },
+  "runtime/src/morph/dataset/core/vocab.py": {
+    "bytes": 2236,
+    "sha256": "f8618488f7bcdc8a58d8b9f3443b764eac60985a33ead1bcc2d17d3bdc213329"
+  },
+  "runtime/src/morph/dataset/unconditional/__init__.py": {
+    "bytes": 403,
+    "sha256": "d7cd3b85745ad1a4d884c0a11a64b3ab9cedcc64e30f604dbe83f5beb14fa97b"
+  },
+  "runtime/src/morph/dataset/unconditional/chembl3d.py": {
+    "bytes": 9854,
+    "sha256": "d5cfd1ee4ddd3085b95b9a678d761d4f0beef99ac5ecfb21d3dfb3cae59653eb"
+  },
+  "runtime/src/morph/dataset/unconditional/geom.py": {
+    "bytes": 4071,
+    "sha256": "12bc792c2a61b3e6c29ae265b9997ba610765e268408e873918b5a65225945be"
+  },
+  "runtime/src/morph/dataset/unconditional/qm9.py": {
+    "bytes": 9799,
+    "sha256": "a23fdb22e86597ae19cf4b8435f82ffcb9c16c32d0dc729a5ca1019aef8fd78a"
+  },
+  "runtime/src/morph/flow_matching/__init__.py": {
+    "bytes": 78,
+    "sha256": "674f4630aa8421d7e75c913741c6efb1a163fbc38ce909c6cdb011f9ba9ef48e"
+  },
+  "runtime/src/morph/flow_matching/assignment.py": {
+    "bytes": 16050,
+    "sha256": "b6ad66538f5bd7f14e0eee2a0ffd25a4110d1504e057a0a9eb63a354d9f6aadb"
+  },
+  "runtime/src/morph/flow_matching/integration.py": {
+    "bytes": 33356,
+    "sha256": "f64b7b9ed2a79c11932b72e498e57eef924b5c85a05aa6893ddfe11e2d4595e9"
+  },
+  "runtime/src/morph/flow_matching/interpolation.py": {
+    "bytes": 23963,
+    "sha256": "81939bb12a705f92394d1d2b78d4cf13b592bb20a129524020cc5236074c8072"
+  },
+  "runtime/src/morph/flow_matching/prior.py": {
+    "bytes": 2389,
+    "sha256": "0f9b77274238b23be7a2ad88ee8e6dcbb785817fcfa3a35aa863b489d2a6e05d"
+  },
+  "runtime/src/morph/flow_matching/sampling_step.py": {
+    "bytes": 2806,
+    "sha256": "c768682a47da1b7852838e20b39317528717fc0485cbc35030b3ca71d7d845bb"
+  },
+  "runtime/src/morph/flow_matching/scaffold_insertion.py": {
+    "bytes": 2886,
+    "sha256": "18e0d7093dfaab98b253d202c4fc4649b8b8de96c9a22144c5eeb5041f73aef8"
+  },
+  "runtime/src/morph/flow_matching/schedules.py": {
+    "bytes": 6776,
+    "sha256": "6fd8396a05052ae7831babc75ca40a7e748fb9edffe82bb2559533afa949b2a9"
+  },
+  "runtime/src/morph/inference/__init__.py": {
+    "bytes": 732,
+    "sha256": "63047340b4c7ed784e969b7d54035ab737282ee2acc6eeb26ba6cb3d52b4f573"
+  },
+  "runtime/src/morph/inference/bundles.py": {
+    "bytes": 6395,
+    "sha256": "f6e2d46e6e428452a58208e78c83da01d6c786f10f7062643a093fb6750dafe6"
+  },
+  "runtime/src/morph/inference/catalog.py": {
+    "bytes": 6215,
+    "sha256": "53a27b86d39641fd4964da82f4b1875598a0cdb1533f981074c6b7a14b4174b7"
+  },
+  "runtime/src/morph/inference/generate.py": {
+    "bytes": 11889,
+    "sha256": "c3181fbf6187cf22b476431ed7c0fdea4c74ea8e97acf270f486318e43646d19"
+  },
+  "runtime/src/morph/inference/hub.py": {
+    "bytes": 9739,
+    "sha256": "fa1f43937d66f0ab4b7b9c11ed749aef8d23444b2df3257c36ff72ecd3b821ca"
+  },
+  "runtime/src/morph/inference/module.py": {
+    "bytes": 3820,
+    "sha256": "415e0f9c624c191855874b8dd88d5e7aa18941632bc403a9c0b685bbf74f1d60"
+  },
+  "runtime/src/morph/inference/registry.py": {
+    "bytes": 4314,
+    "sha256": "8ca3e4246e00707ed0d646e6e760acebd5e3d3443e5e8d5f71f3b54653993fa9"
+  },
+  "runtime/src/morph/model/README.md": {
+    "bytes": 10319,
+    "sha256": "9c06b5b90300f7449048640417116aa8869dc1a75f106cbdd9344a89f6e446d3"
+  },
+  "runtime/src/morph/model/__init__.py": {
+    "bytes": 80,
+    "sha256": "1c7c3875387d5ba7f9166a804ea5a7ef7bd469728c1ad5c5003150d44e33be51"
+  },
+  "runtime/src/morph/model/backbones/__init__.py": {
+    "bytes": 64,
+    "sha256": "a1a1419590c11aa6ed429f8b6b293470e30fe767f5571d2517b0883efb071e0c"
+  },
+  "runtime/src/morph/model/backbones/conditional_dit.py": {
+    "bytes": 25614,
+    "sha256": "15aacd0afd334a6d296556a00e5e8849a5dbf021b37c55f1f96af6c9fe706c80"
+  },
+  "runtime/src/morph/model/backbones/dit.py": {
+    "bytes": 31994,
+    "sha256": "7d9e1f25cc4174bb9f2e03f57679c4b2d28a292740e3833ac38870d172bbe805"
+  },
+  "runtime/src/morph/model/build.py": {
+    "bytes": 3442,
+    "sha256": "e69f4231815f09c094d787f11edc49e222cbdc970edc6e416b6b94a9b88d4b21"
+  },
+  "runtime/src/morph/model/finetune/__init__.py": {
+    "bytes": 282,
+    "sha256": "8746b1e29e5a3b3b1805389257270b90f5d30995783f2cf41b9fb533c485fc0c"
+  },
+  "runtime/src/morph/model/finetune/base/__init__.py": {
+    "bytes": 803,
+    "sha256": "6e0ded0b3a5c2a76ccb85b05cf63bcc54e145bd1be07d933a737d6151433d856"
+  },
+  "runtime/src/morph/model/finetune/base/conditional_backbone.py": {
+    "bytes": 2853,
+    "sha256": "1353e96443eacf3ce88473a30d02ab4f1c8b6a9c90763ea61c58d353b806b378"
+  },
+  "runtime/src/morph/model/finetune/base/context_encoder.py": {
+    "bytes": 13655,
+    "sha256": "095784c710fd921c9da4114dd867df636513a696beece28cfa9a79e1d8193320"
+  },
+  "runtime/src/morph/model/finetune/base/finetune_base.py": {
+    "bytes": 10575,
+    "sha256": "06b38586346545b6ff19e689944d4c5a6da04431d0b10eefc58c8ee43e88ef46"
+  },
+  "runtime/src/morph/model/finetune/pocket/__init__.py": {
+    "bytes": 455,
+    "sha256": "bd83b0aec910454a989214169a9160ef744ec1f115044fceba8fcb3d1d208edd"
+  },
+  "runtime/src/morph/model/finetune/pocket/pocket_context.py": {
+    "bytes": 2913,
+    "sha256": "c9d00636bbaa7ba413f4299894e6db28b82e02680005d261d1f7cb52df26ea91"
+  },
+  "runtime/src/morph/model/finetune/pocket/scaffold_pocket_context.py": {
+    "bytes": 1476,
+    "sha256": "7c5e3424c7b68ea1dff5d516c1010e0fd5bb417966262eea3896908b6971847f"
+  },
+  "runtime/src/morph/model/finetune/scaffold/__init__.py": {
+    "bytes": 366,
+    "sha256": "6345e71c8b03ee5eb0dcd105c0532acf73a1795bf6360b2847be600bcecd40ba"
+  },
+  "runtime/src/morph/model/finetune/scaffold/scaffold.py": {
+    "bytes": 5643,
+    "sha256": "54c27926aff97448521be3cd28e8560dda696ae1f9208dbbe3ad79a8e856597f"
+  },
+  "runtime/src/morph/model/finetune/scaffold/scaffold_context.py": {
+    "bytes": 6086,
+    "sha256": "d9446254770e3c3ea2c634a0636ab82a718514a7cb69760d756e9235cfbe2814"
+  },
+  "runtime/src/morph/model/layers/__init__.py": {
+    "bytes": 189,
+    "sha256": "79671fbdea358c330a45b7fd3d842119b32b1d548804b3d441bbfb7dbd703b69"
+  },
+  "runtime/src/morph/model/layers/attention.py": {
+    "bytes": 22828,
+    "sha256": "366f4b7618097715e5a50acbcf7fae3f1fe7015810e6dfd69ce2e657862cdfba"
+  },
+  "runtime/src/morph/model/layers/embedding.py": {
+    "bytes": 14356,
+    "sha256": "efe924190da5904e05495f421dcc313134cebe0dee9bf665060e1e5781cd95ef"
+  },
+  "runtime/src/morph/model/layers/gmm.py": {
+    "bytes": 6753,
+    "sha256": "628e90c73bdbb3e70104214f80bbf8a94896ddbe22a9a3fc40cce34b20d2565f"
+  },
+  "runtime/src/morph/model/layers/heads.py": {
+    "bytes": 30913,
+    "sha256": "7113c29a6be81c93ca980dc19d0847d2015ac36702683e4f1adedd549aed46ae"
+  },
+  "runtime/src/morph/model/layers/kernels.py": {
+    "bytes": 12483,
+    "sha256": "be0c52b69c7612946244755e2865de0491440a41163cf828168eb750a8f929cf"
+  },
+  "runtime/src/morph/model/layers/lora.py": {
+    "bytes": 5947,
+    "sha256": "7194750605e7b5df9a02e4c4a39cf29c982f117c40198c99c73211c85ecdfe4b"
+  },
+  "runtime/src/morph/model/lightning/__init__.py": {
+    "bytes": 339,
+    "sha256": "c53943a4eb1e45568cebfb538655cc5eb7ead46284bbcd515800102c89177e52"
+  },
+  "runtime/src/morph/model/lightning/_optimizer.py": {
+    "bytes": 19578,
+    "sha256": "f77519db8d3458c05aec1543cb4cd487995cf398abcc71b62ea1835cb132165e"
+  },
+  "runtime/src/morph/model/lightning/_sampling.py": {
+    "bytes": 15588,
+    "sha256": "ab5f423a6910939552a62c2da645ea1e9afcd763bc8b7e0dbfc75953825a9dca"
+  },
+  "runtime/src/morph/model/lightning/_setup.py": {
+    "bytes": 6537,
+    "sha256": "835f510094110c4dbc590a88d9b94d41474ae87b442785a949328feda5b9afce"
+  },
+  "runtime/src/morph/model/lightning/_training.py": {
+    "bytes": 2747,
+    "sha256": "2d298e8b0833cce18e4bdef76e67bf81b49a9fdca9920868e2e4083fcc398fc4"
+  },
+  "runtime/src/morph/model/lightning/_validation.py": {
+    "bytes": 12558,
+    "sha256": "82c9e1a9e2c54827c7ec92dcdb857c6d2bf050b73416ff028e022c86a2710a75"
+  },
+  "runtime/src/morph/model/lightning/base.py": {
+    "bytes": 9294,
+    "sha256": "ce9159e7b387ece0a3ce010b164f675b81980d2f617b5b05d00f96695ee33e28"
+  },
+  "runtime/src/morph/model/losses/__init__.py": {
+    "bytes": 393,
+    "sha256": "dc20020e6686703a5b0abd0e77b451fc4beace021f22fd6f92d988a48cb4b526"
+  },
+  "runtime/src/morph/model/losses/flow.py": {
+    "bytes": 21766,
+    "sha256": "a8e63b363e8e800c5d22d80454999bd8c5d91bb75ff2f9842800bed8e3377e04"
+  },
+  "runtime/src/morph/model/losses/functional.py": {
+    "bytes": 11765,
+    "sha256": "42ae52f604a0cb8b7fe08955cfd273945ca068727994f20b02c80cdee3a00e1b"
+  },
+  "runtime/src/morph/utils/__init__.py": {
+    "bytes": 78,
+    "sha256": "eb76ca86f046931eaea693a696317e8b3ce0b8ad8695a92e3744fd1892f2b9b8"
+  },
+  "runtime/src/morph/utils/checkpoints.py": {
+    "bytes": 2301,
+    "sha256": "750302eb039e3947a5d4c84e4e7d04eb46e974cc0031ef1d197a3573e20eae4b"
+  },
+  "runtime/src/morph/utils/edge_alignment.py": {
+    "bytes": 4896,
+    "sha256": "0edcde93cfa3a2d825e783ea5cf64715aa248e59ffb8c6a23d4490d74976a71e"
+  },
+  "runtime/src/morph/utils/graph_math.py": {
+    "bytes": 6755,
+    "sha256": "2bae326c3538d757aac66dcfc4a0b5d023b17bd987d814d3dab9a57f9ce60552"
+  },
+  "runtime/src/morph/utils/loss_accumulation.py": {
+    "bytes": 15115,
+    "sha256": "0f3eca42145e715290576dd86f4bcfb1553714ec4cabeda9246cfaf1e4f4323c"
+  },
+  "runtime/src/morph/utils/lr_schedulers.py": {
+    "bytes": 5554,
+    "sha256": "b954c12df413ca6676263ef1af960e2a4ff52692acfd4223e72a6e02122a3638"
+  },
+  "runtime/src/morph/utils/metrics/DIFFDEC_LICENSE": {
+    "bytes": 1074,
+    "sha256": "729bec7640e96b6357728566e43ac7dec9b7393f15c8ee96edf1e699c00e91f1"
+  },
+  "runtime/src/morph/utils/metrics/__init__.py": {
+    "bytes": 7120,
+    "sha256": "ab3cfce2cc6ce7d7cdacedefe91d195c6783e0d6d21762beb6cb4446f47deb32"
+  },
+  "runtime/src/morph/utils/metrics/chemistry.py": {
+    "bytes": 36408,
+    "sha256": "db05302c87b6880167be67dc1d5f7b35924bb84f6a7a0b5b32d2d62e54a00735"
+  },
+  "runtime/src/morph/utils/metrics/denovo.py": {
+    "bytes": 26664,
+    "sha256": "57517d1124c6067a1682e13f6faa439ecbceb3d8c12ea0d13f6da0db503cd5c9"
+  },
+  "runtime/src/morph/utils/metrics/diffdec.py": {
+    "bytes": 7879,
+    "sha256": "37d334fb306afd114de2f50ee4ad5dc48f7565adaa6a077a08e01fc1460599c8"
+  },
+  "runtime/src/morph/utils/metrics/distribution.py": {
+    "bytes": 3348,
+    "sha256": "0a6c25c4e65843308059a3effc44e1072837e747926074c1d7c47ba7ee72cb46"
+  },
+  "runtime/src/morph/utils/metrics/plotting.py": {
+    "bytes": 4270,
+    "sha256": "686d491d7fbc83cf35f772649a869dc1a271966d2a4fa6162d6e2334db735723"
+  },
+  "runtime/src/morph/utils/metrics/posebusters_energy.py": {
+    "bytes": 3567,
+    "sha256": "a705c1baa499a5a4e95329f941f6c762fb49feb505819ed0a35b34daf46ac521"
+  },
+  "runtime/src/morph/utils/metrics/posecheck_strain.py": {
+    "bytes": 6531,
+    "sha256": "1fd8340484f542d6a9abce041b8caee20901b9d704bc354f37baf67c76d156a2"
+  },
+  "runtime/src/morph/utils/metrics/scaffold.py": {
+    "bytes": 6312,
+    "sha256": "44965940eb17c661734ab0a816123ac5e50a33103aaca217596cca697fd8be6d"
+  },
+  "runtime/src/morph/utils/metrics/scaffold_posebusters.py": {
+    "bytes": 3825,
+    "sha256": "d5372df116119a55074cab7ceae085568be4edbb0c932b0961a1ed19bb453f83"
+  },
+  "runtime/src/morph/utils/metrics/tensor.py": {
+    "bytes": 13503,
+    "sha256": "3fcb867cde5d47f81725acc3b862fc56af5ecce23dee3a11ebe6d05c1772c6fe"
+  },
+  "runtime/src/morph/utils/rdkit_utils.py": {
+    "bytes": 9053,
+    "sha256": "0da70d65eb85d9906e4b611ffa087a870f6133df6ea99a9b21a35b55ad57ffc5"
+  },
+  "runtime/src/morph/utils/run_config.py": {
+    "bytes": 8025,
+    "sha256": "0c289120887a051379523af528ebc9310f356f3b92efb898ddaf773dbf698aa2"
+  },
+  "runtime/src/morph/utils/vocab_utils.py": {
+    "bytes": 6343,
+    "sha256": "7b5506971b5092865b86311173b24d7fb70a881f123c57fd8696c412a25d618b"
+  },
+  "runtime/uv.lock": {
+    "bytes": 615473,
+    "sha256": "4b85cc8b6e28d7fe42533df16cc9633d909fd91296b38b3d8ebce3dbbf8317aa"
+  },
+  "training_config.yaml": {
+    "bytes": 15526,
+    "sha256": "7243310c19f0d90399db52845e8ad0446d66e303b64863cbce444058e1bf06bf"
+  },
+  "training_source.tar.gz": {
+    "bytes": 510894,
+    "sha256": "f2ee1bf919ad17d664f0614252f43bdcf39b2474e5a1069a37429a520adb8a2f"
+  }
+}

geom/scaffold_murcko_substituent_lora_r16/metadata.json

@@ -0,0 +1,41 @@
+{
+  "task": "scaffold_decoration",
+  "dataset": "GEOM-Drugs",
+  "hydrogens": "explicit",
+  "completed_epochs": 25,
+  "checkpoint_epoch_zero_based": 24,
+  "global_step": 199100,
+  "checkpoint_sha256": "0f3b9d75897c951fdfe437bb10735fb371ea2f5e9ea982471c3c7bd73a160484",
+  "checkpoint_bytes": 638268597,
+  "original_checkpoint": "/cluster/project/krause/frankem/morph-chem/logs/training/geom-scaffold-substituent-lora-r16-20261012T095326Z/run/every_n_epochs/epoch=24-step=199100.ckpt",
+  "training_job_id": 16886672,
+  "model": "geom-scaffold-murcko-substituent-lora-r16",
+  "lora_rank": 16,
+  "lora_alpha": 16,
+  "base_model": "geom-explicit-h",
+  "base_completed_epochs": 100,
+  "base_checkpoint_sha256": "0ab5ad7247b5518858c8cb6aa7c4102352e8fe09cbb6744c33a4c784c85b8587",
+  "insertion_assignment": "substituent",
+  "freeze_keep_positions": false,
+  "freeze_keep_charges": true,
+  "default_eval_weights": "ema",
+  "integration_steps": 100,
+  "original_checkpoint_including_optimizer": true,
+  "source_training_archive": "training_source.tar.gz",
+  "evaluation_runtime": "runtime",
+  "panel_sha256": {
+    "val_murcko_512_seed42.json": "b30a2063ba1c74414a2bda387f9dc42ade8c82540d6ec36c58956c12bee64e44",
+    "test_murcko_512_seed42.json": "5df2f8b632dd261098ee86581b748487163b10893d2a4462f3e52cd25130905b"
+  },
+  "evaluation_protocol": {
+    "split": "test",
+    "n_scaffolds": 512,
+    "samples_per_scaffold": 8,
+    "seeds": [
+      42,
+      43,
+      44
+    ]
+  },
+  "not_unconditional_catalog_entry": true
+}

geom/scaffold_murcko_substituent_lora_r16/panels/verification.json

@@ -0,0 +1,10 @@
+{
+  "panel": "val_murcko_512_seed42.json",
+  "samples": 4096,
+  "scaffolds": 512,
+  "samples_per_scaffold": 8,
+  "two_rank_disjoint_coverage": true,
+  "reference_roundtrip_checks": 16,
+  "all_reference_retention_rmsd_recovery_checks_passed": true,
+  "model_generation_run": false
+}

geom/scaffold_murcko_substituent_lora_r16/runtime/README.md

@@ -0,0 +1,202 @@
+# Morph
+
+Flow-matching molecular generation on QM9, GEOM-Drugs, and ChEMBL3D, including
+scaffold-decoration fine-tuning. A molecular diffusion transformer (DiT)
+predicts clean coordinates, atom and bond types, charges, and edit posteriors.
+The sampler combines those predictions with time schedules to move, insert,
+delete, and substitute atoms and bonds.
+
+## Pretrained models
+
+[Checkpoints on Hugging Face](https://huggingface.co/maltefranke/morph)
+include QM9 with explicit hydrogens (epochs 1,000 and 1,500), GEOM-Drugs with
+explicit hydrogens (epochs 50 and 100), and ChEMBL3D with explicit hydrogens
+(epochs 200, 300, 400) or implicit hydrogens (epochs 100, 200, 300). Download and generate without preparing a dataset:
+
+```bash
+uv sync --locked
+source .venv/bin/activate
+hf auth login
+morph models list
+morph models download chembl3d-implicit-h --epoch 300
+# Run generation on a compute worker:
+morph generate --model chembl3d-implicit-h --epoch 300 \
+  --device cuda --batch 64 --batch-size 16 --output molecules.sdf
+```
+
+Python loading is equally direct:
+
+```python
+from morph.inference import load_pretrained
+
+model = load_pretrained("chembl3d-implicit-h", epoch=300, device="cuda")
+```
+
+The loader fetches the selected weights, config, vocabularies and distributions
+and constructs only one network (EMA by default; `use_ema=False` selects current
+weights). `morph models list` discovers shortcuts from the Hub's `catalog.json`;
+`--offline` reads the cached catalog. Adding a release requires updating that
+manifest, with each entry pointing to its model release. You can also pass any
+Hugging Face `owner/repo` with `subfolder` and `revision`, or load a local bundle
+with `load_pretrained(weights_dir="/path/to/bundle")`. See [inference](docs/inference.md) for sampling,
+offline use, checkpoint selection and adding new model releases.
+
+## Reproducibility
+
+Each model has a **training bundle** with its original training configuration,
+launch settings, frozen source, dependency versions and data references.
+The bundles live alongside the corresponding model files on Hugging Face:
+
+| Model | Configuration and source |
+| --- | --- |
+| QM9, explicit H | [Training bundle](https://huggingface.co/maltefranke/morph/resolve/main/qm9/explicit_h/training_bundle.tar.gz) |
+| GEOM-Drugs, explicit H | [Training bundle](https://huggingface.co/maltefranke/morph/resolve/main/geom/explicit_h/training_bundle.tar.gz) |
+| ChEMBL3D, explicit H | [Training bundle](https://huggingface.co/maltefranke/morph/resolve/main/chembl3d/explicit_h/training_bundle.tar.gz) |
+| ChEMBL3D, implicit H | [Training bundle](https://huggingface.co/maltefranke/morph/resolve/main/chembl3d/implicit_h/training_bundle.tar.gz) |
+
+For example, download and unpack the GEOM training bundle:
+
+```bash
+hf download maltefranke/morph geom/explicit_h/training_bundle.tar.gz --local-dir .
+tar -xzf geom/explicit_h/training_bundle.tar.gz
+```
+
+Each bundle also includes a portable training recipe; its changes from the
+original run are recorded alongside it. See the [training bundle guide](docs/reproducibility.md)
+for setup, data requirements and resuming. Version identifiers and checksums
+are recorded in the release metadata and bundle manifests.
+
+## Training quick start
+
+Preprocessed splits, vocabularies, and statistics are available in the public
+[Morph data repository](https://huggingface.co/datasets/maltefranke/morph-data).
+Download a cache into this checkout and skip preprocessing:
+
+```bash
+hf download maltefranke/morph-data --type dataset --include 'qm9/**' --local-dir data
+```
+
+Replace `qm9/**` with `geom/**`, `chembl3d/**`, `chembl3d_max100/**`, or
+`chembl3d_max100_implicit_h/**` as needed. The released ChEMBL3D checkpoints use
+the two `max100` caches; the dataset card documents the matching training bundles.
+
+Install [uv](https://docs.astral.sh/uv/) and use Python 3.11 or newer.
+From the repository root:
+
+```bash
+bash setup_env.sh
+source .venv/bin/activate
+source .env
+
+# Choose qm9, geom, or chembl3d; the workflow is the same for each.
+dataset=chembl3d
+python scripts/preprocess.py "$dataset"
+python run.py defaults="$dataset/$dataset"
+```
+
+Setup installs the versions in `uv.lock` and creates `.env` only when it is
+absent. Local outputs default to `outputs/`. To choose another artifact root,
+set `MORPH_SCRATCH` before running setup. Training uses W&B by default; add
+`logging.enabled=false` for a local run without W&B logging.
+
+`scripts/preprocess.py` downloads missing source files into `data/<dataset>/raw/`,
+processes the train/validation/test splits, and computes vocabularies and training
+statistics in `data/<dataset>/processed/`. Rerunning it reuses completed files.
+No manual download or source directory is required. Run preprocessing once on a
+CPU worker before starting distributed training; add `--workers 20` to choose
+the number of preprocessing workers.
+
+GEOM and ChEMBL3D support heavy-atom graphs with implicit hydrogens. Choose
+`--hydrogen-mode implicit` when preprocessing, then select the matching recipe:
+
+```bash
+python scripts/preprocess.py "$dataset" --hydrogen-mode implicit
+python run.py defaults="$dataset/implicit_h"
+```
+
+Set `dataset` to `geom` or `chembl3d` for this option. It uses a separate
+`data/<dataset>_implicit_h/` cache with its own vocabularies and statistics.
+See [training and data options](docs/training.md) for filters and optional local
+source overrides.
+
+GPU training compiles both current and EMA models by default. For short smoke
+tests, use `MORPH_COMPILE=0`. The full training defaults require a GPU; a small
+CPU run can be requested explicitly:
+
+```bash
+MORPH_COMPILE=0 python run.py logging.enabled=false \
+  trainer.trainer.accelerator=cpu trainer.trainer.devices=1 \
+  trainer.trainer.strategy=auto integrator.integrator.num_integration_steps=2 \
+  trainer.trainer.precision=32-true +trainer.trainer.fast_dev_run=true \
+  data.datamodule.num_workers.train=0 data.datamodule.batch_size.train=2 \
+  data.datamodule.batch_size.val=2 data.datamodule.batch_size.test=2
+```
+
+## Scaffold decoration
+
+Fine-tune a pretrained unconditional DiT while conditioning on retained atoms:
+
+```bash
+python run.py defaults=qm9/scaffold_decoration \
+  model.module.pretrained_ckpt=/path/to/unconditional.ckpt \
+  data.scaffold_kind=rgroup
+```
+
+Supported retained structures are Murcko scaffolds, BRICS fragments (`rgroup`),
+heavy atoms, and fragments for linker generation. See
+[training and fine-tuning](docs/training.md) for their semantics and LoRA options.
+
+## Reading the implementation
+
+The main data path is:
+
+```text
+Dataset → prior/target alignment → interpolation → collated training batch
+        → DiT endpoint/edit predictions → per-graph losses → optimizer/EMA
+```
+
+Sampling repeatedly decodes predictions, applies task masks, integrates edits,
+and recenters coordinates. Output coordinates are restored to Angstroms.
+
+| Entry point | Purpose |
+| --- | --- |
+| [run.py](run.py) | Training, validation, and prediction orchestration |
+| [scripts/preprocess.py](scripts/preprocess.py) | Automatic dataset download, processing and statistics |
+| [model/build.py](src/morph/model/build.py) | Shared model and metric construction |
+| [flow_matching/](src/morph/flow_matching/) | Assignment, interpolation, schedules, and integration |
+| [dataset/core/](src/morph/dataset/core/) | Molecular batches and structured insertion targets |
+| [model/lightning/](src/morph/model/lightning/) | Training lifecycle, losses, sampling, and EMA |
+| [configs/](configs/) | Dataset and model recipes |
+| [tests/model/](tests/model/) | Regression tests grouped by subject |
+
+The [model contract](src/morph/model/README.md) documents tensor shapes,
+coordinate conventions, conditioning ports, and the loss-to-head mapping.
+
+## Further documentation
+
+- [Training, configurations, and fine-tuning](docs/training.md)
+- [Inference and model bundles](docs/inference.md)
+- [Reproducing released models and training runs](docs/reproducibility.md)
+- [Runtime, compilation, and performance](docs/performance.md)
+- [Euler cluster setup and SLURM](docs/euler.md)
+- [Development and regression checks](docs/development.md)
+- [Release metadata](docs/release.md)
+
+## Citation
+
+If you use Morph, please cite our [paper](https://arxiv.org/abs/2606.07239):
+
+```bibtex
+@misc{franke2026generativemolecularmorphingflexiblesize,
+      title={Generative Molecular Morphing for Flexible-Size Design via Unbalanced Optimal Transport},
+      author={Malte Franke and Stefan P. Schmid and Zarko Ivkovic and Kjell Jorner and Andreas Krause},
+      year={2026},
+      eprint={2606.07239},
+      archivePrefix={arXiv},
+      primaryClass={cs.LG},
+      url={https://arxiv.org/abs/2606.07239},
+}
+```
+
+Machine-readable citation metadata is available in [CITATION.cff](CITATION.cff).
+License details are pending.

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/callbacks/callbacks.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+
+## Put your callback args here
+callbacks:
+  monitor_metric: ${if:${oc.eval:"'${representation}' in ('geometric_graph', 'molecule')"},val/validity,val/batch/pair_dist_l1}
+  monitor_metric_mode: ${if:${oc.eval:"'${representation}' in ('geometric_graph', 'molecule')"},max,min}
+
+  #   model_checkpoints         -> best-by-metric (top-1, monitored)
+  #   every_n_epochs_checkpoint -> latest (no monitor; overwrites every epoch)
+  model_checkpoints:
+    save_top_k: 1
+    save_last: False
+    verbose: False
+
+  every_n_epochs_checkpoint:
+    every_n_epochs: 1
+    save_top_k: 1
+    save_last: False
+    verbose: False
+    save_on_train_epoch_end: True # Force per-train-epoch firing

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/chembl3d/chembl3d.yaml

@@ -0,0 +1,8 @@
+# LoQI ChEMBL3D source format, without dataset-specific size/element filters.
+defaults:
+  - /data/molecular@_here_
+  - _self_
+
+dataset_name: chembl3d
+dataset_target: morph.dataset.unconditional.chembl3d.FlowMatchingChEMBL3DDataset
+source_dir: ${oc.env:CHEMBL3D_SOURCE_DIR,null}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/chembl3d/implicit_h.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - /data/chembl3d/chembl3d@_here_
+  - _self_
+
+hydrogen_mode: implicit

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/chembl3d/max100.yaml

@@ -0,0 +1,7 @@
+# Inclusive total-atom limit, applied before hydrogen removal.
+defaults:
+  - /data/chembl3d/chembl3d@_here_
+  - _self_
+
+max_atoms: 100
+cache_name: ${data.dataset_name}_max${data.max_atoms}${if:${eq:${data.hydrogen_mode},implicit},_implicit_h,''}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/chembl3d/max100_implicit_h.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - /data/chembl3d/max100@_here_
+  - _self_
+
+hydrogen_mode: implicit

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/crossdocked/finetune.yaml

@@ -0,0 +1,67 @@
+defaults:
+  - /data/molecular@_here_
+  - _self_
+
+dataset_name: crossdocked
+dataset_target: morph.dataset.conditional.pocket.CrossDockedPocketDataset
+hydrogen_mode: implicit
+root: ${data.root_path}/crossdocked
+source_dir: ${oc.env:MORPH_CROSSDOCKED_RAW,null}
+pretrained_assets_root: ${oc.env:MORPH_PRETRAINED_ASSETS}
+pretrain_root: ${data.root_path}/chembl3d_implicit_h
+pretrain_source_dir: ${oc.env:CHEMBL3D_SOURCE_DIR,null}
+pretrain_max_atoms: null
+pretrain_allowed_atom_symbols: null
+finetune_fraction: 0.5 # p / 100, sampled per example with replacement
+train_epoch_size: null # source draws per epoch; defaults to retained fine-tuning size
+pocket_vocab: null # Filled from TRAIN pocket elements during datamodule setup.
+max_pocket_atoms: 512
+val_fraction: 0.02
+
+# Load the exact artifacts associated with the pretrained checkpoint.
+# Never discover a new ligand vocabulary/normalization for fine-tuning.
+preprocessing:
+  root: ${data.pretrained_assets_root}
+  train_dataset: null
+  atom_tokens_path: ${data.preprocessing.root}/atom_tokens.txt
+  edge_tokens_path: ${data.preprocessing.root}/edge_tokens.txt
+  charge_tokens_path: ${data.preprocessing.root}/charge_tokens.txt
+  distributions_path: ${data.preprocessing.root}/distributions.pt
+
+datamodule:
+  _target_: morph.dataset.conditional.pocket.datamodule.PocketLightningDataModule
+  pocket_vocab: ${data.pocket_vocab}
+  finetune_fraction: ${data.finetune_fraction}
+  train_epoch_size: ${data.train_epoch_size}
+  mix_seed: ${seed}
+  pretrain_dataset:
+    _target_: morph.dataset.unconditional.chembl3d.FlowMatchingChEMBL3DDataset
+    root: ${data.pretrain_root}
+    source_dir: ${data.pretrain_source_dir}
+    hydrogen_mode: ${data.hydrogen_mode}
+    max_atoms: ${data.pretrain_max_atoms}
+    allowed_atom_symbols: ${data.pretrain_allowed_atom_symbols}
+    preprocess_workers: ${data.preprocess_workers}
+    preprocess_chunk_size: ${data.preprocess_chunk_size}
+  datasets:
+    train:
+      root: ${data.root}
+      allowed_atom_symbols: null
+      max_pocket_atoms: ${data.max_pocket_atoms}
+      val_fraction: ${data.val_fraction}
+    val:
+      - _target_: ${data.dataset_target}
+        root: ${data.root}
+        source_dir: ${data.source_dir}
+        hydrogen_mode: ${data.hydrogen_mode}
+        max_pocket_atoms: ${data.max_pocket_atoms}
+        val_fraction: ${data.val_fraction}
+        preprocess_workers: ${data.preprocess_workers}
+    test:
+      - _target_: ${data.dataset_target}
+        root: ${data.root}
+        source_dir: ${data.source_dir}
+        hydrogen_mode: ${data.hydrogen_mode}
+        max_pocket_atoms: ${data.max_pocket_atoms}
+        val_fraction: ${data.val_fraction}
+        preprocess_workers: ${data.preprocess_workers}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/crossdocked/scaffold_decoration.yaml

@@ -0,0 +1,31 @@
+defaults:
+  - /data/crossdocked/finetune@_here_
+  - _self_
+
+# Morph's DiffDec task uses LibINVENT reaction cuts. Other shared cutters can
+# be selected explicitly (murcko, rgroup, linker).
+scaffold_kind: libinvent
+scaffold_groups_dir: ${data.root}/scaffold_groups
+enumerate_slicings: true
+# Fixed scaffold/pocket pairs with repeated draws enable retention, recovery,
+# within-condition uniqueness/diversity, RMSD, and scaffold-aware PoseBusters.
+# Unlike a topology-only panel, identical scaffolds in different pockets remain
+# distinct conditions. Splits with fewer pairs use all of them.
+eval_panel:
+  n_scaffolds: 512
+  samples_per_scaffold: 8
+  seed: 42
+# Denoise movable scaffold coordinates; physical Angstroms, training only.
+jitter_scale: 0.1
+insertion_assignment: nearest
+interpolator:
+  insertion_assignment: ${data.insertion_assignment}
+  jitter_scale: ${data.jitter_scale}
+
+datamodule:
+  _target_: morph.dataset.conditional.pocket.scaffold_pocket.ScaffoldPocketDataModule
+  scaffold_groups_dir: ${data.scaffold_groups_dir}
+  scaffold_kind: ${data.scaffold_kind}
+  enumerate_slicings: ${data.enumerate_slicings}
+  eval_panel: ${data.eval_panel}
+  rotate: true

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/geom/geom.yaml

@@ -0,0 +1,11 @@
+# GEOM-Drugs source format and default molecule subset.
+defaults:
+  - /data/molecular@_here_
+  - _self_
+
+dataset_name: geom
+dataset_target: morph.dataset.unconditional.geom.FlowMatchingGEOMDataset
+source_dir: ${oc.env:GEOM_SOURCE_DIR,null} # Optional prefiltered pickle directory.
+# Preserve the established GEOM subset. Limits apply before hydrogen removal.
+max_atoms: 72
+allowed_atom_symbols: [H, C, N, O, S, F, Cl, Br, P, I]

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/geom/implicit_h.yaml

@@ -0,0 +1,5 @@
+defaults:
+  - /data/geom/geom@_here_
+  - _self_
+
+hydrogen_mode: implicit

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/geom/scaffold_decoration.yaml

@@ -0,0 +1,38 @@
+# GEOM-Drugs data config for the **scaffold decoration** task.
+#
+# Mirrors configs/data/qm9/scaffold_decoration.yaml but on GEOM-Drugs: source
+# is the selected scaffold of each target; target is the full molecule. The model
+# learns to grow decoration atoms while denoising the retained scaffold.
+#
+# Inherits from configs/data/geom/geom.yaml and overrides:
+#   - datamodule._target_ -> ScaffoldLightningDataModule
+#
+# The scaffold cache is built lazily into ``scaffold_groups_dir`` on first run
+# (one file per split and scaffold kind) and reused afterwards.
+defaults:
+  - /data/geom/geom@_here_
+  - _self_
+
+scaffold_groups_dir: ${data.preprocessing.root}/processed/scaffold_groups
+scaffold_kind: rgroup # murcko, rgroup (BRICS), heavy (generate H), linker
+# Physical Angstroms, per coordinate axis. Used only by training interpolation.
+jitter_scale: 0.1
+# "substituent" restricts insertion parents to the target branch or its
+# scaffold attachments. This changes training supervision, not atom OT.
+insertion_assignment: nearest
+interpolator:
+  jitter_scale: ${data.jitter_scale}
+  insertion_assignment: ${data.insertion_assignment}
+# Exhaustive evaluation when eval_panel=null; training always draws randomly.
+enumerate_slicings: false
+eval_panel:
+  directory: ${data.scaffold_groups_dir}/eval_panels
+  n_scaffolds: 512
+  samples_per_scaffold: 8
+  seed: 42
+datamodule:
+  _target_: morph.dataset.conditional.scaffold.datamodule.ScaffoldLightningDataModule
+  scaffold_groups_dir: ${data.scaffold_groups_dir}
+  scaffold_kind: ${data.scaffold_kind}
+  enumerate_slicings: ${data.enumerate_slicings}
+  eval_panel: ${data.eval_panel}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/molecular.yaml

@@ -0,0 +1,136 @@
+# Shared drug-like molecular training and preprocessing configuration.
+
+root_path: ${oc.env:PROJECT_ROOT}/data
+preprocess_workers: 10
+preprocess_chunk_size: 128
+statistics_workers: ${data.preprocess_workers}
+hydrogen_mode: explicit
+# The mode is part of the cache path; changing it discovers fresh vocab/statistics.
+cache_name: ${data.dataset_name}${if:${eq:${data.hydrogen_mode},implicit},_implicit_h,''}
+source_dir: null
+max_atoms: null
+allowed_atom_symbols: null
+
+n_atoms_strategy: "uniform" # "approx", "empirical", "learned"
+# Uniform source-count support padding; explicit so inference and training can
+# be matched or ablated without code changes.
+uniform_n_atoms_padding: 5
+optimal_transport: "equivariant"
+# Physical Angstroms (converted to normalized coordinates internally). These
+# reproduce the former normalized 0.25 / 0.2 scales at GEOM's training-set std.
+# Physical Angstroms. Insertion bridge noise vanishes as (1-t); move noise is
+# the persistent training-time jitter floor for matched atoms and insertions
+# that are already present.
+ins_noise_scale: 0.65
+move_noise_scale: 0.5
+
+# Drug-like datasets contain charged species; allow them in validity metrics.
+allow_charged: true
+
+
+# Preprocessing configuration - computes tokens from data and distributions from training dataset only
+preprocessing:
+  _target_: morph.dataset.core.preprocessing.Preprocessing
+  _recursive_: false
+  root: ${data.root_path}/${data.cache_name}
+  num_workers: ${data.statistics_workers}
+  train_dataset: ${data.datamodule.datasets.train}
+  atom_tokens_path: ${data.preprocessing.root}/processed/atom_tokens.txt
+  edge_tokens_path: ${data.preprocessing.root}/processed/edge_tokens.txt
+  charge_tokens_path: ${data.preprocessing.root}/processed/charge_tokens.txt
+  distributions_path: ${data.preprocessing.root}/processed/distributions.pt
+  # Tokens and distributions will be discovered from data and saved to files
+  # On subsequent runs, they will be loaded from the files
+
+vocab: null
+
+interpolator:
+  _target_: morph.flow_matching.interpolation.Interpolator
+  distributions: null
+  optimal_transport: ${data.optimal_transport}
+  ins_noise_scale: ${data.ins_noise_scale}
+  move_noise_scale: ${data.move_noise_scale}
+  # Training-only categorical corruption; pairs are scaled per molecule to
+  # match the expected number of changed atoms. Clean targets stay unchanged.
+  atom_type_noise_prob: 0.0
+  # OT matching (cost always squared-Euclidean; move cost in Angstrom). c_move
+  # scales the squared move distance (A^2); c_ins/c_del/c_sub are fixed A^2 costs,
+  # directly comparable. At 6.125 each, delete+insert costs 3.5^2, so atoms
+  # farther than 3.5 A apart are left unmatched by default.
+  pre_align_iters: 2   # equivariant-OT inner loop (Hungarian+Kabsch) iters
+  c_move: 1.0
+  c_sub: 0.0
+  c_ins: 6.125
+  c_del: 6.125
+  del_schedule: ${schedule}
+  ins_schedule: ${schedule}
+  sub_schedule:
+    _target_: morph.flow_matching.schedules.SmoothstepSchedule
+    shift: 1.5
+  sub_e_schedule:
+    _target_: morph.flow_matching.schedules.SmoothstepSchedule
+    shift: 1.5
+
+datamodule:
+  _target_: morph.dataset.core.lightning_datamodule.LightningDataModule
+  # tokens and distributions will be passed from preprocessing in run.py
+
+  vocab: ${data.vocab}
+  distributions: null
+  representation: ${representation}
+
+  datasets:
+    train:
+      _target_: ${data.dataset_target}
+      root: ${data.preprocessing.root}
+      preprocess_workers: ${data.preprocess_workers}
+      preprocess_chunk_size: ${data.preprocess_chunk_size}
+      hydrogen_mode: ${data.hydrogen_mode}
+      source_dir: ${data.source_dir}
+      max_atoms: ${data.max_atoms}
+      allowed_atom_symbols: ${data.allowed_atom_symbols}
+      vocab: ${data.vocab}
+      distributions: null
+
+    val:
+      - _target_: ${data.dataset_target}
+        root: ${data.preprocessing.root}
+        preprocess_workers: ${data.preprocess_workers}
+        preprocess_chunk_size: ${data.preprocess_chunk_size}
+        hydrogen_mode: ${data.hydrogen_mode}
+        source_dir: ${data.source_dir}
+        max_atoms: ${data.max_atoms}
+        allowed_atom_symbols: ${data.allowed_atom_symbols}
+        vocab: ${data.vocab}
+        distributions: null
+
+    test:
+      - _target_: ${data.dataset_target}
+        root: ${data.preprocessing.root}
+        preprocess_workers: ${data.preprocess_workers}
+        preprocess_chunk_size: ${data.preprocess_chunk_size}
+        hydrogen_mode: ${data.hydrogen_mode}
+        source_dir: ${data.source_dir}
+        max_atoms: ${data.max_atoms}
+        allowed_atom_symbols: ${data.allowed_atom_symbols}
+        vocab: ${data.vocab}
+        distributions: null
+
+  interpolator: ${data.interpolator}
+
+  rotate: ${model.rotate}
+  n_augmentations: ${model.n_augmentations}
+
+  num_workers:
+    train: 10
+    val: 0
+    test: 0
+
+  batch_size:
+    train: 320
+    val: 128
+    test: 64
+
+  n_atoms_strategy: ${data.n_atoms_strategy}
+  uniform_n_atoms_padding: ${data.uniform_n_atoms_padding}
+  time_dist: ${model.module.time_dist}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/qm9/qm9.yaml

@@ -0,0 +1,106 @@
+## QM9 data and preprocessing configuration.
+
+dataset_name: qm9
+root_path: ${oc.env:PROJECT_ROOT}/data
+preprocess_workers: 0
+
+n_atoms_strategy: "uniform" # "approx", "empirical", "learned"
+# Expand both ends of the empirical count support for the uniform flow source.
+# QM9's minimum is already the hard lower bound of 3, so positive padding is
+# necessarily asymmetric; set to 0 for an unpadded 3--29 diagnostic prior.
+uniform_n_atoms_padding: 5
+optimal_transport: "equivariant"
+# Physical Angstroms (converted to normalized coordinates internally). Insertion
+# bridge noise vanishes as (1-t); move noise is the persistent training-time
+# jitter floor for matched atoms and insertions that are already present.
+ins_noise_scale: 0.35
+move_noise_scale: 0.3
+
+# QM9 contains only neutral molecules; charged species are treated as invalid.
+allow_charged: false
+
+
+# Preprocessing configuration - computes tokens from data and distributions from training dataset only
+preprocessing:
+  _target_: morph.dataset.core.preprocessing.Preprocessing
+  _recursive_: false
+  root: ${data.root_path}/qm9
+  train_dataset: ${data.datamodule.datasets.train}
+  # Canonical (representation-agnostic) cache. One preprocessing per dataset;
+  # representation-specific projection happens at runtime in the wrapper.
+  atom_tokens_path: ${data.preprocessing.root}/processed/atom_tokens.txt
+  edge_tokens_path: ${data.preprocessing.root}/processed/edge_tokens.txt
+  charge_tokens_path: ${data.preprocessing.root}/processed/charge_tokens.txt
+  distributions_path: ${data.preprocessing.root}/processed/distributions.pt
+
+vocab: None
+
+interpolator:
+  _target_: morph.flow_matching.interpolation.Interpolator
+  distributions: None
+  optimal_transport: ${data.optimal_transport}
+  ins_noise_scale: ${data.ins_noise_scale}
+  move_noise_scale: ${data.move_noise_scale}
+  # OT matching (cost always squared-Euclidean; move cost in Angstrom). c_move
+  # scales the squared move distance (A^2); c_ins/c_del/c_sub are fixed A^2 costs,
+  # directly comparable. At 6.125 each, delete+insert costs 3.5^2, so atoms
+  # farther than 3.5 A apart are left unmatched by default.
+  pre_align_iters: 2   # equivariant-OT inner loop (Hungarian+Kabsch) iters
+  c_move: 1.0
+  c_sub: 0.0
+  c_ins: 6.125
+  c_del: 6.125
+  del_schedule: ${schedule}
+  ins_schedule: ${schedule}
+  sub_schedule:
+    _target_: morph.flow_matching.schedules.SmoothstepSchedule
+    shift: 1.5
+  sub_e_schedule:
+    _target_: morph.flow_matching.schedules.SmoothstepSchedule
+    shift: 1.5
+
+datamodule:
+  _target_: morph.dataset.core.lightning_datamodule.LightningDataModule
+  # tokens and distributions will be passed from preprocessing in run.py
+
+  vocab: ${data.vocab}
+  distributions: None
+  representation: ${representation}
+
+  datasets:
+    train:
+      _target_: morph.dataset.unconditional.qm9.FlowMatchingQM9Dataset
+      root: ${data.root_path}/qm9
+      vocab: ${data.vocab}
+      distributions: None
+
+    val:
+      - _target_: morph.dataset.unconditional.qm9.FlowMatchingQM9Dataset
+        root: ${data.root_path}/qm9
+        vocab: ${data.vocab}
+        distributions: None
+
+    test:
+      - _target_: morph.dataset.unconditional.qm9.FlowMatchingQM9Dataset
+        root: ${data.root_path}/qm9
+        vocab: ${data.vocab}
+        distributions: None
+
+  interpolator: ${data.interpolator}
+
+  rotate: ${model.rotate}
+  n_augmentations: ${model.n_augmentations}
+
+  num_workers:
+    train: 10
+    val: 0
+    test: 0
+
+  batch_size:
+    train: 1024
+    val: 128
+    test: 32
+
+  n_atoms_strategy: ${data.n_atoms_strategy}
+  uniform_n_atoms_padding: ${data.uniform_n_atoms_padding}
+  time_dist: ${model.module.time_dist}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/data/qm9/scaffold_decoration.yaml

@@ -0,0 +1,32 @@
+# QM9 data config for the **scaffold decoration** task.
+#
+# Source is the selected scaffold of each target; target is the full molecule.
+# The model learns to grow the molecule by inserting decoration atoms
+# while denoising the retained scaffold.
+#
+# Inherits from configs/data/qm9/qm9.yaml and overrides:
+#   - datamodule._target_ → ScaffoldLightningDataModule
+#
+defaults:
+  - /data/qm9/qm9@_here_
+  - _self_
+
+scaffold_groups_dir: ${data.root_path}/qm9/processed/scaffold_groups
+scaffold_kind: rgroup # murcko, rgroup (BRICS), heavy (generate H), linker
+# Physical Angstroms, per coordinate axis. Used only by training interpolation.
+jitter_scale: 0.1
+interpolator:
+  jitter_scale: ${data.jitter_scale}
+# Exhaustive evaluation when eval_panel=null; training always draws randomly.
+enumerate_slicings: false
+eval_panel:
+  directory: ${data.scaffold_groups_dir}/eval_panels
+  n_scaffolds: 512
+  samples_per_scaffold: 8
+  seed: 42
+datamodule:
+  _target_: morph.dataset.conditional.scaffold.datamodule.ScaffoldLightningDataModule
+  scaffold_groups_dir: ${data.scaffold_groups_dir}
+  scaffold_kind: ${data.scaffold_kind}
+  enumerate_slicings: ${data.enumerate_slicings}
+  eval_panel: ${data.eval_panel}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/default.yaml

@@ -0,0 +1,25 @@
+defaults:
+  - _self_
+  # Single-knob presets bundle
+  # `data` + `embeddings` (with dataset-tuned ExtrapolatableCount params)
+  # plus the shared `core` group selections. Override individual groups as
+  # usual, e.g. `defaults=geom/geom model=backbones/dit embeddings=qm9`.
+  - defaults: qm9/qm9
+
+# What the model trains on. Datasets declare their CAPABILITIES; run.py validates
+# the requested mode against them before preprocessing.
+#   pointcloud         — x, a only (charges and edges are dummy singletons)
+#   charged_pointcloud — x, a, c   (edges are dummy singletons)
+#   geometric_graph    — x, a, edge_index, e (charges are dummy neutral)
+#   molecule           — full chemistry (current behavior)
+representation: molecule
+seed: 42
+
+# Run directory: <root>/<dataset>/<cfg_method>/<date>/<wandb_id>. Root is
+# MORPH_RUN_ROOT (scratch, set in .env) so every run's outputs/checkpoints/wandb
+# land off-repo; falls back to <cwd>/outputs for ad-hoc runs with no env set.
+# wandb id is MORPH_RUN_ID (same as WANDB_RUN_ID). Set in the shell before
+# torchrun, or set automatically for single-process runs in run.py before Hydra composes.
+hydra:
+  run:
+    dir: ${oc.env:MORPH_RUN_ROOT,${hydra:runtime.cwd}/outputs}/${hydra:runtime.choices.data}/${now:%Y-%m-%d}/${oc.env:MORPH_RUN_ID}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/chembl3d/chembl3d.yaml

@@ -0,0 +1,5 @@
+# @package _global_
+defaults:
+  - core
+  - /data: chembl3d/chembl3d
+  - /embeddings: geom

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/chembl3d/implicit_h.yaml

@@ -0,0 +1,5 @@
+# @package _global_
+defaults:
+  - /defaults/core
+  - /data: chembl3d/implicit_h
+  - /embeddings: geom

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/chembl3d/implicit_h_2x4090.yaml

@@ -0,0 +1,10 @@
+# @package _global_
+defaults:
+  - /defaults/chembl3d/train_2x4090
+  - override /data: chembl3d/max100_implicit_h
+  - _self_
+
+# Train from scratch: the atom vocabulary/statistics differ from the H model.
+# Preserve global batch 640, eval every epoch, both checkpoint callbacks every 5.
+logging:
+  project: morph-chembl3d-implicit-h

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/chembl3d/train_2x4090.yaml

@@ -0,0 +1,40 @@
+# @package _global_
+defaults:
+  - /defaults/core
+  - /data: chembl3d/max100
+  - /embeddings: geom
+  - _self_
+
+# Profiled on max100 ChEMBL: 2 GPUs * 320 * 1 = 640 effective global batch.
+data:
+  datamodule:
+    train_prefetch_factor: 1
+    batch_size:
+      train: 320
+      val: 32
+      test: 32
+    num_workers:
+      train: 20
+      val: 2
+      test: 2
+
+trainer:
+  trainer:
+    accelerator: gpu
+    devices: 2
+    accumulate_grad_batches: 1
+    max_epochs: -1
+    check_val_every_n_epoch: 1
+    num_val_samples: 4096
+  # Validation runs during fit; leave wall-clock headroom for final checkpointing.
+  do_validate: false
+  do_predict: false
+  final_checkpoint_path: final.ckpt
+
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 5
+  every_n_epochs_checkpoint:
+    every_n_epochs: 5
+    save_top_k: -1
+    save_last: link

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/core.yaml

@@ -0,0 +1,13 @@
+# @package _global_
+# Shared default groups that don't change between QM9 / GEOM runs.
+# Dataset-specific presets (defaults/qm9/qm9.yaml, defaults/geom/geom.yaml) inherit
+# from this and only add `data` + `embeddings`.
+defaults:
+  - /heads: head
+  - /insertion_head: unimodal
+  - /model: backbones/dit
+  - /schedule: smoothstep
+  - /trainer: trainer
+  - /callbacks: callbacks
+  - /logging: wandb_logger
+  - /integrator: integrator

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/crossdocked/finetune.yaml

@@ -0,0 +1,16 @@
+# @package _global_
+defaults:
+  - /defaults/core
+  - /data: crossdocked/finetune
+  - /embeddings: geom
+  - override /model: finetune/pocket_finetune
+  - _self_
+
+trainer:
+  trainer:
+    # ReplaySampler already partitions its stream between DDP ranks.
+    use_distributed_sampler: false
+    check_val_every_n_epoch: 1
+
+logging:
+  project: morph-crossdocked-finetune

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/crossdocked/scaffold_decoration.yaml

@@ -0,0 +1,9 @@
+# @package _global_
+defaults:
+  - /defaults/crossdocked/finetune
+  - override /data: crossdocked/scaffold_decoration
+  - override /model: finetune/scaffold_pocket_finetune
+  - _self_
+
+logging:
+  project: morph-crossdocked-scaffold-finetune

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/crossdocked/scaffold_decoration_2x4090.yaml

@@ -0,0 +1,51 @@
+# @package _global_
+defaults:
+  - /defaults/crossdocked/scaffold_decoration
+  - _self_
+
+data:
+  pretrain_root: ${data.root_path}/chembl3d_max100_implicit_h
+  pretrain_max_atoms: 100
+  finetune_fraction: 0.5
+  # 400 optimizer updates per epoch at global batch 256.
+  train_epoch_size: 102400
+  datamodule:
+    train_prefetch_factor: 1
+    batch_size:
+      train: 32
+      val: 8
+      test: 8
+    num_workers:
+      train: 6
+      val: 2
+      test: 2
+
+model:
+  module:
+    # LoRA, conditioning modules, and complete prediction heads train with replay.
+    # Peak Muon/Adam rates are inherited from scaffold_pocket_finetune.
+    optimizer_config:
+      scheduler:
+        warmup_steps: 1000
+        total_steps: 40000
+
+trainer:
+  trainer:
+    accelerator: gpu
+    devices: 2
+    accumulate_grad_batches: 4
+    max_epochs: 100
+    check_val_every_n_epoch: 5
+    # Evaluate the complete repeated panel; truncation biases conditional scores.
+    num_val_samples: null
+  do_validate: false
+  do_predict: false
+  final_checkpoint_path: final.ckpt
+
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 5
+  every_n_epochs_checkpoint:
+    every_n_epochs: 5
+    save_top_k: -1
+    save_last: link

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/geom/geom.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+# GEOM preset: shared core + GEOM data and embeddings.
+defaults:
+  - core
+  - /data: geom/geom
+  - /embeddings: geom
+  - _self_
+
+# Evaluate every epoch; keep every fifth completed epoch for releases/resuming.
+trainer:
+  trainer:
+    check_val_every_n_epoch: 1
+
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 5
+  every_n_epochs_checkpoint:
+    every_n_epochs: 5
+    save_top_k: -1
+    save_last: link

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/geom/implicit_h.yaml

@@ -0,0 +1,5 @@
+# @package _global_
+defaults:
+  - /defaults/core
+  - /data: geom/implicit_h
+  - /embeddings: geom

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/geom/scaffold_decoration.yaml

@@ -0,0 +1,39 @@
+# @package _global_
+# GEOM-Drugs **scaffold decoration** fine-tune preset.
+#
+# Mirrors defaults/qm9/scaffold_decoration.yaml on GEOM-Drugs. Bare-scaffold
+# source -> full-molecule target: the model learns to grow a molecule by
+# inserting decoration atoms while allowing scaffold coordinates to move.
+#
+# Differences from the QM9 scaffold preset:
+#   - data       -> geom/scaffold_decoration (GEOM base datasets)
+#   - embeddings -> geom
+#
+# Reuses the scaffold_finetune model config (loads the pretrained unconditional
+# DiT into the clean lane + adds the node/edge conditioning and the gated
+# cross-attn blocks).
+#
+# Pair with a GEOM unconditional DiT checkpoint via
+# ``model.module.pretrained_ckpt=...``.
+defaults:
+  - /defaults/core
+  - /data: geom/scaffold_decoration
+  - /embeddings: geom
+  - override /model: finetune/scaffold_finetune
+  - _self_
+
+# Evaluate each completed epoch; retain checkpoints every five epochs.
+trainer:
+  trainer:
+    check_val_every_n_epoch: 1
+
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 5
+  every_n_epochs_checkpoint:
+    every_n_epochs: 5
+    save_top_k: -1
+    save_last: link
+
+logging:
+  project: morph-${data.dataset_name}-scaffold-decoration

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/geom/scaffold_decoration_2x4090.yaml

@@ -0,0 +1,27 @@
+# @package _global_
+defaults:
+  - /defaults/geom/scaffold_decoration
+  - _self_
+
+# Starting point for future GEOM scaffold runs on two 24-GiB GPUs.
+# The epoch-100 Murcko runs used 160/GPU with accumulation 2; reported GPU
+# memory usage was only 33% (full) / 29% (LoRA). Double the microbatch while
+# preserving the effective batch: 2 GPUs * 320 * 1 = 640.
+# Profile peak memory and throughput before choosing still larger batches.
+data:
+  datamodule:
+    train_prefetch_factor: 1
+    batch_size:
+      train: 320
+      val: 32
+      test: 32
+    num_workers:
+      train: 20
+      val: 0
+      test: 0
+
+trainer:
+  trainer:
+    accelerator: gpu
+    devices: 2
+    accumulate_grad_batches: 1

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/geom/scaffold_decoration_scratch_2x4090.yaml

@@ -0,0 +1,44 @@
+# @package _global_
+# Train GEOM-Drugs Murcko decoration from scratch, using the scaffold protocol.
+defaults:
+  - /defaults/geom/scaffold_decoration_2x4090
+  - _self_
+
+seed: 42
+
+data:
+  scaffold_kind: murcko
+  jitter_scale: 0.1
+
+model:
+  module:
+    pretrained_ckpt: null
+    freeze_pretrained_backbone: false
+    freeze_output_heads: false
+    freeze_keep_positions: false
+    exclude_scaffold_from_x_loss: false
+    optimizer_config:
+      optimizer:
+        lr: 1e-3
+      aux_optimizer:
+        lr: 1e-4
+  lora:
+    enabled: false
+    freeze_base: false
+
+trainer:
+  trainer:
+    max_epochs: 50
+    check_val_every_n_epoch: 1
+    num_val_samples: 4096
+    enable_progress_bar: false
+    max_time:
+      hours: 47
+  checkpoint_path: null
+  final_checkpoint_path: final.ckpt
+  do_validate: false
+  do_predict: false
+
+logging:
+  group: geom-murcko-scratch
+  tags: [geom, explicit-h, murcko, scaffold-decoration, scratch, full-model, movable, jitter-0.1A]

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/qm9/qm9.yaml

@@ -0,0 +1,20 @@
+# @package _global_
+# QM9 preset: shared core + QM9 data and embeddings.
+defaults:
+  - /defaults/core
+  - /data: qm9/qm9
+  - /embeddings: qm9
+  - _self_
+
+trainer:
+  trainer:
+    check_val_every_n_epoch: 1
+
+# Keep the full 25-epoch checkpoint history for model releases and resuming.
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 25
+  every_n_epochs_checkpoint:
+    every_n_epochs: 25
+    save_top_k: -1
+    save_last: link

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/qm9/scaffold_decoration.yaml

@@ -0,0 +1,27 @@
+# @package _global_
+# QM9 **scaffold decoration** fine-tune preset.
+#
+# Bare-scaffold source → full-molecule target. The model learns to grow
+# a molecule by inserting decoration atoms while scaffold coordinates may move.
+defaults:
+  - core
+  - /data: qm9/scaffold_decoration
+  - /embeddings: qm9
+  - override /model: finetune/scaffold_finetune
+  - _self_
+
+# Evaluate each completed epoch; retain checkpoints every five epochs.
+trainer:
+  trainer:
+    check_val_every_n_epoch: 1
+
+callbacks:
+  model_checkpoints:
+    every_n_epochs: 5
+  every_n_epochs_checkpoint:
+    every_n_epochs: 5
+    save_top_k: -1
+    save_last: link
+
+logging:
+  project: morph-${data.dataset_name}-scaffold-decoration

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/defaults/qm9/train_2x4090.yaml

@@ -0,0 +1,29 @@
+# @package _global_
+defaults:
+  - /defaults/qm9/qm9
+  - _self_
+
+# Preserve the established QM9 effective batch: 2 GPUs * 1024 * 2 = 4096.
+data:
+  datamodule:
+    train_prefetch_factor: 1
+    batch_size:
+      train: 1024
+      val: 128
+      test: 32
+    num_workers:
+      train: 20
+      val: 2
+      test: 2
+
+trainer:
+  trainer:
+    accelerator: gpu
+    devices: 2
+    accumulate_grad_batches: 2
+    max_epochs: 3000
+    check_val_every_n_epoch: 1
+    num_val_samples: 4096
+  do_validate: false
+  do_predict: false
+  final_checkpoint_path: final.ckpt

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/embeddings/geom.yaml

@@ -0,0 +1,28 @@
+# Shared embedding stack tuned for GEOM-Drugs.
+# - node_count_embedding uses ExtrapolatableCountEmbedding with periods/max_count
+#   scaled up for the much larger atom counts in GEOM-Drugs.
+
+atom_type_embedding:
+  _target_: morph.model.layers.embedding.Embedding
+  num_embeddings: ${len:${data.vocab.atom_tokens}}
+  embedding_dim: 64
+  out_dim: 128
+
+edge_type_embedding:
+  _target_: morph.model.layers.embedding.Embedding
+  num_embeddings: ${len:${data.vocab.edge_tokens}}
+  embedding_dim: 64
+  out_dim: 128
+
+time_embedding:
+  _target_: morph.model.layers.embedding.TimeEmbedding
+  embedding_dim: 128
+  out_dim: 128
+
+node_count_embedding:
+  _target_: morph.model.layers.embedding.ExtrapolatableCountEmbedding
+  embedding_dim: 64
+  out_dim: 128
+  min_period: 128.0
+  max_period: 1024.0
+  max_count: 96.0

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/embeddings/qm9.yaml

@@ -0,0 +1,29 @@
+# Shared embedding stack tuned for QM9.
+# - node_count_embedding uses ExtrapolatableCountEmbedding so the model can
+#   generalise slightly outside the training atom-count support.
+# - Defaults sized for QM9 (training counts in [3, 29]).
+
+atom_type_embedding:
+  _target_: morph.model.layers.embedding.Embedding
+  num_embeddings: ${len:${data.vocab.atom_tokens}}
+  embedding_dim: 64
+  out_dim: 128
+
+edge_type_embedding:
+  _target_: morph.model.layers.embedding.Embedding
+  num_embeddings: ${len:${data.vocab.edge_tokens}}
+  embedding_dim: 64
+  out_dim: 128
+
+time_embedding:
+  _target_: morph.model.layers.embedding.TimeEmbedding
+  embedding_dim: 128
+  out_dim: 128
+
+node_count_embedding:
+  _target_: morph.model.layers.embedding.ExtrapolatableCountEmbedding
+  embedding_dim: 64
+  out_dim: 128
+  min_period: 64.0
+  max_period: 512.0
+  max_count: 32.0

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/heads/head.yaml

@@ -0,0 +1,75 @@
+# Standard molecular DiT readouts. The insertion-content head is an independent
+# Hydra choice (``insertion_head=unimodal`` by default, or ``=gmm``).
+
+heads:
+  _target_: morph.model.layers.heads.MultiHeadModule
+  output_init_std: ${model.head_initialization.output_std}
+  independent_adapters: ${oc.select:model.head_independent_adapters,false}
+
+  heads_configs:
+    graph_aggregation: mean
+
+    node_heads:
+      atom_type_head:
+        input_dim: ${model.head_node_dim}
+        output_dim: ${len:${data.vocab.atom_tokens}}
+        adapter_dim: ${model.head_node_adapter_dim}
+        group: state
+
+      charge_head:
+        input_dim: ${model.head_node_dim}
+        output_dim: ${len:${data.vocab.charge_tokens}}
+        adapter_dim: ${model.head_node_adapter_dim}
+        group: state
+
+      ins_rate_head:
+        input_dim: ${model.head_node_dim}
+        output_dim: 1
+        adapter_dim: ${model.head_node_adapter_dim}
+        group: edit
+        initial_rate: ${model.head_initialization.ins_rate}
+
+      do_del_head:
+        input_dim: ${model.head_node_dim}
+        output_dim: 1
+        adapter_dim: ${model.head_node_adapter_dim}
+        group: edit
+        initial_probability: ${model.head_initialization.do_del_probability}
+
+      do_sub_a_head:
+        input_dim: ${model.head_node_dim}
+        output_dim: 1
+        adapter_dim: ${model.head_node_adapter_dim}
+        group: edit
+        initial_probability: ${model.head_initialization.do_sub_a_probability}
+
+    edge_heads:
+      edge_type_head:
+        input_dim: ${model.head_edge_dim}
+        output_dim: ${len:${data.vocab.edge_tokens}}
+        adapter_dim: ${model.head_edge_adapter_dim}
+        group: state
+
+      do_sub_e_head:
+        input_dim: ${model.head_edge_dim}
+        output_dim: 1
+        adapter_dim: ${model.head_edge_adapter_dim}
+        group: state
+        initial_probability: ${model.head_initialization.do_sub_e_probability}
+
+ins_edge_head:
+  _target_: morph.model.layers.heads.InsertionEdgeHead
+  _recursive_: false
+  hidden_dim: ${model.head_node_dim}
+  readout_dim: ${model.head_insertion_edge_dim}
+  output_init_std: ${model.head_initialization.output_std}
+  n_edge_types: ${len:${data.vocab.edge_tokens}}
+  n_atom_types: ${len:${data.vocab.atom_tokens}}
+  n_charge_types: ${len:${data.vocab.charge_tokens}}
+  rbf_embedding_args:
+    _target_: morph.model.layers.embedding.RBFEmbedding
+    num_rbf: 128
+    rbf_dmax: 3.5
+    out_dim: 64
+    dropout: 0.0
+    trainable: false

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/insertion_head/gmm.yaml

@@ -0,0 +1,16 @@
+# Optional mixture-density insertion-content head.
+mode: gmm
+dimension: 3
+num_components: 10
+
+model:
+  _target_: morph.model.layers.heads.GMMInsertionHead
+  hidden_dim: ${model.head_node_dim}
+  readout_dim: ${model.head_insertion_adapter_dim}
+  output_init_std: ${model.head_initialization.output_std}
+  num_components: ${insertion_head.num_components}
+  sigma_min: 0.05
+  sigma_max: 2.0
+  sigma_init: 0.5
+  N_a: ${len:${data.vocab.atom_tokens}}
+  N_c: ${len:${data.vocab.charge_tokens}}

geom/scaffold_murcko_substituent_lora_r16/runtime/configs/insertion_head/unimodal.yaml

@@ -0,0 +1,13 @@
+# Default insertion-content head: one nearest pending atom per spawning node.
+mode: unimodal
+dimension: 3
+num_components: 1
+
+model:
+  _target_: morph.model.layers.heads.UnimodalInsertionHead
+  hidden_dim: ${model.head_node_dim}
+  readout_dim: ${model.head_insertion_adapter_dim}
+  output_init_std: ${model.head_initialization.output_std}
+  independent_adapters: ${oc.select:model.head_independent_adapters,false}
+  N_a: ${len:${data.vocab.atom_tokens}}
+  N_c: ${len:${data.vocab.charge_tokens}}