Add files using upload-large-folder tool

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/README.md

@@ -0,0 +1,64 @@
+# SeqFunc smoke00
+
+This is an initial pipeline checkpoint, not a fully trained scientific result.
+
+The single model has 13,218,756 trainable parameters. A convolutional encoder maps the complete
+1,048,576-base DNA input to 1,024 tokens, followed by six 384-wide transformer blocks and shared
+heads for all eleven output families. Dense heads predict 128-bp bins; splice sites use per-offset
+logits, usage uses predicted positions, junctions use low-rank donor/acceptor factors, and contacts
+use symmetric token products. The implementation is derived from the supplied reference code.
+
+All parameters were initialized locally with seed 17. This checkpoint ran 16 optimizer steps on
+the first 16 eligible training intervals, using quantized targets decoded by the supplied reader,
+on one H100 80 GB on 2026-10-22. The measured training loop took 4.0 seconds, excluding setup.
+This short run checks the pipeline; it does not yet meet the intended full-training coverage.
+Subsequent experiments use every one of the 41,020 eligible intervals per epoch. No pretrained
+parameters, validation training labels, test labels, or test-derived caches were used.
+
+Both executable entry points take INPUT_ROOT and OUTPUT_ROOT. They use only public manifests and
+the pinned reference FASTA. The package includes its CPython 3.11 environment, PyTorch 2.7.1 CUDA
+12.6 runtime, and all Python dependencies in runtime.tar.gz. Entry points extract this environment
+into a temporary directory, run offline, and remove it on completion. The host supplies Linux,
+bash/tar/gzip and the NVIDIA driver. Model parameters are last.pt; source code and a SHA-256
+manifest are included. Track values are float16; perturbation values are float32.
+
+Validation reports accompanying publication cover all 200 validation intervals (validation_tracks.json)
+and all 2,697 development perturbations across 13 evaluations (validation_variants.json). These are
+scored by the unmodified verifier tools. The checkpoint is deliberately undertrained, its splicing
+head lacks a local base-resolution encoder, and variant effects should not be used clinically.
+The supplied 215M baseline has validation family-mean Pearson 0.302; this checkpoint is a pipeline
+milestone, not a claim to improve that baseline.
+
+## Measured validation results
+
+Family-mean Pearson: **0.004141** on 200 validation intervals.
+
+| Family | Pearson |
+|---|---:|
+| atac | 0.004916 |
+| dnase | -0.000656 |
+| procap | 0.047810 |
+| cage | -0.000640 |
+| rna_seq | -0.002504 |
+| chip_tf | 0.002254 |
+| chip_histone | 0.000647 |
+| splice_sites | 0.000067 |
+| splice_usage | -0.000982 |
+| junctions | 0.000000 |
+| contact_maps | -0.005367 |
+
+| Development evaluation | Metric | Model | Published anchors on the same rows |
+|---|---|---:|---|
+| eqtl_sign | auroc | 0.4941 | AlphaGenome: 0.8264 |
+| eqtl_causality | auroc | 0.6542 | AlphaGenome: 0.8325 |
+| eqtl_coefficient | spearman | -0.0486 | AlphaGenome: 0.4134 |
+| sqtl_causality | auprc | 0.8434 | AlphaGenome: 0.8447 |
+| clinvar_noncoding | auprc | 0.1946 | AlphaGenome: 0.9410 |
+| clinvar_splice_region | auprc | 0.1778 | AlphaGenome: 0.7225 |
+| clinvar_missense | auprc | 0.2330 | AlphaGenome: 0.3738 |
+| mfass | auprc | 0.2177 | AlphaGenome: 0.7343 |
+| caqtl | auprc | 0.1637 | AlphaGenome: 0.8076 |
+| bqtl_spi1 | auprc | 0.2077 | AlphaGenome: 0.8167 |
+| enhancer_gene | auprc | 0.4133 | AlphaGenome: 0.9594 |
+| traitgym_mendelian | auprc | 0.2092 | Borzoi_L2_L2.plus.all: 0.5026; Enformer_L2_L2.plus.all: 0.5453; CADD.plus.RawScore: 0.7189; GPN-MSA_absLLR.plus.score: 0.6729 |
+| traitgym_complex | auprc | 0.2001 | Borzoi_L2_L2.plus.all: 0.2945; Enformer_L2_L2.plus.all: 0.2692; CADD.plus.RawScore: 0.4134; GPN-MSA_absLLR.plus.score: 0.4214 |

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/infer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: infer.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/predict.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/package_manifest.json

@@ -0,0 +1,26 @@
+{
+  "parameters": 13218756,
+  "source_checkpoint_sha256": "a8d6d7e5a4852d7e869b05d30ed4086a1ed8f2c5711b8a8baaf909f8cccc63f8",
+  "files": {
+    "README.md": "325e8e0af474a1a5ed730515b06f61cc57aff5ed6148c951f5287783372e7de6",
+    "infer.sh": "ef810532b1e72b85fbe283e4f52c177bb70025977dbb2345d75837c9bbd51e37",
+    "last.pt": "fd99cef3f7bff9a57881cb645a717ae2812f4d5a2229bfd96f288a5cbbd024bc",
+    "perturb.py": "ba37a6f9f8b8eccb052903618bcb4c91d3f4cbed62dfe678ee362644dc80801e",
+    "perturb.sh": "113ec2383276a6e83fe1e4e8b0fa914f8d535d5dd0f5b2c34240140312dd5fb4",
+    "predict.py": "2725592456c55c188b22c376f0cb249e9f46b4ae1370d2226df7143da358a8b2",
+    "prediction_contract.py": "b11af8f7cff82b35afc6282be387358a48464b78bd1dfa44452dace26a5e0a83",
+    "reference/__init__.py": "45f3cf93f48859104e70bb58d717130dfd6521a45d2aba06b1a726afc0dc51dd",
+    "reference/alphagenome_50m/__init__.py": "a5a7e45d5940c3b201017c6322128e9f47efd37e1d29f717da2c1f787688eff9",
+    "reference/alphagenome_50m/alphagenome_50m.yaml": "3cac32e9f55e352dff78bb85ac892fdae1f9e412d9bba3e945750210c5252eee",
+    "reference/alphagenome_50m/dataset.py": "ad6670f742f4de9898064becc525d0aea98b402abe7b210bb1b26a9eee6402b9",
+    "reference/alphagenome_50m/layers.py": "26a116a72aa3f0e307a3606163547edbdecb7965f7fdcd96bc5f805cd21b3352",
+    "reference/alphagenome_50m/model.py": "713940fd2b335bf1ce16d1d76241a174f42c3ec15ebdf5c97c1e03f9cd691293",
+    "reference/alphagenome_50m/reference_large.yaml": "68084d299b39418034c6bbf71db174c3ffa68bbeea8779c1694e44ec71f3529c",
+    "reference/alphagenome_50m/run_ddp.sh": "96d35a24a4e6789311501fb98203807ac0c4429375c44d5c6671908270c93bb0",
+    "reference/alphagenome_50m/tiny_overfit.yaml": "f7a104c3929de0530a9a8f73f66d794cca595aefad8ef262e09ecbeb9cfce6de",
+    "reference/alphagenome_50m/train_eval.py": "2547c9adbdb51ad1acf796a548724cc7770eba90a755f4cb3b37d6f591adf6ec",
+    "runtime.tar.gz": "718da4c374e0c552b6e429b226c90b2fded5c900d95577d190d4df520aaf3901",
+    "validation_tracks.json": "73a44a7400dce3e367ed4aa3fb4fd4b4d14524acad6aaea26843fc89813d9519",
+    "validation_variants.json": "74ea2d8e1f2714cd73a6a71bdc5f302139075871e85b7a3100b349c9d9472c84"
+  }
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/perturb.py

@@ -0,0 +1,101 @@
+"""Predict both sequences of every perturbation (contract: perturbations/v1).
+
+    python perturb.py INPUT_ROOT OUTPUT_ROOT --checkpoint last.pt
+
+INPUT_ROOT holds `public/perturbations.parquet` and `reference/GRCh38.p13.genome.fa` (in the
+workspace, `/workspace/data` works too: the queries are then read from `variant_evals/public/`). Each row is a
+1,048,576-bp window starting at `input_start` and an edit spanning [edit_start, edit_end) in genomic
+0-based coordinates:
+
+- `snv`: sequence A carries `allele_a` at edit_start, sequence B carries `allele_b` (both are written
+  explicitly; either may differ from the reference genome);
+- `mask`: sequence A is the reference, sequence B has the interval replaced by N.
+
+For each perturbation the output group `perturbations/p{index:06d}` holds `a/<family>` and
+`b/<family>` for every family in `families`: dense families sliced to bins
+[dense_bin_start, dense_bin_end) of the central target window, and `splice_sites` sliced to bp
+[splice_start, splice_end). Values are the same quantities as predictions.zarr (asinh space for
+dense tracks, splice-site scores for splice_sites).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import pandas as pd
+import pysam
+import torch
+import zarr
+
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+PERTURBATION_SCHEMA = "genome-sequence-to-function-perturbations/v1"
+COMPRESSOR = Blosc(cname="zstd", clevel=3, shuffle=Blosc.BITSHUFFLE)
+
+
+def sequences(fasta, row) -> tuple[str, str]:
+    length = fasta.get_reference_length(row.chrom)
+    start, end = int(row.input_start), int(row.input_start) + 1_048_576
+    sequence = fasta.fetch(row.chrom, max(0, start), min(length, end)).upper()
+    sequence = "N" * max(0, -start) + sequence + "N" * max(0, end - length)
+    lo, hi = int(row.edit_start) - start, int(row.edit_end) - start
+    if row.edit == "snv":
+        return sequence[:lo] + row.allele_a + sequence[hi:], sequence[:lo] + row.allele_b + sequence[hi:]
+    if row.edit == "mask":
+        return sequence, sequence[:lo] + "N" * (hi - lo) + sequence[hi:]
+    raise ValueError(f"unknown edit {row.edit!r}")
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, queries: Path | None = None) -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    if queries is None:
+        queries = input_root / "public/perturbations.parquet"
+        if not queries.exists():
+            queries = input_root / "variant_evals/public/perturbations.parquet"
+    rows = pd.read_parquet(queries)
+    fasta = pysam.FastaFile(str(input_root / "reference/GRCh38.p13.genome.fa"))
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "perturbations.zarr"), mode="w")
+    target_start = (config.input_length - config.target_length) // 2
+    with torch.inference_mode():
+        for index, row in enumerate(rows.itertuples(index=False)):
+            pair = sequences(fasta, row)
+            dna = torch.from_numpy(np.stack([AlphaGenomeDataset._one_hot(s) for s in pair])).to(device)
+            trunk = model._trunk(dna)
+            group = root.create_group(f"perturbations/p{index:06d}")
+            features = None
+            for family in row.families:
+                if family == "splice_sites":
+                    logits = model._splice_site_logits(trunk)[:, target_start:target_start + config.target_length]
+                    values = logits[:, row.splice_start:row.splice_end]
+                else:
+                    features = model._dense_features(trunk) if features is None else features
+                    values = model.dense_heads[family](features)[:, row.dense_bin_start:row.dense_bin_end]
+                # float32: one variant's effect is often below float16 resolution (about 0.004 at
+                # asinh values of 4-8), so A and B would round to the same numbers.
+                values = values.float().cpu().numpy()
+                for side, array in zip("ab", values):
+                    group.create_dataset(f"{side}/{family}", data=array, compressor=COMPRESSOR)
+            print(json.dumps({"event": "perturb", "done": index + 1, "total": len(rows)}), flush=True)
+    root.attrs.update({"schema": PERTURBATION_SCHEMA,
+                       "perturbation_ids": rows.perturbation_id.astype(str).tolist()})
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--queries", type=Path, help="another query table, e.g. the development split")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.queries)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/perturb.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: perturb.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/perturb.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/predict.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Stream the single benchmark model into the sharded prediction contract."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import torch
+import zarr
+
+from prediction_contract import DENSE_TRACKS, MAX_JUNCTION_PAIRS, MAX_USAGE_SITES, PREDICTION_SCHEMA
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+
+COMPRESSOR = Blosc(cname="zstd", clevel=7, shuffle=Blosc.BITSHUFFLE)
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, split: str = "test") -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    dataset = AlphaGenomeDataset(input_root, split, include_targets=False)
+    model.set_junction_track_halves(dataset.junction_track_halves)
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "predictions.zarr"), mode="w")
+    ids = []
+    with torch.inference_mode():
+        for sample in dataset:
+            example_id = sample["example_id"]
+            dna = sample["dna"][None].to(device)
+            trunk = model._trunk(dna)
+            dense_features = model._dense_features(trunk)
+            group = root.create_group(f"examples/{example_id}")
+            for family in DENSE_TRACKS:
+                values = model.dense_heads[family](dense_features)[0]
+                group.create_dataset(family, data=values.cpu().numpy().astype(np.float16), compressor=COMPRESSOR)
+
+            all_site_logits = model._splice_site_logits(trunk)
+            target_start = (config.input_length - config.target_length) // 2
+            group.create_dataset(
+                "splice_sites",
+                data=all_site_logits[0, target_start:target_start + config.target_length].cpu().numpy().astype(np.float16),
+                chunks=(4096, 4), compressor=COMPRESSOR,
+            )
+            predicted_positions = model.select_junction_positions(all_site_logits)[0]
+
+            # Usage at the model's own predicted sites (v4 is sparse; unlisted hidden sites score 0).
+            usage_bins = model.splice_usage_head(dense_features)[0].float()
+            sites = predicted_positions.cpu().numpy().astype(np.int64).reshape(-1)
+            sites = np.unique(sites[(sites >= target_start) & (sites < target_start + config.target_length)]
+                              - target_start)[:MAX_USAGE_SITES]
+            group.create_dataset("splice_usage_positions", data=sites.astype(np.int32), compressor=COMPRESSOR)
+            usage = usage_bins[torch.as_tensor(sites // 128, device=usage_bins.device)] if len(sites) \
+                else usage_bins[:0]
+            group.create_dataset("splice_usage", data=usage.cpu().numpy().astype(np.float16),
+                                 chunks=(1024, 734), compressor=COMPRESSOR)
+
+            # Junctions: score every donor x acceptor pair of each strand, keep the strongest pairs.
+            positions_batch = predicted_positions[None]
+            site_factors = model.junction_site_factors(trunk, positions_batch)
+            halves = model.junction_track_half
+            candidates = []
+            for row_start in range(0, 512, 128):
+                for column_start in range(0, 512, 128):
+                    block = torch.cat([
+                        model.junction_block(
+                            trunk, positions_batch, row_start, row_start + 128,
+                            column_start, column_start + 128, track_start,
+                            min(track_start + 64, config.junction_tracks), site_factors,
+                        )[0]
+                        for track_start in range(0, config.junction_tracks, 64)
+                    ], dim=-1).float()  # [128, 128, 734]
+                    for half in (0, 1):
+                        donors = predicted_positions[2 * half, row_start:row_start + 128]
+                        acceptors = predicted_positions[2 * half + 1, column_start:column_start + 128]
+                        valid = (donors[:, None] >= 0) & (acceptors[None, :] >= 0)
+                        strength = block[..., halves == half].amax(dim=-1).masked_fill(~valid, -torch.inf)
+                        keep = min(MAX_JUNCTION_PAIRS // 2, int(valid.sum()))
+                        if not keep:
+                            continue
+                        best = strength.flatten().topk(keep)
+                        rows, columns = best.indices // 128, best.indices % 128
+                        candidates.append((best.values, torch.full_like(rows, half), donors[rows],
+                                           acceptors[columns], block[rows, columns]))
+            if candidates:
+                score, half, donor, acceptor, values = (torch.cat(x) for x in zip(*candidates))
+                order = score.topk(min(MAX_JUNCTION_PAIRS, len(score))).indices
+                half, donor, acceptor, values = half[order], donor[order], acceptor[order], values[order]
+            else:
+                half = donor = acceptor = torch.zeros(0, dtype=torch.long)
+                values = torch.zeros(0, config.junction_tracks)
+            group.create_dataset("junction_half", data=half.cpu().numpy().astype(np.int8), compressor=COMPRESSOR)
+            group.create_dataset("junction_donor", data=donor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junction_acceptor", data=acceptor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junctions", data=values.cpu().numpy().astype(np.float16),
+                                 chunks=(4096, 734), compressor=COMPRESSOR)
+
+            contact = trunk.reshape(
+                1, config.contact_bins, -1, config.hidden_dim
+            ).mean(dim=2)
+            q, k = model.contact_q(contact), model.contact_k(contact)
+            row, column = model.contact_row, model.contact_column
+            contact_values = 0.5 * (q[:, row] * k[:, column] + q[:, column] * k[:, row])
+            group.create_dataset(
+                "contact_maps", data=contact_values[0].cpu().numpy().astype(np.float16),
+                chunks=(8192, 28), compressor=COMPRESSOR,
+            )
+            ids.append(example_id)
+            print(json.dumps({"event": "predict", "example": len(ids), "total": len(dataset)}), flush=True)
+    root.attrs.update({"schema": PREDICTION_SCHEMA, "example_ids": ids})
+    (output_root / "example_ids.json").write_text(json.dumps(ids) + "\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--split", default="test", choices=("valid", "test"),
+                        help="manifest to predict; the verifier uses test, local validation uses valid")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.split)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/prediction_contract.py

@@ -0,0 +1,23 @@
+"""Public prediction shapes; no trusted splice coordinates are exposed."""
+
+from __future__ import annotations
+
+DENSE_TRACKS = {
+    "atac": 167,
+    "dnase": 305,
+    "procap": 12,
+    "cage": 546,
+    "rna_seq": 667,
+    "chip_tf": 1_617,
+    "chip_histone": 1_116,
+}
+
+PREDICTION_SCHEMA = "genome-sequence-to-function-predictions/v4"
+MAX_USAGE_SITES = 4_096
+MAX_JUNCTION_PAIRS = 16_384
+# Fixed-shape arrays per example; splice usage and junctions are sparse (see contract.md).
+FIXED_SHAPES = {
+    **{name: (1_536, tracks) for name, tracks in DENSE_TRACKS.items()},
+    "splice_sites": (196_608, 4),
+    "contact_maps": (131_328, 28),
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/__init__.py

@@ -0,0 +1 @@
+"""The reference model of the alphagenome-reference baseline."""

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/__init__.py

@@ -0,0 +1,5 @@
+"""Compact 1-Mb, eleven-family AlphaGenome reference model."""
+
+from .model import CompactModel, ModelConfig, count_parameters
+
+__all__ = ["CompactModel", "ModelConfig", "count_parameters"]

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/alphagenome_50m.yaml

@@ -0,0 +1,23 @@
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 32
+channel_growth: 32
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 384
+num_sequence_blocks: 6
+num_attention_heads: 6
+attention_head_dim: 64
+mlp_expansion: 4.0
+dropout: 0.0
+head_hidden_size: 256
+junction_rank: 32
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: true

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/dataset.py

@@ -0,0 +1,229 @@
+"""Streaming reader for the compact 1 Mb / eleven-family release."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pysam
+import torch
+from torch.utils.data import Dataset
+import zarr
+
+
+def _open_part(path: Path):
+    if str(path).endswith(".zarr.zip"):
+        store = zarr.ZipStore(str(path), mode="r")
+        try:
+            return zarr.open_group(store=store, mode="r"), store
+        except BaseException:
+            store.close()
+            raise
+    return zarr.open_group(str(path), mode="r"), None
+
+
+DENSE_FAMILIES = (
+    "atac",
+    "dnase",
+    "procap",
+    "cage",
+    "rna_seq",
+    "chip_tf",
+    "chip_histone",
+)
+def normalize_splice_positions(value) -> np.ndarray:
+    """Normalize Arrow's nested-list representation to the public [4, 512] array."""
+
+    outer = np.asarray(value, dtype=object).reshape(-1).tolist()
+    positions = np.stack([np.asarray(item, dtype=np.int64) for item in outer])
+    if positions.shape != (4, 512):
+        raise ValueError(f"splice_site_positions must have shape (4, 512), got {positions.shape}")
+    return positions
+
+
+class AlphaGenomeDataset(Dataset):
+    """Resolve frozen coordinates to reference DNA and one Zarr example group."""
+
+    def __init__(
+        self,
+        data_root: str | Path,
+        split: str,
+        *,
+        max_open_parts: int = 8,
+        include_targets: bool = True,
+    ) -> None:
+        self.root = Path(data_root)
+        self.split = split
+        manifest = self.root / "public" / f"{split}.parquet"
+        if not manifest.is_file():
+            raise FileNotFoundError(f"Missing materialized manifest: {manifest}")
+        self.rows = pd.read_parquet(manifest).reset_index(drop=True)
+        junction_tracks = pd.read_parquet(self.root / "public/junction_tracks.parquet")
+        junction_tracks = junction_tracks.sort_values("tensor_index")
+        self.junction_track_halves = torch.from_numpy(
+            junction_tracks.junction_channel_half.to_numpy(np.int64)
+        )
+        if include_targets:
+            labels_path = self.root / "labels" / f"{split}.parquet"
+            if not labels_path.is_file():
+                raise FileNotFoundError(f"Missing trusted labels manifest: {labels_path}")
+            labels = pd.read_parquet(labels_path).reset_index(drop=True)
+            if self.rows.example_id.astype(str).tolist() != labels.example_id.astype(str).tolist():
+                raise ValueError("public and labels manifests have different IDs/order")
+            self.rows = self.rows.merge(labels, on="example_id", validate="one_to_one", sort=False)
+        self.fasta_path = self.root / "reference" / "GRCh38.p13.genome.fa"
+        self.max_open_parts = max_open_parts
+        self.include_targets = include_targets
+        self._fasta = None
+        self._parts: OrderedDict[str, tuple[zarr.Group, object | None]] = OrderedDict()
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def _reference(self):
+        if self._fasta is None:
+            self._fasta = pysam.FastaFile(str(self.fasta_path))
+        return self._fasta
+
+    def _part(self, relative: str):
+        if relative in self._parts:
+            opened = self._parts.pop(relative)
+            self._parts[relative] = opened
+            return opened[0]
+        group, store = _open_part(self.root / relative)
+        if len(self._parts) >= self.max_open_parts:
+            _, (_, old_store) = self._parts.popitem(last=False)
+            if old_store is not None:
+                old_store.close()
+        self._parts[relative] = (group, store)
+        return group
+
+    @staticmethod
+    def _one_hot(sequence: str) -> np.ndarray:
+        encoded = np.frombuffer(sequence.upper().encode("ascii"), dtype=np.uint8)
+        output = np.zeros((len(encoded), 4), dtype=np.float32)
+        for index, letter in enumerate(b"ACGT"):
+            output[:, index] = encoded == letter
+        return output
+
+    def _sequence(self, row) -> tuple[np.ndarray, np.ndarray]:
+        reference = self._reference()
+        chromosome_length = reference.get_reference_length(str(row.chromosome))
+        start, end = int(row.input_start), int(row.input_end)
+        clipped_start, clipped_end = max(0, start), min(chromosome_length, end)
+        sequence = reference.fetch(str(row.chromosome), clipped_start, clipped_end)
+        left, right = clipped_start - start, end - clipped_end
+        if left or right:
+            sequence = "N" * left + sequence + "N" * right
+        valid = np.ones(end - start, dtype=bool)
+        if left:
+            valid[:left] = False
+        if right:
+            valid[-right:] = False
+        return self._one_hot(sequence), valid
+
+    @staticmethod
+    def _decode(example, name: str, *, asinh: bool) -> np.ndarray:
+        """Train targets may be stored as 8-bit codes with per-track ranges; they are decoded
+        here, one example at a time, so the release stays compressed on disk."""
+        array = example[name]
+        if array.dtype != np.uint8:
+            return np.asarray(array, dtype=np.float32)
+        lo = np.asarray(example[f"{name}_lo"], dtype=np.float32)
+        hi = np.asarray(example[f"{name}_hi"], dtype=np.float32)
+        x = lo + np.asarray(array, dtype=np.float32) * ((hi - lo) / 255.0)
+        return np.sinh(x) if asinh else x
+
+    @staticmethod
+    def _dense_target(example, family: str) -> dict[str, torch.Tensor]:
+        values = AlphaGenomeDataset._decode(example, f"{family}/values", asinh=True)
+        mask = np.asarray(example[f"{family}/mask"], dtype=bool)
+        if mask.ndim == 1:
+            mask = np.broadcast_to(mask[None, :], values.shape).copy()
+        return {
+            "values": torch.from_numpy(values),
+            "mask": torch.from_numpy(mask),
+        }
+
+    def __getitem__(self, item: int):
+        row = self.rows.iloc[item]
+        dna, input_mask = self._sequence(row)
+        result = {
+            "example_id": str(row.example_id),
+            "dna": torch.from_numpy(dna),
+            "input_mask": torch.from_numpy(input_mask),
+            "junction_track_halves": self.junction_track_halves,
+        }
+        if not self.include_targets:
+            return result
+
+        part = self._part(str(row.target_shard))
+        example = part[str(row.target_group)]
+        result["dense"] = {
+            family: self._dense_target(example, family) for family in DENSE_FAMILIES
+        }
+        result["splice_sites"] = torch.from_numpy(
+            np.asarray(example["splice_sites/values"], dtype=np.float32)
+        )
+        result["splice_usage"] = {
+            "positions": torch.from_numpy(
+                np.asarray(example["splice_site_usage/positions"], dtype=np.int64)
+            ),
+            "values": torch.from_numpy(
+                np.asarray(example["splice_site_usage/values"], dtype=np.float32)
+            ),
+            "mask": torch.from_numpy(
+                np.asarray(example["splice_site_usage/mask"], dtype=bool)
+            ),
+        }
+        result["usage_positions"] = result["splice_usage"]["positions"]
+        result["junctions"] = {
+            name: torch.from_numpy(
+                np.asarray(
+                    example[f"splice_junctions/{name}"],
+                    dtype=np.float32 if name == "value" else np.int64,
+                )
+            )
+            for name in ("row", "column", "track", "value")
+        }
+        result["junctions"]["site_positions"] = torch.from_numpy(
+            np.asarray(example["splice_junctions/site_positions"], dtype=np.int64)
+        )
+        site_positions = normalize_splice_positions(row.splice_site_positions)
+        result["site_positions"] = torch.from_numpy(site_positions)
+        if not torch.equal(result["junctions"]["site_positions"], result["site_positions"]):
+            raise ValueError(f"public/private splice positions differ for {row.example_id}")
+        scoring_path = self.root / "scoring" / self.split / f"part-{item:06d}.parquet"
+        scoring = pd.read_parquet(scoring_path)
+        if not (scoring.example_id.astype(str) == str(row.example_id)).all():
+            raise ValueError(f"scoring part ID differs for {row.example_id}")
+        result["junction_scoring"] = {
+            "donor_position": torch.from_numpy(
+                scoring.donor_position.to_numpy(np.int64)
+            ),
+            "acceptor_position": torch.from_numpy(
+                scoring.acceptor_position.to_numpy(np.int64)
+            ),
+            "track": torch.from_numpy(scoring.track.to_numpy(np.int64)),
+            "target_value": torch.from_numpy(
+                scoring.target_value.to_numpy(np.float32)
+            ),
+            "valid": torch.from_numpy(scoring.valid.to_numpy(bool)),
+        }
+        result["contact_maps"] = torch.from_numpy(
+            self._decode(example, "contact_maps/upper_triangle", asinh=False)
+        )
+        result["contact_map_mask"] = torch.from_numpy(
+            np.asarray(example["contact_maps/mask"], dtype=bool)
+        )
+        return result
+
+
+def single_example_collate(items):
+    """Keep variable-size event tensors intact; the reference currently trains at batch one."""
+
+    if len(items) != 1:
+        raise ValueError("The compact event loader currently requires batch_size=1")
+    return items[0]

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/layers.py

@@ -0,0 +1,124 @@
+"""Shared neural-network layers for the single compact AlphaGenome model."""
+
+from __future__ import annotations
+
+import math
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F
+
+
+class ChannelRMSNorm(nn.Module):
+    def __init__(self, channels: int, eps: float = 1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(channels))
+        self.eps = eps
+
+    def forward(self, x: Tensor) -> Tensor:
+        variance = x.float().square().mean(dim=1, keepdim=True)
+        normalized = x * torch.rsqrt(variance + self.eps).to(x.dtype)
+        return normalized * self.weight[None, :, None].to(x.dtype)
+
+
+class StandardizedConv1d(nn.Conv1d):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int):
+        super().__init__(in_channels, out_channels, kernel_size, padding="same", bias=True)
+        self.scale = nn.Parameter(torch.ones(out_channels))
+        nn.init.trunc_normal_(self.weight, std=1.0 / math.sqrt(in_channels * kernel_size))
+        nn.init.trunc_normal_(self.bias, std=1e-4)
+
+    def forward(self, x: Tensor) -> Tensor:
+        centered = self.weight - self.weight.mean(dim=(1, 2), keepdim=True)
+        variance = centered.float().square().mean(dim=(1, 2), keepdim=True)
+        fan_in = self.weight.shape[1] * self.weight.shape[2]
+        multiplier = self.scale[:, None, None] * torch.rsqrt(
+            (fan_in * variance).clamp_min(1e-4)
+        ).to(self.weight.dtype)
+        return F.conv1d(x, centered * multiplier, self.bias, padding="same")
+
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int):
+        super().__init__()
+        self.norm = ChannelRMSNorm(in_channels)
+        self.conv = StandardizedConv1d(in_channels, out_channels, kernel_size)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(F.gelu(self.norm(x), approximate="tanh"))
+
+
+def _apply_rope(x: Tensor) -> Tensor:
+    rotary_dim = x.shape[-1] - x.shape[-1] % 2
+    if rotary_dim == 0:
+        return x
+    positions = torch.arange(x.shape[-2], device=x.device, dtype=torch.float32)
+    inverse_frequency = 1.0 / (
+        10_000 ** (
+            torch.arange(0, rotary_dim, 2, device=x.device, dtype=torch.float32)
+            / rotary_dim
+        )
+    )
+    angles = torch.outer(positions, inverse_frequency)
+    cos = angles.cos()[None, None, :, :].to(x.dtype)
+    sin = angles.sin()[None, None, :, :].to(x.dtype)
+    even, odd = x[..., :rotary_dim:2], x[..., 1:rotary_dim:2]
+    rotated = torch.stack((even * cos - odd * sin, even * sin + odd * cos), dim=-1)
+    return torch.cat((rotated.flatten(-2), x[..., rotary_dim:]), dim=-1)
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.num_heads = config.num_attention_heads
+        self.head_dim = config.attention_head_dim
+        inner_dim = self.num_heads * self.head_dim
+        self.norm = nn.RMSNorm(config.hidden_dim)
+        self.qkv = nn.Linear(config.hidden_dim, 3 * inner_dim, bias=False)
+        self.output = nn.Linear(inner_dim, config.hidden_dim)
+        self.dropout = config.dropout
+        nn.init.trunc_normal_(self.output.weight, std=1e-3)
+        nn.init.zeros_(self.output.bias)
+
+    def forward(self, x: Tensor, attention_bias: Tensor | None = None) -> Tensor:
+        batch, length, _ = x.shape
+        qkv = self.qkv(self.norm(x)).view(
+            batch, length, 3, self.num_heads, self.head_dim
+        )
+        q, k, value = qkv.unbind(dim=2)
+        attended = F.scaled_dot_product_attention(
+            _apply_rope(q.transpose(1, 2)),
+            _apply_rope(k.transpose(1, 2)),
+            value.transpose(1, 2),
+            attn_mask=attention_bias,
+            dropout_p=self.dropout if self.training else 0.0,
+        )
+        return self.output(attended.transpose(1, 2).reshape(batch, length, -1))
+
+
+class MLPBlock(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        expanded = int(config.hidden_dim * config.mlp_expansion)
+        self.norm = nn.RMSNorm(config.hidden_dim)
+        self.input = nn.Linear(config.hidden_dim, expanded)
+        self.output = nn.Linear(expanded, config.hidden_dim)
+        self.dropout = nn.Dropout(config.dropout)
+        nn.init.trunc_normal_(self.output.weight, std=1e-3)
+        nn.init.zeros_(self.output.bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.dropout(
+            self.output(F.gelu(self.input(self.norm(x)), approximate="tanh"))
+        )
+
+
+class SequenceBlock(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.attention = MultiHeadAttention(config)
+        self.mlp = MLPBlock(config)
+
+    def forward(self, x: Tensor, attention_bias: Tensor | None = None) -> Tensor:
+        x = x + self.attention(x, attention_bias)
+        return x + self.mlp(x)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/model.py

@@ -0,0 +1,368 @@
+"""Affordable multi-resolution baseline for the compact AlphaGenome task."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, fields
+import math
+from pathlib import Path
+from typing import Any, Iterable
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F
+from torch.utils.checkpoint import checkpoint
+import yaml
+
+from .layers import ConvBlock, SequenceBlock
+
+
+DENSE_TRACKS = {
+    "atac": 167,
+    "dnase": 305,
+    "procap": 12,
+    "cage": 546,
+    "rna_seq": 667,
+    "chip_tf": 1_617,
+    "chip_histone": 1_116,
+}
+ALL_FAMILIES = (*DENSE_TRACKS, "splice_sites", "splice_usage", "junctions", "contact_maps")
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    input_length: int = 1_048_576
+    target_length: int = 196_608
+    dense_bin_size: int = 128
+    trunk_bin_size: int = 1_024
+    contact_bin_size: int = 2_048
+    stem_stride: int = 8
+    encoder_width: int = 32
+    channel_growth: int = 32
+    num_downsampling_blocks: int = 7
+    conv_kernel_size: int = 5
+    dna_kernel_size: int = 15
+    hidden_dim: int = 384
+    num_sequence_blocks: int = 6
+    num_attention_heads: int = 6
+    attention_head_dim: int = 64
+    mlp_expansion: float = 4.0
+    dropout: float = 0.0
+    head_hidden_size: int = 256
+    junction_rank: int = 32
+    splice_usage_tracks: int = 734
+    junction_tracks: int = 734
+    contact_tracks: int = 28
+    gradient_checkpointing: bool = True
+    enable_pairwise: bool = False
+    pair_width: int = 32
+    pair_downsample: int = 16
+    pair_update_interval: int = 2
+
+    def __post_init__(self) -> None:
+        downsample = self.stem_stride * 2**self.num_downsampling_blocks
+        if downsample != self.trunk_bin_size:
+            raise ValueError("stem_stride * 2**num_downsampling_blocks must equal trunk_bin_size")
+        for length in (self.input_length, self.target_length):
+            if length % self.trunk_bin_size:
+                raise ValueError("input and target lengths must divide by trunk_bin_size")
+        if self.trunk_bin_size % self.dense_bin_size:
+            raise ValueError("trunk_bin_size must divide by dense_bin_size")
+        if self.input_length % self.contact_bin_size:
+            raise ValueError("input_length must divide by contact_bin_size")
+        if self.hidden_dim <= 0 or self.num_attention_heads <= 0:
+            raise ValueError("hidden dimensions and attention heads must be positive")
+
+    @property
+    def trunk_bins(self) -> int:
+        return self.input_length // self.trunk_bin_size
+
+    @property
+    def target_trunk_bins(self) -> int:
+        return self.target_length // self.trunk_bin_size
+
+    @property
+    def dense_bins(self) -> int:
+        return self.target_length // self.dense_bin_size
+
+    @property
+    def dense_upsample(self) -> int:
+        return self.trunk_bin_size // self.dense_bin_size
+
+    @property
+    def contact_bins(self) -> int:
+        return self.input_length // self.contact_bin_size
+
+    @property
+    def encoder_output_width(self) -> int:
+        return self.encoder_width + self.channel_growth * self.num_downsampling_blocks
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "ModelConfig":
+        values: dict[str, Any] = yaml.safe_load(Path(path).read_text()) or {}
+        known = {field.name for field in fields(cls)}
+        unknown = sorted(values.keys() - known)
+        if unknown:
+            raise ValueError(f"Unknown model configuration keys: {unknown}")
+        return cls(**values)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class SequenceEncoder(nn.Module):
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.stem = nn.Conv1d(
+            4,
+            config.encoder_width,
+            config.dna_kernel_size,
+            stride=config.stem_stride,
+            padding=config.dna_kernel_size // 2,
+        )
+        blocks = []
+        width = config.encoder_width
+        for _ in range(config.num_downsampling_blocks):
+            output_width = width + config.channel_growth
+            blocks.append(ConvBlock(width, output_width, config.conv_kernel_size))
+            width = output_width
+        self.blocks = nn.ModuleList(blocks)
+
+    def forward(self, dna: Tensor) -> Tensor:
+        x = F.gelu(self.stem(dna.transpose(1, 2)), approximate="tanh")
+        for block in self.blocks:
+            x = F.max_pool1d(block(x), kernel_size=2, stride=2)
+        return x.transpose(1, 2)
+
+
+class CompactModel(nn.Module):
+    """One shared 1-kb trunk with representation-specific output heads."""
+
+    def __init__(self, config: ModelConfig | None = None):
+        super().__init__()
+        self.config = config or ModelConfig()
+        self.encoder = SequenceEncoder(self.config)
+        self.projection = nn.Linear(self.config.encoder_output_width, self.config.hidden_dim)
+        self.blocks = nn.ModuleList(
+            SequenceBlock(self.config) for _ in range(self.config.num_sequence_blocks)
+        )
+        self.final_norm = nn.RMSNorm(self.config.hidden_dim)
+        self.dense_decoder = nn.Sequential(
+            nn.RMSNorm(self.config.hidden_dim),
+            nn.Linear(self.config.hidden_dim, self.config.head_hidden_size),
+            nn.GELU(approximate="tanh"),
+        )
+        self.dense_heads = nn.ModuleDict(
+            {
+                family: nn.Linear(self.config.head_hidden_size, tracks)
+                for family, tracks in DENSE_TRACKS.items()
+            }
+        )
+        self.splice_site_head = nn.Linear(
+            self.config.head_hidden_size, self.config.dense_bin_size * 4
+        )
+        self.splice_usage_head = nn.Linear(
+            self.config.head_hidden_size, self.config.splice_usage_tracks
+        )
+        rank = self.config.junction_rank
+        self.junction_source = nn.Linear(self.config.head_hidden_size, rank)
+        self.junction_destination = nn.Linear(self.config.head_hidden_size, rank)
+        self.junction_track = nn.Embedding(self.config.junction_tracks, rank)
+        if self.config.junction_tracks % 2:
+            raise ValueError("junction tracks must split evenly into strand halves")
+        self.register_buffer(
+            "junction_track_half",
+            torch.arange(self.config.junction_tracks) // (self.config.junction_tracks // 2),
+            persistent=False,
+        )
+        self.contact_q = nn.Linear(self.config.hidden_dim, self.config.contact_tracks)
+        self.contact_k = nn.Linear(self.config.hidden_dim, self.config.contact_tracks)
+        row, column = torch.triu_indices(
+            self.config.contact_bins, self.config.contact_bins
+        )
+        self.register_buffer("contact_row", row, persistent=False)
+        self.register_buffer("contact_column", column, persistent=False)
+
+    def set_junction_track_halves(self, halves: Tensor) -> None:
+        halves = torch.as_tensor(halves, dtype=torch.long, device=self.junction_track_half.device)
+        if halves.shape != (self.config.junction_tracks,) or not torch.isin(
+            halves, torch.tensor([0, 1], device=halves.device)
+        ).all():
+            raise ValueError("junction track halves must be a 734-element 0/1 mapping")
+        self.junction_track_half.copy_(halves)
+
+    def _trunk(self, dna: Tensor) -> Tensor:
+        if dna.ndim != 3 or dna.shape[1:] != (self.config.input_length, 4):
+            raise ValueError(
+                f"Expected DNA [B,{self.config.input_length},4], got {tuple(dna.shape)}"
+            )
+        x = self.projection(self.encoder(dna))
+        for block in self.blocks:
+            if self.config.gradient_checkpointing and self.training and x.requires_grad:
+                x = checkpoint(block, x, None, use_reentrant=False)
+            else:
+                x = block(x, None)
+        return self.final_norm(x)
+
+    def _dense_features(self, trunk: Tensor) -> Tensor:
+        start = (self.config.trunk_bins - self.config.target_trunk_bins) // 2
+        target = trunk[:, start : start + self.config.target_trunk_bins]
+        target = target.repeat_interleave(self.config.dense_upsample, dim=1)
+        return self.dense_decoder(target)
+
+    def _all_dense_features(self, trunk: Tensor) -> Tensor:
+        return self.dense_decoder(
+            trunk.repeat_interleave(self.config.dense_upsample, dim=1)
+        )
+
+    def _splice_site_logits(self, trunk: Tensor) -> Tensor:
+        logits = self.splice_site_head(self._all_dense_features(trunk))
+        return logits.view(len(trunk), self.config.input_length, 4).float()
+
+    @staticmethod
+    def select_junction_positions(site_logits: Tensor, limit: int = 512) -> Tensor:
+        """Select each site type from model scores alone, then sort by coordinate.
+
+        This follows the four independent site classes in Google DeepMind's
+        AlphaGenome splicing implementation (pinned in docs/v3-author/PROTOCOL.md).  Padding is
+        -1 when an input is shorter than ``limit``.
+        """
+        count = min(limit, site_logits.shape[1])
+        selected = []
+        for site_type in range(4):
+            coordinates = torch.topk(site_logits[..., site_type], count, dim=1).indices
+            coordinates = coordinates.sort(dim=1).values
+            if count < limit:
+                coordinates = F.pad(coordinates, (0, limit - count), value=-1)
+            selected.append(coordinates)
+        return torch.stack(selected, dim=1)
+
+    @staticmethod
+    def _gather_bins(features: Tensor, positions: Tensor, bin_size: int) -> Tensor:
+        indices = torch.div(positions, bin_size, rounding_mode="floor")
+        indices = indices.clamp(0, features.shape[1] - 1)
+        return torch.gather(
+            features,
+            1,
+            indices[..., None].expand(-1, -1, features.shape[-1]),
+        )
+
+    def _junction_predictions(
+        self, trunk: Tensor, site_positions: Tensor, queries: Tensor
+    ) -> Tensor:
+        row, column, track = queries.unbind(dim=-1)
+        half = self.junction_track_half[track]
+        batch = torch.arange(len(trunk), device=trunk.device)[:, None]
+        donor = site_positions[batch, 2 * half, row]
+        acceptor = site_positions[batch, 2 * half + 1, column]
+        source = self.dense_decoder(self._gather_bins(
+            trunk, donor.clamp(0, self.config.input_length - 1), self.config.trunk_bin_size
+        ))
+        destination = self.dense_decoder(self._gather_bins(
+            trunk, acceptor.clamp(0, self.config.input_length - 1), self.config.trunk_bin_size
+        ))
+        interaction = self.junction_source(source) * self.junction_destination(destination)
+        track_embedding = self.junction_track(track)
+        return (interaction * track_embedding).sum(dim=-1) / math.sqrt(
+            self.config.junction_rank
+        )
+
+    def junction_block(
+        self,
+        trunk: Tensor,
+        site_positions: Tensor,
+        row_start: int,
+        row_end: int,
+        column_start: int,
+        column_end: int,
+        track_start: int,
+        track_end: int,
+        site_factors: tuple[Tensor, Tensor] | None = None,
+    ) -> Tensor:
+        """Compute a bounded block of the full predicted-position junction cube."""
+        tracks = torch.arange(track_start, track_end, device=trunk.device)
+        halves = self.junction_track_half[tracks]
+        if site_factors is None:
+            site_factors = self.junction_site_factors(trunk, site_positions)
+        source_all, destination_all = site_factors
+        source = source_all[:, halves, row_start:row_end]
+        destination = destination_all[:, halves, column_start:column_end]
+        embedding = self.junction_track(tracks)[None, :, None, None, :]
+        values = (
+            source[:, :, :, None, :] * destination[:, :, None, :, :] * embedding
+        ).sum(dim=-1) / math.sqrt(self.config.junction_rank)
+        return values.permute(0, 2, 3, 1).float()
+
+    def junction_site_factors(
+        self, trunk: Tensor, site_positions: Tensor
+    ) -> tuple[Tensor, Tensor]:
+        """Precompute the two strand-specific factors reused by all cube blocks."""
+        donor = torch.stack((site_positions[:, 0], site_positions[:, 2]), dim=1).clamp_min(0)
+        acceptor = torch.stack((site_positions[:, 1], site_positions[:, 3]), dim=1).clamp_min(0)
+        expanded = trunk[:, None].expand(-1, 2, -1, -1).reshape(
+            -1, trunk.shape[1], trunk.shape[2]
+        )
+        donor_features = self.dense_decoder(self._gather_bins(
+            expanded, donor.reshape(-1, donor.shape[-1]), self.config.trunk_bin_size,
+        )).reshape(len(trunk), 2, donor.shape[-1], -1)
+        acceptor_features = self.dense_decoder(self._gather_bins(
+            expanded, acceptor.reshape(-1, acceptor.shape[-1]), self.config.trunk_bin_size,
+        )).reshape(len(trunk), 2, acceptor.shape[-1], -1)
+        return self.junction_source(donor_features), self.junction_destination(acceptor_features)
+
+    def forward(
+        self,
+        dna: Tensor,
+        *,
+        families: Iterable[str] | None = None,
+        usage_positions: Tensor | None = None,
+        junction_site_positions: Tensor | None = None,
+        junction_queries: Tensor | None = None,
+    ) -> dict[str, Tensor]:
+        requested = set(families or ALL_FAMILIES)
+        unknown = requested - set(ALL_FAMILIES)
+        if unknown:
+            raise ValueError(f"Unknown output families: {sorted(unknown)}")
+        trunk = self._trunk(dna)
+        needs_dense = bool(
+            requested.intersection((*DENSE_TRACKS, "splice_sites", "splice_usage", "junctions"))
+        )
+        features = self._dense_features(trunk) if needs_dense else None
+        outputs: dict[str, Tensor] = {}
+        for family in DENSE_TRACKS:
+            if family in requested:
+                outputs[family] = self.dense_heads[family](features).float()
+        if "splice_sites" in requested:
+            all_logits = self._splice_site_logits(trunk)
+            start = (self.config.input_length - self.config.target_length) // 2
+            outputs["splice_sites"] = all_logits[:, start:start + self.config.target_length]
+        if "splice_usage" in requested:
+            if usage_positions is None:
+                raise ValueError("splice_usage requires usage_positions")
+            gathered = self._gather_bins(
+                features, usage_positions, self.config.dense_bin_size
+            )
+            outputs["splice_usage"] = self.splice_usage_head(gathered).float()
+        if "junctions" in requested:
+            if junction_site_positions is None or junction_queries is None:
+                raise ValueError("junctions require site positions and query triples")
+            outputs["junctions"] = self._junction_predictions(
+                trunk, junction_site_positions, junction_queries
+            ).float()
+        if "contact_maps" in requested:
+            contact = trunk.reshape(
+                len(dna), self.config.contact_bins, -1, self.config.hidden_dim
+            ).mean(dim=2)
+            q, k = self.contact_q(contact), self.contact_k(contact)
+            row, column = self.contact_row, self.contact_column
+            outputs["contact_maps"] = (
+                0.5
+                * (
+                    q[:, row] * k[:, column]
+                    + q[:, column] * k[:, row]
+                )
+            ).float()
+        return outputs
+
+
+def count_parameters(model: nn.Module) -> int:
+    return sum(parameter.numel() for parameter in model.parameters() if parameter.requires_grad)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/reference_large.yaml

@@ -0,0 +1,23 @@
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 96
+channel_growth: 96
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 1024
+num_sequence_blocks: 16
+num_attention_heads: 16
+attention_head_dim: 64
+mlp_expansion: 4.0
+dropout: 0.0
+head_hidden_size: 768
+junction_rank: 32
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: true

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/run_ddp.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# run_ddp.sh DATA_DIR OUTPUT_DIR CONFIG EPOCHS [GPUS=8] [WORKERS_PER_GPU=12]
+# Train the reference on every train interval with one example per GPU per step, then score
+# validation with the verifier's own scorer. Runs inside the task image (torch, torchrun).
+set -Eeuo pipefail
+DATA=$1; OUT=$2; CONFIG=$3; EPOCHS=$4; GPUS=${5:-8}; WORKERS=${6:-12}
+BASELINE=$(cd "$(dirname "$0")/../.." && pwd)
+mkdir -p "$OUT"
+cd "$BASELINE"
+# Loopback rendezvous: works offline, where --standalone cannot resolve the hostname.
+torchrun --nnodes 1 --nproc-per-node "$GPUS" --master-addr 127.0.0.1 --master-port "${MASTER_PORT:-29511}" -m reference.alphagenome_50m.train_eval train \
+  --input "$DATA" --config "$CONFIG" --output "$OUT" --epochs "$EPOCHS" --workers "$WORKERS" \
+  --log-every 200 --save-every 2000 2>&1 | tee -a "$OUT/train.log"
+python predict.py "$DATA" "$OUT/valid-pred" --checkpoint "$OUT/last.pt" --split valid
+python /workspace/evaluation/score.py --predictions "$OUT/valid-pred/predictions.zarr" \
+  --labels "$DATA" --split valid --output "$OUT/valid-score"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/tiny_overfit.yaml

@@ -0,0 +1,24 @@
+# Keep the frozen 1-Mb input and every output track; shrink only learned widths.
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 8
+channel_growth: 4
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 32
+num_sequence_blocks: 1
+num_attention_heads: 2
+attention_head_dim: 16
+mlp_expansion: 2.0
+dropout: 0.0
+head_hidden_size: 32
+junction_rank: 8
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: false

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/reference/alphagenome_50m/train_eval.py

@@ -0,0 +1,534 @@
+"""Train and stream-evaluate the <=50M compact AlphaGenome baseline."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import time
+
+import numpy as np
+import torch
+from torch import Tensor
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, Subset
+
+from .dataset import (
+    AlphaGenomeDataset,
+    DENSE_FAMILIES,
+    single_example_collate,
+)
+from .model import (
+    ALL_FAMILIES,
+    CompactModel,
+    ModelConfig,
+    count_parameters,
+)
+
+
+DEFAULT_CONFIG = Path(__file__).with_name("alphagenome_50m.yaml")
+
+
+def _device(name: str) -> torch.device:
+    if name == "auto":
+        name = "cuda" if torch.cuda.is_available() else "cpu"
+    if name == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("--device cuda requested but CUDA is unavailable")
+    return torch.device(name)
+
+
+def _autocast(device: torch.device):
+    enabled = device.type == "cuda"
+    dtype = torch.bfloat16 if enabled and torch.cuda.is_bf16_supported() else torch.float16
+    return torch.autocast(device_type=device.type, dtype=dtype, enabled=enabled)
+
+
+def _distributed() -> tuple[int, int, int]:
+    """(rank, local_rank, world_size) under torchrun; (0, 0, 1) otherwise."""
+    world = int(os.environ.get("WORLD_SIZE", "1"))
+    if world > 1 and not torch.distributed.is_initialized():
+        torch.distributed.init_process_group("nccl")
+    return int(os.environ.get("RANK", "0")), int(os.environ.get("LOCAL_RANK", "0")), world
+
+
+def _loader(dataset, *, workers: int, shuffle: bool, sampler=None) -> DataLoader:
+    return DataLoader(
+        dataset,
+        batch_size=1,
+        shuffle=shuffle and sampler is None,
+        sampler=sampler,
+        num_workers=workers,
+        persistent_workers=workers > 0,
+        pin_memory=torch.cuda.is_available(),
+        collate_fn=single_example_collate,
+    )
+
+
+def _to_device(value, device: torch.device):
+    if isinstance(value, Tensor):
+        return value.to(device, non_blocking=True)
+    if isinstance(value, dict):
+        return {key: _to_device(item, device) for key, item in value.items()}
+    return value
+
+
+def _match_coordinate_queries(
+    scoring: dict[str, Tensor], positions: Tensor, track_halves: Tensor
+) -> tuple[Tensor, Tensor, Tensor]:
+    """Match trusted coordinate queries to typed position axes like the grader."""
+    device = positions.device
+    tracks = scoring["track"]
+    halves = track_halves[tracks]
+    queries = torch.zeros((len(tracks), 3), dtype=torch.int64, device=device)
+    queries[:, 2] = tracks
+    valid = scoring["valid"].clone()
+    missing = torch.ones(len(tracks), dtype=torch.bool, device=device)
+    position_rows = positions.detach().cpu().numpy()
+    halves_cpu = halves.detach().cpu().numpy()
+    donors_cpu = scoring["donor_position"].detach().cpu().numpy()
+    acceptors_cpu = scoring["acceptor_position"].detach().cpu().numpy()
+    valid_indices = np.flatnonzero(valid.detach().cpu().numpy())
+    lookups = [
+        {int(coordinate): index for index, coordinate in enumerate(axis) if coordinate >= 0}
+        for axis in position_rows
+    ]
+    for index in valid_indices:
+        half = int(halves_cpu[index])
+        row = lookups[2 * half].get(int(donors_cpu[index]))
+        column = lookups[2 * half + 1].get(int(acceptors_cpu[index]))
+        if row is not None and column is not None:
+            queries[index, 0] = row
+            queries[index, 1] = column
+            missing[index] = False
+    return queries.unsqueeze(0), valid, missing
+
+
+def _model_inputs(sample: dict) -> tuple[dict, Tensor, Tensor]:
+    queries, query_valid, missing = _match_coordinate_queries(
+        sample["junction_scoring"],
+        sample["site_positions"],
+        sample["junction_track_halves"],
+    )
+    if (query_valid & missing).any():
+        raise ValueError("trusted scoring coordinates do not match target positions")
+    junction_target = torch.asinh(
+        sample["junction_scoring"]["target_value"]
+    ).unsqueeze(0)
+    return {
+        "dna": sample["dna"].unsqueeze(0),
+        "usage_positions": sample["usage_positions"].unsqueeze(0),
+        "junction_site_positions": sample["site_positions"].unsqueeze(0),
+        "junction_queries": queries,
+    }, junction_target, query_valid
+
+
+def _losses(outputs: dict[str, Tensor], sample: dict, junction_target: Tensor,
+            junction_valid: Tensor) -> dict[str, Tensor]:
+    losses = {}
+    for family in DENSE_FAMILIES:
+        target = torch.asinh(sample["dense"][family]["values"]).unsqueeze(0)
+        mask = sample["dense"][family]["mask"].unsqueeze(0)
+        residual = torch.where(mask, outputs[family] - target, 0.0)
+        losses[family] = residual.square().sum() / mask.sum().clamp_min(1)
+    losses["splice_sites"] = F.binary_cross_entropy_with_logits(
+        outputs["splice_sites"], sample["splice_sites"].unsqueeze(0)
+    )
+    usage_target = torch.asinh(sample["splice_usage"]["values"]).unsqueeze(0)
+    usage_mask = sample["splice_usage"]["mask"].unsqueeze(0)
+    usage_residual = torch.where(usage_mask, outputs["splice_usage"] - usage_target, 0.0)
+    losses["splice_usage"] = usage_residual.square().sum() / usage_mask.sum().clamp_min(1)
+    junction_residual = outputs["junctions"][0] - junction_target[0]
+    losses["junctions"] = (
+        junction_residual[junction_valid].square().mean()
+        if junction_valid.any() else junction_residual.sum() * 0
+    )
+    contact_target = torch.asinh(sample["contact_maps"]).unsqueeze(0)
+    contact_mask = sample["contact_map_mask"].unsqueeze(0)
+    contact_residual = torch.where(
+        contact_mask, outputs["contact_maps"] - contact_target, 0.0
+    )
+    losses["contact_maps"] = contact_residual.square().sum() / contact_mask.sum().clamp_min(1)
+    losses["total"] = torch.stack([losses[name] for name in ALL_FAMILIES]).mean()
+    return losses
+
+
+def _validation_inference(
+    model: CompactModel, sample: dict
+) -> tuple[dict[str, Tensor], Tensor, Tensor, Tensor]:
+    """Use the same predicted-position path as a formal v3 submission."""
+    trunk = model._trunk(sample["dna"].unsqueeze(0))
+    dense_features = model._dense_features(trunk)
+    outputs = {
+        family: model.dense_heads[family](dense_features).float()
+        for family in DENSE_FAMILIES
+    }
+    all_sites = model._splice_site_logits(trunk)
+    target_start = (model.config.input_length - model.config.target_length) // 2
+    outputs["splice_sites"] = all_sites[:, target_start:target_start + model.config.target_length]
+    usage_bins = model.splice_usage_head(dense_features).float()
+    usage_indices = torch.div(sample["usage_positions"], model.config.dense_bin_size,
+                              rounding_mode="floor")
+    outputs["splice_usage"] = usage_bins[:, usage_indices]
+    predicted_positions = model.select_junction_positions(all_sites)
+
+    matched, valid, missing = _match_coordinate_queries(
+        sample["junction_scoring"],
+        predicted_positions[0],
+        sample["junction_track_halves"],
+    )
+    junction_target = torch.asinh(
+        sample["junction_scoring"]["target_value"]
+    ).unsqueeze(0)
+    junction_prediction = torch.zeros(len(valid), device=valid.device)
+    if (~missing & valid).any():
+        selected = ~missing & valid
+        junction_prediction[selected] = model._junction_predictions(
+            trunk, predicted_positions, matched[:, selected]
+        )[0]
+    outputs["junctions"] = junction_prediction.unsqueeze(0)
+
+    contact = trunk.reshape(
+        1, model.config.contact_bins, -1, model.config.hidden_dim
+    ).mean(dim=2)
+    q, k = model.contact_q(contact), model.contact_k(contact)
+    row, column = model.contact_row, model.contact_column
+    outputs["contact_maps"] = (0.5 * (q[:, row] * k[:, column] + q[:, column] * k[:, row])).float()
+    return outputs, junction_target, valid, missing
+
+
+def _atomic_save(payload: dict, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp")
+    torch.save(payload, temporary)
+    os.replace(temporary, path)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _resume_position(payload: dict, *, examples: int, epochs: int) -> tuple[int, int]:
+    epoch = int(payload["epoch"])
+    step = int(payload["global_step"])
+    kind = payload.get("checkpoint_kind")
+    if kind not in (None, "epoch") or step != epoch * examples:
+        raise ValueError("only a completed-epoch checkpoint can resume training")
+    if payload.get("examples", examples) != examples or payload.get("schedule_epochs", epochs) != epochs:
+        raise ValueError("checkpoint data size or training schedule differs from this run")
+    return epoch, step
+
+
+def train(args: argparse.Namespace) -> None:
+    # Multi-GPU with `torchrun --nproc-per-node N train_eval.py train ...`: one example per GPU per
+    # step (data parallel), rank 0 writes checkpoints and logs. Model size is bounded by the
+    # training budget, not by a parameter cap.
+    rank, local_rank, world = _distributed()
+    config = ModelConfig.from_yaml(args.config)
+    device = torch.device("cuda", local_rank) if world > 1 else _device(args.device)
+    if world > 1:
+        torch.cuda.set_device(device)
+    torch.manual_seed(args.seed)
+    model = CompactModel(config).to(device)
+    parameters = count_parameters(model)
+    optimizer = torch.optim.AdamW(
+        model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay
+    )
+    scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda")
+    full_dataset = AlphaGenomeDataset(args.input, "train")
+    model.set_junction_track_halves(full_dataset.junction_track_halves)
+    size = min(len(full_dataset), args.max_examples or len(full_dataset))
+    dataset = Subset(full_dataset, range(size))
+    start_epoch, global_step = 0, 0
+    if args.resume:
+        payload = torch.load(args.resume, map_location="cpu", weights_only=True)
+        if payload.get("config") != config.to_dict():
+            raise ValueError("checkpoint configuration does not match --config")
+        model.load_state_dict(payload["model"], strict=True)
+        optimizer.load_state_dict(payload["optimizer"])
+        scaler.load_state_dict(payload.get("scaler", {}))
+        start_epoch, global_step = _resume_position(payload, examples=size, epochs=args.epochs)
+    per_rank = math.ceil(size / world)
+    steps = max(1, per_rank * args.epochs)
+    module = model
+    if world > 1:
+        model = torch.nn.parallel.DistributedDataParallel(
+            model, device_ids=[local_rank], find_unused_parameters=True)
+    sampler = (torch.utils.data.distributed.DistributedSampler(dataset, num_replicas=world, rank=rank,
+                                                               shuffle=True, seed=args.seed)
+               if world > 1 else None)
+    stop_after_epoch = args.stop_after_epoch or args.epochs
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    started = time.monotonic()
+    if rank == 0:
+        print(json.dumps({"event": "train_start", "parameters": parameters, "examples": size,
+                          "device": str(device), "world_size": world}), flush=True)
+
+    for epoch in range(start_epoch, stop_after_epoch):
+        model.train()
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        loader = _loader(dataset, workers=args.workers, shuffle=True, sampler=sampler)
+        for sample in loader:
+            sample = _to_device(sample, device)
+            inputs, junction_target, junction_valid = _model_inputs(sample)
+            progress = min((global_step + 1) / steps, 1.0)
+            learning_rate = args.min_learning_rate + 0.5 * (
+                args.learning_rate - args.min_learning_rate
+            ) * (1.0 + math.cos(math.pi * progress))
+            for group in optimizer.param_groups:
+                group["lr"] = learning_rate
+            optimizer.zero_grad(set_to_none=True)
+            with _autocast(device):
+                predictions = model(**inputs)
+                losses = _losses(predictions, sample, junction_target, junction_valid)
+            if not torch.isfinite(losses["total"]):
+                raise FloatingPointError(f"non-finite loss at step {global_step}")
+            scaler.scale(losses["total"]).backward()
+            scaler.unscale_(optimizer)
+            gradient_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_gradient_norm)
+            scaler.step(optimizer)
+            scaler.update()
+            global_step += 1
+            if rank == 0 and (global_step == 1 or global_step % args.log_every == 0):
+                print(
+                    json.dumps(
+                        {
+                            "event": "train_step",
+                            "epoch": epoch + 1,
+                            "step": global_step,
+                            "loss": float(losses["total"].detach()),
+                            "gradient_norm": float(gradient_norm),
+                            "learning_rate": learning_rate,
+                            "elapsed_seconds": time.monotonic() - started,
+                        }
+                    ),
+                    flush=True,
+                )
+            if rank == 0 and global_step % args.save_every == 0:
+                _atomic_save(
+                    {
+                        "schema": "alphagenome-50m-real/v3",
+                        "model": module.state_dict(),
+                        "optimizer": optimizer.state_dict(),
+                        "scaler": scaler.state_dict(),
+                        "config": config.to_dict(),
+                        "epoch": epoch,
+                        "global_step": global_step,
+                        "checkpoint_kind": "progress",
+                        "examples": size,
+                        "schedule_epochs": args.epochs,
+                    },
+                    output / "progress.pt",
+                )
+        if world > 1:
+            torch.distributed.barrier()
+        if rank != 0:
+            continue
+        _atomic_save(
+            {
+                "schema": "alphagenome-50m-real/v3",
+                "model": module.state_dict(),
+                "optimizer": optimizer.state_dict(),
+                "scaler": scaler.state_dict(),
+                "config": config.to_dict(),
+                "epoch": epoch + 1,
+                "global_step": global_step,
+                "checkpoint_kind": "epoch",
+                "examples": size,
+                "schedule_epochs": args.epochs,
+            },
+            output / "last.pt",
+        )
+    if world > 1:
+        torch.distributed.barrier()
+        torch.distributed.destroy_process_group()
+    if rank != 0:
+        return
+    checkpoint = output / "last.pt"
+    manifest = {
+        "schema": "alphagenome-50m-real/v3",
+        "checkpoint": {"path": checkpoint.name, "sha256": _sha256(checkpoint)},
+        "parameters": parameters,
+        "config": config.to_dict(),
+        "output_families": list(ALL_FAMILIES),
+        "epochs": args.epochs,
+        "completed_epochs": stop_after_epoch,
+        "global_step": global_step,
+    }
+    (output / "model_manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({"event": "train_complete", **manifest}), flush=True)
+
+
+class PerTrackMoments:
+    def __init__(self, tracks: int):
+        self.n = np.zeros(tracks, dtype=np.int64)
+        self.sum_x = np.zeros(tracks, dtype=np.float64)
+        self.sum_y = np.zeros(tracks, dtype=np.float64)
+        self.sum_x2 = np.zeros(tracks, dtype=np.float64)
+        self.sum_y2 = np.zeros(tracks, dtype=np.float64)
+        self.sum_xy = np.zeros(tracks, dtype=np.float64)
+
+    def update(self, prediction: Tensor, target: Tensor, mask: Tensor | None = None) -> None:
+        x = prediction.detach().double().cpu().numpy().reshape(-1, prediction.shape[-1])
+        y = target.detach().double().cpu().numpy().reshape(-1, target.shape[-1])
+        valid = np.ones_like(y, dtype=bool) if mask is None else mask.detach().cpu().numpy().reshape(y.shape).astype(bool)
+        self.n += valid.sum(axis=0)
+        self.sum_x += np.where(valid, x, 0).sum(axis=0, dtype=np.float64)
+        self.sum_y += np.where(valid, y, 0).sum(axis=0, dtype=np.float64)
+        self.sum_x2 += np.where(valid, x * x, 0).sum(axis=0, dtype=np.float64)
+        self.sum_y2 += np.where(valid, y * y, 0).sum(axis=0, dtype=np.float64)
+        self.sum_xy += np.where(valid, x * y, 0).sum(axis=0, dtype=np.float64)
+
+    def update_indexed(self, prediction: Tensor, target: Tensor, track: Tensor) -> None:
+        x = prediction.detach().double().cpu().numpy().reshape(-1)
+        y = target.detach().double().cpu().numpy().reshape(-1)
+        indices = track.detach().cpu().numpy().reshape(-1).astype(np.int64)
+        self.n += np.bincount(indices, minlength=len(self.n))
+        self.sum_x += np.bincount(indices, weights=x, minlength=len(self.n))
+        self.sum_y += np.bincount(indices, weights=y, minlength=len(self.n))
+        self.sum_x2 += np.bincount(indices, weights=x * x, minlength=len(self.n))
+        self.sum_y2 += np.bincount(indices, weights=y * y, minlength=len(self.n))
+        self.sum_xy += np.bincount(indices, weights=x * y, minlength=len(self.n))
+
+    def report(self) -> dict:
+        numerator = self.n * self.sum_xy - self.sum_x * self.sum_y
+        denominator = np.sqrt(
+            np.maximum(self.n * self.sum_x2 - self.sum_x**2, 0)
+            * np.maximum(self.n * self.sum_y2 - self.sum_y**2, 0)
+        )
+        target_ss = np.maximum(self.n * self.sum_y2 - self.sum_y**2, 0)
+        scorable = (self.n >= 2) & (target_ss > 0)
+        pearson = np.full_like(numerator, np.nan)
+        nonconstant = scorable & (denominator > 0)
+        pearson[nonconstant] = numerator[nonconstant] / denominator[nonconstant]
+        pearson[scorable & ~nonconstant] = 0.0
+        return {
+            "mean_pearson": float(pearson[scorable].mean()) if scorable.any() else 0.0,
+            "valid_tracks": int(scorable.sum()),
+            "per_track_pearson": [float(value) if np.isfinite(value) else None for value in pearson],
+            "values_per_track": self.n.tolist(),
+        }
+
+
+def evaluate(args: argparse.Namespace) -> None:
+    device = _device(args.device)
+    payload = torch.load(args.checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config).to(device)
+    model.load_state_dict(payload["model"], strict=True)
+    model.eval()
+    full_dataset = AlphaGenomeDataset(args.input, args.split)
+    model.set_junction_track_halves(full_dataset.junction_track_halves)
+    size = min(len(full_dataset), args.max_examples or len(full_dataset))
+    dataset = Subset(full_dataset, range(size))
+    metrics = {
+        **{family: PerTrackMoments(config_value) for family, config_value in {
+            "atac": 167, "dnase": 305, "procap": 12, "cage": 546,
+            "rna_seq": 667, "chip_tf": 1617, "chip_histone": 1116,
+        }.items()},
+        "splice_sites": PerTrackMoments(4),
+        "splice_usage": PerTrackMoments(config.splice_usage_tracks),
+        "junctions": PerTrackMoments(config.junction_tracks),
+        "contact_maps": PerTrackMoments(config.contact_tracks),
+    }
+    with torch.inference_mode():
+        for index, sample in enumerate(_loader(dataset, workers=args.workers, shuffle=False)):
+            sample = _to_device(sample, device)
+            outputs, junction_target, junction_valid, junction_missing = (
+                _validation_inference(model, sample)
+            )
+            # Match predict.py: FP32 inference is serialized to FP16 Zarr values.
+            outputs = {name: value.half().float() for name, value in outputs.items()}
+            for family in DENSE_FAMILIES:
+                metrics[family].update(
+                    outputs[family][0],
+                    torch.asinh(sample["dense"][family]["values"]),
+                    sample["dense"][family]["mask"],
+                )
+            metrics["splice_sites"].update(outputs["splice_sites"][0], sample["splice_sites"])
+            metrics["splice_usage"].update(
+                outputs["splice_usage"][0],
+                torch.asinh(sample["splice_usage"]["values"]),
+                sample["splice_usage"]["mask"],
+            )
+            junction_track = sample["junction_scoring"]["track"]
+            metrics["junctions"].update_indexed(
+                outputs["junctions"][0][junction_valid],
+                junction_target[0][junction_valid],
+                junction_track[junction_valid],
+            )
+            metrics["contact_maps"].update(
+                outputs["contact_maps"][0],
+                torch.asinh(sample["contact_maps"]),
+                sample["contact_map_mask"],
+            )
+            if index == 0 or (index + 1) % args.log_every == 0 or index + 1 == size:
+                print(json.dumps({"event": "evaluate_progress", "examples": index + 1, "total": size}), flush=True)
+    families = {name: accumulator.report() for name, accumulator in metrics.items()}
+    valid_family_scores = [item["mean_pearson"] for item in families.values()]
+    report = {
+        "schema": "alphagenome-50m-evaluation/v3",
+        "split": args.split,
+        "examples": size,
+        "metric_space": (
+            "asinh continuous targets and binary splice-site targets; "
+            "junction Pearson uses hidden coordinate queries and predicted endpoints; "
+            "FP32 inference rounded to FP16 prediction values"
+        ),
+        "families": families,
+        "overall_mean_family_pearson": float(np.mean(valid_family_scores)),
+    }
+    args.report.parent.mkdir(parents=True, exist_ok=True)
+    args.report.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({"event": "evaluate_complete", "overall_mean_family_pearson": report["overall_mean_family_pearson"]}), flush=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--input", required=True, type=Path)
+    common.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    common.add_argument("--workers", type=int, default=2)
+    common.add_argument("--max-examples", type=int, default=0)
+    common.add_argument("--device", choices=("auto", "cuda", "cpu"), default="auto")
+    common.add_argument("--log-every", type=int, default=25)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    train_parser = subparsers.add_parser("train", parents=[common])
+    train_parser.add_argument("--output", required=True, type=Path)
+    train_parser.add_argument("--epochs", type=int, default=10)
+    train_parser.add_argument("--stop-after-epoch", type=int)
+    train_parser.add_argument("--learning-rate", type=float, default=2e-4)
+    train_parser.add_argument("--min-learning-rate", type=float, default=2e-5)
+    train_parser.add_argument("--weight-decay", type=float, default=1e-4)
+    train_parser.add_argument("--max-gradient-norm", type=float, default=5.0)
+    train_parser.add_argument("--save-every", type=int, default=250)
+    train_parser.add_argument("--seed", type=int, default=17)
+    train_parser.add_argument("--resume", type=Path)
+    train_parser.set_defaults(run=train)
+    evaluate_parser = subparsers.add_parser("evaluate", parents=[common])
+    evaluate_parser.add_argument("--checkpoint", required=True, type=Path)
+    evaluate_parser.add_argument("--split", choices=("train", "valid", "test"), required=True)
+    evaluate_parser.add_argument("--report", required=True, type=Path)
+    evaluate_parser.set_defaults(run=evaluate)
+    args = parser.parse_args()
+    if args.workers < 0 or args.max_examples < 0:
+        parser.error("workers/max-examples must be nonnegative")
+    if args.command == "train" and (
+        args.epochs < 1
+        or (args.stop_after_epoch is not None
+            and not 1 <= args.stop_after_epoch <= args.epochs)
+    ):
+        parser.error("epochs must be positive and stop-after-epoch must be within the schedule")
+    args.run(args)
+
+
+if __name__ == "__main__":
+    main()

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S001/validation_variants.json

@@ -0,0 +1,125 @@
+{
+  "eqtl_sign": {
+    "rows": 17052,
+    "perturbations": 165,
+    "metric": "auroc",
+    "model": 0.4941389147398904,
+    "anchors": {
+      "AlphaGenome": 0.8263569969634328
+    }
+  },
+  "eqtl_causality": {
+    "rows": 17934,
+    "perturbations": 174,
+    "metric": "auroc",
+    "model": 0.6542302506588221,
+    "anchors": {
+      "AlphaGenome": 0.8325427468284611
+    }
+  },
+  "eqtl_coefficient": {
+    "rows": 8575,
+    "perturbations": 165,
+    "metric": "spearman",
+    "model": -0.04857778001776154,
+    "anchors": {
+      "AlphaGenome": 0.4133539365891599
+    }
+  },
+  "sqtl_causality": {
+    "rows": 21340,
+    "perturbations": 194,
+    "metric": "auprc",
+    "model": 0.8433797414542621,
+    "anchors": {
+      "AlphaGenome": 0.8447114201904594
+    }
+  },
+  "clinvar_noncoding": {
+    "rows": 199,
+    "perturbations": 199,
+    "metric": "auprc",
+    "model": 0.1946354697971151,
+    "anchors": {
+      "AlphaGenome": 0.9409857958177288
+    }
+  },
+  "clinvar_splice_region": {
+    "rows": 194,
+    "perturbations": 194,
+    "metric": "auprc",
+    "model": 0.17777922359375958,
+    "anchors": {
+      "AlphaGenome": 0.7224791623996103
+    }
+  },
+  "clinvar_missense": {
+    "rows": 199,
+    "perturbations": 199,
+    "metric": "auprc",
+    "model": 0.23303249002260132,
+    "anchors": {
+      "AlphaGenome": 0.373826292978903
+    }
+  },
+  "mfass": {
+    "rows": 195,
+    "perturbations": 195,
+    "metric": "auprc",
+    "model": 0.21772140965743444,
+    "anchors": {
+      "AlphaGenome": 0.7342557141920668
+    }
+  },
+  "caqtl": {
+    "rows": 198,
+    "perturbations": 198,
+    "metric": "auprc",
+    "model": 0.1636819584913644,
+    "anchors": {
+      "AlphaGenome": 0.8075760167741196
+    }
+  },
+  "bqtl_spi1": {
+    "rows": 160,
+    "perturbations": 160,
+    "metric": "auprc",
+    "model": 0.20768655997770985,
+    "anchors": {
+      "AlphaGenome": 0.8167450781363793
+    }
+  },
+  "enhancer_gene": {
+    "rows": 200,
+    "perturbations": 200,
+    "metric": "auprc",
+    "model": 0.4132730815910868,
+    "anchors": {
+      "AlphaGenome": 0.9594307235541584
+    }
+  },
+  "traitgym_mendelian": {
+    "rows": 292,
+    "perturbations": 292,
+    "metric": "auprc",
+    "model": 0.20918637590093828,
+    "anchors": {
+      "Borzoi_L2_L2.plus.all": 0.5026323772738239,
+      "Enformer_L2_L2.plus.all": 0.5452938267693526,
+      "CADD.plus.RawScore": 0.7189111372856957,
+      "GPN-MSA_absLLR.plus.score": 0.6729149139043132
+    }
+  },
+  "traitgym_complex": {
+    "rows": 299,
+    "perturbations": 299,
+    "metric": "auprc",
+    "model": 0.2001169301893302,
+    "anchors": {
+      "Borzoi_L2_L2.plus.all": 0.294501577162467,
+      "Enformer_L2_L2.plus.all": 0.269227301087889,
+      "CADD.plus.RawScore": 0.41341570280137435,
+      "GPN-MSA_absLLR.plus.score": 0.4213971415058371
+    }
+  }
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/README.md

@@ -0,0 +1,70 @@
+# SeqFunc local01 — base-resolution residual path
+
+A single 13,256,456-parameter model reads 1,048,576 bp and predicts all eleven output families.
+Its global encoder and six 384-wide transformer blocks operate on 1,024 tokens. A parallel width-32
+convolutional path keeps base resolution, with a 21-bp stem and four residual depthwise blocks at
+dilations 1, 4, 16 and 64 (701-bp receptive field). Base logits augment splice predictions; average
+and maximum pooling supply aligned 128-bp residual features to dense, usage and junction heads.
+Contacts use the shared global trunk. Sparse sites and junctions come from model scores alone.
+
+All weights originated from local random initialization with seed 17. The parent model trained
+for 2,000 updates using a balanced splice objective; the new branch was attached with zero residual
+outputs and trained for the next 2,000 updates. Parent parameters and optimizer moments were
+preserved exactly at attachment. This checkpoint has seen 4,000 distinct eligible training intervals
+(9.75% of the first epoch); complete training coverage is still in progress. All 41,020 intervals
+are included in each deterministic epoch permutation. Data are AlphaGenome FOLD_0 train folds 2–7,
+with the supplied quantized-target decoding. No pretrained parameters, test labels or test-derived
+caches were used. Development labels are used only to evaluate and select models.
+
+Training uses one H100 80 GB, at most 22 CPUs, eight loader workers, BF16, AdamW, a four-epoch
+2e-4-to-2e-5 cosine schedule with 500-step warmup, weight decay 1e-4, and gradient clipping at 5.
+The splice loss balances positives and negatives per type; the other family losses follow the
+reference. A full-length mechanical benchmark measured about 0.09 seconds per steady training
+step and 3.7 GiB peak allocated GPU memory. End-to-end training runs can share this same GPU with
+validation inference of a frozen earlier checkpoint; no second GPU is used.
+
+Both entry points read only public manifests and the pinned reference DNA. The complete Python,
+PyTorch and CUDA-library environment is vendored in runtime.tar.gz and is extracted temporarily
+offline. The host provides Linux, bash/tar/gzip and the NVIDIA driver. Model weights, source code,
+checksums, and complete validation reports are included. Perturbation values use float32; track
+values use float16. Both entry points use the same parameters and model functions.
+
+All 200 validation intervals and all 2,697 development perturbations are scored with the verifier's
+unmodified tools; results and published anchors are appended below. This early checkpoint remains
+undertrained, has a short local receptive field, and retains a low-capacity contact/junction model.
+The matched control continues the same parent on the same additional training intervals without
+the local path; it is tracked separately in the research ledger.
+
+## Measured validation results
+
+Family-mean Pearson: **0.171715** on 200 validation intervals.
+
+| Family | Pearson |
+|---|---:|
+| atac | 0.313440 |
+| dnase | 0.488170 |
+| procap | 0.267572 |
+| cage | 0.130995 |
+| rna_seq | 0.149987 |
+| chip_tf | 0.254508 |
+| chip_histone | 0.223019 |
+| splice_sites | 0.030428 |
+| splice_usage | 0.023365 |
+| junctions | 0.004990 |
+| contact_maps | 0.002394 |
+
+| Development evaluation | Metric | Model | Published anchors on the same rows |
+|---|---|---:|---|
+| eqtl_sign | auroc | 0.4399 | AlphaGenome: 0.8264 |
+| eqtl_causality | auroc | 0.6804 | AlphaGenome: 0.8325 |
+| eqtl_coefficient | spearman | -0.1099 | AlphaGenome: 0.4134 |
+| sqtl_causality | auprc | 0.6716 | AlphaGenome: 0.8447 |
+| clinvar_noncoding | auprc | 0.1962 | AlphaGenome: 0.9410 |
+| clinvar_splice_region | auprc | 0.2155 | AlphaGenome: 0.7225 |
+| clinvar_missense | auprc | 0.2710 | AlphaGenome: 0.3738 |
+| mfass | auprc | 0.1522 | AlphaGenome: 0.7343 |
+| caqtl | auprc | 0.3468 | AlphaGenome: 0.8076 |
+| bqtl_spi1 | auprc | 0.2619 | AlphaGenome: 0.8167 |
+| enhancer_gene | auprc | 0.4727 | AlphaGenome: 0.9594 |
+| traitgym_mendelian | auprc | 0.2523 | Borzoi_L2_L2.plus.all: 0.5026; Enformer_L2_L2.plus.all: 0.5453; CADD.plus.RawScore: 0.7189; GPN-MSA_absLLR.plus.score: 0.6729 |
+| traitgym_complex | auprc | 0.1482 | Borzoi_L2_L2.plus.all: 0.2945; Enformer_L2_L2.plus.all: 0.2692; CADD.plus.RawScore: 0.4134; GPN-MSA_absLLR.plus.score: 0.4214 |

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/infer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: infer.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/predict.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/package_manifest.json

@@ -0,0 +1,26 @@
+{
+  "parameters": 13256456,
+  "source_checkpoint_sha256": "2258257f7d405240c62d9f9faafba2c7f87da26041302f387dad790c2f123209",
+  "files": {
+    "README.md": "9d2854394e54a769b519e4e60aec257d83439eed1ed0f584f3b58999cbfb5905",
+    "infer.sh": "ef810532b1e72b85fbe283e4f52c177bb70025977dbb2345d75837c9bbd51e37",
+    "last.pt": "eb52b09e500dc3089b840c0ac471e4b449090889799d73e0741f61b787536756",
+    "perturb.py": "ba37a6f9f8b8eccb052903618bcb4c91d3f4cbed62dfe678ee362644dc80801e",
+    "perturb.sh": "113ec2383276a6e83fe1e4e8b0fa914f8d535d5dd0f5b2c34240140312dd5fb4",
+    "predict.py": "2725592456c55c188b22c376f0cb249e9f46b4ae1370d2226df7143da358a8b2",
+    "prediction_contract.py": "b11af8f7cff82b35afc6282be387358a48464b78bd1dfa44452dace26a5e0a83",
+    "reference/__init__.py": "45f3cf93f48859104e70bb58d717130dfd6521a45d2aba06b1a726afc0dc51dd",
+    "reference/alphagenome_50m/__init__.py": "a5a7e45d5940c3b201017c6322128e9f47efd37e1d29f717da2c1f787688eff9",
+    "reference/alphagenome_50m/alphagenome_50m.yaml": "3cac32e9f55e352dff78bb85ac892fdae1f9e412d9bba3e945750210c5252eee",
+    "reference/alphagenome_50m/dataset.py": "ad6670f742f4de9898064becc525d0aea98b402abe7b210bb1b26a9eee6402b9",
+    "reference/alphagenome_50m/layers.py": "26a116a72aa3f0e307a3606163547edbdecb7965f7fdcd96bc5f805cd21b3352",
+    "reference/alphagenome_50m/model.py": "2871dc8893879c3e14a526dea659701d72c8c4d0e2f835b0bfb857034a2c2e6d",
+    "reference/alphagenome_50m/reference_large.yaml": "68084d299b39418034c6bbf71db174c3ffa68bbeea8779c1694e44ec71f3529c",
+    "reference/alphagenome_50m/run_ddp.sh": "96d35a24a4e6789311501fb98203807ac0c4429375c44d5c6671908270c93bb0",
+    "reference/alphagenome_50m/tiny_overfit.yaml": "f7a104c3929de0530a9a8f73f66d794cca595aefad8ef262e09ecbeb9cfce6de",
+    "reference/alphagenome_50m/train_eval.py": "2547c9adbdb51ad1acf796a548724cc7770eba90a755f4cb3b37d6f591adf6ec",
+    "runtime.tar.gz": "718da4c374e0c552b6e429b226c90b2fded5c900d95577d190d4df520aaf3901",
+    "validation_tracks.json": "4cbc1f3246fd93e871c3b198e14d976fa3bca2e1c616160f606a5176d7e4a51e",
+    "validation_variants.json": "edc97df92a3954c3c57bdc9ed3354b57d5f03aa92057cdb7fcb28e3c89d9209c"
+  }
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/perturb.py

@@ -0,0 +1,101 @@
+"""Predict both sequences of every perturbation (contract: perturbations/v1).
+
+    python perturb.py INPUT_ROOT OUTPUT_ROOT --checkpoint last.pt
+
+INPUT_ROOT holds `public/perturbations.parquet` and `reference/GRCh38.p13.genome.fa` (in the
+workspace, `/workspace/data` works too: the queries are then read from `variant_evals/public/`). Each row is a
+1,048,576-bp window starting at `input_start` and an edit spanning [edit_start, edit_end) in genomic
+0-based coordinates:
+
+- `snv`: sequence A carries `allele_a` at edit_start, sequence B carries `allele_b` (both are written
+  explicitly; either may differ from the reference genome);
+- `mask`: sequence A is the reference, sequence B has the interval replaced by N.
+
+For each perturbation the output group `perturbations/p{index:06d}` holds `a/<family>` and
+`b/<family>` for every family in `families`: dense families sliced to bins
+[dense_bin_start, dense_bin_end) of the central target window, and `splice_sites` sliced to bp
+[splice_start, splice_end). Values are the same quantities as predictions.zarr (asinh space for
+dense tracks, splice-site scores for splice_sites).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import pandas as pd
+import pysam
+import torch
+import zarr
+
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+PERTURBATION_SCHEMA = "genome-sequence-to-function-perturbations/v1"
+COMPRESSOR = Blosc(cname="zstd", clevel=3, shuffle=Blosc.BITSHUFFLE)
+
+
+def sequences(fasta, row) -> tuple[str, str]:
+    length = fasta.get_reference_length(row.chrom)
+    start, end = int(row.input_start), int(row.input_start) + 1_048_576
+    sequence = fasta.fetch(row.chrom, max(0, start), min(length, end)).upper()
+    sequence = "N" * max(0, -start) + sequence + "N" * max(0, end - length)
+    lo, hi = int(row.edit_start) - start, int(row.edit_end) - start
+    if row.edit == "snv":
+        return sequence[:lo] + row.allele_a + sequence[hi:], sequence[:lo] + row.allele_b + sequence[hi:]
+    if row.edit == "mask":
+        return sequence, sequence[:lo] + "N" * (hi - lo) + sequence[hi:]
+    raise ValueError(f"unknown edit {row.edit!r}")
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, queries: Path | None = None) -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    if queries is None:
+        queries = input_root / "public/perturbations.parquet"
+        if not queries.exists():
+            queries = input_root / "variant_evals/public/perturbations.parquet"
+    rows = pd.read_parquet(queries)
+    fasta = pysam.FastaFile(str(input_root / "reference/GRCh38.p13.genome.fa"))
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "perturbations.zarr"), mode="w")
+    target_start = (config.input_length - config.target_length) // 2
+    with torch.inference_mode():
+        for index, row in enumerate(rows.itertuples(index=False)):
+            pair = sequences(fasta, row)
+            dna = torch.from_numpy(np.stack([AlphaGenomeDataset._one_hot(s) for s in pair])).to(device)
+            trunk = model._trunk(dna)
+            group = root.create_group(f"perturbations/p{index:06d}")
+            features = None
+            for family in row.families:
+                if family == "splice_sites":
+                    logits = model._splice_site_logits(trunk)[:, target_start:target_start + config.target_length]
+                    values = logits[:, row.splice_start:row.splice_end]
+                else:
+                    features = model._dense_features(trunk) if features is None else features
+                    values = model.dense_heads[family](features)[:, row.dense_bin_start:row.dense_bin_end]
+                # float32: one variant's effect is often below float16 resolution (about 0.004 at
+                # asinh values of 4-8), so A and B would round to the same numbers.
+                values = values.float().cpu().numpy()
+                for side, array in zip("ab", values):
+                    group.create_dataset(f"{side}/{family}", data=array, compressor=COMPRESSOR)
+            print(json.dumps({"event": "perturb", "done": index + 1, "total": len(rows)}), flush=True)
+    root.attrs.update({"schema": PERTURBATION_SCHEMA,
+                       "perturbation_ids": rows.perturbation_id.astype(str).tolist()})
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--queries", type=Path, help="another query table, e.g. the development split")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.queries)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/perturb.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: perturb.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/perturb.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/predict.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Stream the single benchmark model into the sharded prediction contract."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import torch
+import zarr
+
+from prediction_contract import DENSE_TRACKS, MAX_JUNCTION_PAIRS, MAX_USAGE_SITES, PREDICTION_SCHEMA
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+
+COMPRESSOR = Blosc(cname="zstd", clevel=7, shuffle=Blosc.BITSHUFFLE)
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, split: str = "test") -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    dataset = AlphaGenomeDataset(input_root, split, include_targets=False)
+    model.set_junction_track_halves(dataset.junction_track_halves)
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "predictions.zarr"), mode="w")
+    ids = []
+    with torch.inference_mode():
+        for sample in dataset:
+            example_id = sample["example_id"]
+            dna = sample["dna"][None].to(device)
+            trunk = model._trunk(dna)
+            dense_features = model._dense_features(trunk)
+            group = root.create_group(f"examples/{example_id}")
+            for family in DENSE_TRACKS:
+                values = model.dense_heads[family](dense_features)[0]
+                group.create_dataset(family, data=values.cpu().numpy().astype(np.float16), compressor=COMPRESSOR)
+
+            all_site_logits = model._splice_site_logits(trunk)
+            target_start = (config.input_length - config.target_length) // 2
+            group.create_dataset(
+                "splice_sites",
+                data=all_site_logits[0, target_start:target_start + config.target_length].cpu().numpy().astype(np.float16),
+                chunks=(4096, 4), compressor=COMPRESSOR,
+            )
+            predicted_positions = model.select_junction_positions(all_site_logits)[0]
+
+            # Usage at the model's own predicted sites (v4 is sparse; unlisted hidden sites score 0).
+            usage_bins = model.splice_usage_head(dense_features)[0].float()
+            sites = predicted_positions.cpu().numpy().astype(np.int64).reshape(-1)
+            sites = np.unique(sites[(sites >= target_start) & (sites < target_start + config.target_length)]
+                              - target_start)[:MAX_USAGE_SITES]
+            group.create_dataset("splice_usage_positions", data=sites.astype(np.int32), compressor=COMPRESSOR)
+            usage = usage_bins[torch.as_tensor(sites // 128, device=usage_bins.device)] if len(sites) \
+                else usage_bins[:0]
+            group.create_dataset("splice_usage", data=usage.cpu().numpy().astype(np.float16),
+                                 chunks=(1024, 734), compressor=COMPRESSOR)
+
+            # Junctions: score every donor x acceptor pair of each strand, keep the strongest pairs.
+            positions_batch = predicted_positions[None]
+            site_factors = model.junction_site_factors(trunk, positions_batch)
+            halves = model.junction_track_half
+            candidates = []
+            for row_start in range(0, 512, 128):
+                for column_start in range(0, 512, 128):
+                    block = torch.cat([
+                        model.junction_block(
+                            trunk, positions_batch, row_start, row_start + 128,
+                            column_start, column_start + 128, track_start,
+                            min(track_start + 64, config.junction_tracks), site_factors,
+                        )[0]
+                        for track_start in range(0, config.junction_tracks, 64)
+                    ], dim=-1).float()  # [128, 128, 734]
+                    for half in (0, 1):
+                        donors = predicted_positions[2 * half, row_start:row_start + 128]
+                        acceptors = predicted_positions[2 * half + 1, column_start:column_start + 128]
+                        valid = (donors[:, None] >= 0) & (acceptors[None, :] >= 0)
+                        strength = block[..., halves == half].amax(dim=-1).masked_fill(~valid, -torch.inf)
+                        keep = min(MAX_JUNCTION_PAIRS // 2, int(valid.sum()))
+                        if not keep:
+                            continue
+                        best = strength.flatten().topk(keep)
+                        rows, columns = best.indices // 128, best.indices % 128
+                        candidates.append((best.values, torch.full_like(rows, half), donors[rows],
+                                           acceptors[columns], block[rows, columns]))
+            if candidates:
+                score, half, donor, acceptor, values = (torch.cat(x) for x in zip(*candidates))
+                order = score.topk(min(MAX_JUNCTION_PAIRS, len(score))).indices
+                half, donor, acceptor, values = half[order], donor[order], acceptor[order], values[order]
+            else:
+                half = donor = acceptor = torch.zeros(0, dtype=torch.long)
+                values = torch.zeros(0, config.junction_tracks)
+            group.create_dataset("junction_half", data=half.cpu().numpy().astype(np.int8), compressor=COMPRESSOR)
+            group.create_dataset("junction_donor", data=donor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junction_acceptor", data=acceptor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junctions", data=values.cpu().numpy().astype(np.float16),
+                                 chunks=(4096, 734), compressor=COMPRESSOR)
+
+            contact = trunk.reshape(
+                1, config.contact_bins, -1, config.hidden_dim
+            ).mean(dim=2)
+            q, k = model.contact_q(contact), model.contact_k(contact)
+            row, column = model.contact_row, model.contact_column
+            contact_values = 0.5 * (q[:, row] * k[:, column] + q[:, column] * k[:, row])
+            group.create_dataset(
+                "contact_maps", data=contact_values[0].cpu().numpy().astype(np.float16),
+                chunks=(8192, 28), compressor=COMPRESSOR,
+            )
+            ids.append(example_id)
+            print(json.dumps({"event": "predict", "example": len(ids), "total": len(dataset)}), flush=True)
+    root.attrs.update({"schema": PREDICTION_SCHEMA, "example_ids": ids})
+    (output_root / "example_ids.json").write_text(json.dumps(ids) + "\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--split", default="test", choices=("valid", "test"),
+                        help="manifest to predict; the verifier uses test, local validation uses valid")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.split)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/prediction_contract.py

@@ -0,0 +1,23 @@
+"""Public prediction shapes; no trusted splice coordinates are exposed."""
+
+from __future__ import annotations
+
+DENSE_TRACKS = {
+    "atac": 167,
+    "dnase": 305,
+    "procap": 12,
+    "cage": 546,
+    "rna_seq": 667,
+    "chip_tf": 1_617,
+    "chip_histone": 1_116,
+}
+
+PREDICTION_SCHEMA = "genome-sequence-to-function-predictions/v4"
+MAX_USAGE_SITES = 4_096
+MAX_JUNCTION_PAIRS = 16_384
+# Fixed-shape arrays per example; splice usage and junctions are sparse (see contract.md).
+FIXED_SHAPES = {
+    **{name: (1_536, tracks) for name, tracks in DENSE_TRACKS.items()},
+    "splice_sites": (196_608, 4),
+    "contact_maps": (131_328, 28),
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/__init__.py

@@ -0,0 +1 @@
+"""The reference model of the alphagenome-reference baseline."""

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/__init__.py

@@ -0,0 +1,5 @@
+"""Compact 1-Mb, eleven-family AlphaGenome reference model."""
+
+from .model import CompactModel, ModelConfig, count_parameters
+
+__all__ = ["CompactModel", "ModelConfig", "count_parameters"]

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/alphagenome_50m.yaml

@@ -0,0 +1,23 @@
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 32
+channel_growth: 32
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 384
+num_sequence_blocks: 6
+num_attention_heads: 6
+attention_head_dim: 64
+mlp_expansion: 4.0
+dropout: 0.0
+head_hidden_size: 256
+junction_rank: 32
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: true

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/dataset.py

@@ -0,0 +1,229 @@
+"""Streaming reader for the compact 1 Mb / eleven-family release."""
+
+from __future__ import annotations
+
+from collections import OrderedDict
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import pysam
+import torch
+from torch.utils.data import Dataset
+import zarr
+
+
+def _open_part(path: Path):
+    if str(path).endswith(".zarr.zip"):
+        store = zarr.ZipStore(str(path), mode="r")
+        try:
+            return zarr.open_group(store=store, mode="r"), store
+        except BaseException:
+            store.close()
+            raise
+    return zarr.open_group(str(path), mode="r"), None
+
+
+DENSE_FAMILIES = (
+    "atac",
+    "dnase",
+    "procap",
+    "cage",
+    "rna_seq",
+    "chip_tf",
+    "chip_histone",
+)
+def normalize_splice_positions(value) -> np.ndarray:
+    """Normalize Arrow's nested-list representation to the public [4, 512] array."""
+
+    outer = np.asarray(value, dtype=object).reshape(-1).tolist()
+    positions = np.stack([np.asarray(item, dtype=np.int64) for item in outer])
+    if positions.shape != (4, 512):
+        raise ValueError(f"splice_site_positions must have shape (4, 512), got {positions.shape}")
+    return positions
+
+
+class AlphaGenomeDataset(Dataset):
+    """Resolve frozen coordinates to reference DNA and one Zarr example group."""
+
+    def __init__(
+        self,
+        data_root: str | Path,
+        split: str,
+        *,
+        max_open_parts: int = 8,
+        include_targets: bool = True,
+    ) -> None:
+        self.root = Path(data_root)
+        self.split = split
+        manifest = self.root / "public" / f"{split}.parquet"
+        if not manifest.is_file():
+            raise FileNotFoundError(f"Missing materialized manifest: {manifest}")
+        self.rows = pd.read_parquet(manifest).reset_index(drop=True)
+        junction_tracks = pd.read_parquet(self.root / "public/junction_tracks.parquet")
+        junction_tracks = junction_tracks.sort_values("tensor_index")
+        self.junction_track_halves = torch.from_numpy(
+            junction_tracks.junction_channel_half.to_numpy(np.int64)
+        )
+        if include_targets:
+            labels_path = self.root / "labels" / f"{split}.parquet"
+            if not labels_path.is_file():
+                raise FileNotFoundError(f"Missing trusted labels manifest: {labels_path}")
+            labels = pd.read_parquet(labels_path).reset_index(drop=True)
+            if self.rows.example_id.astype(str).tolist() != labels.example_id.astype(str).tolist():
+                raise ValueError("public and labels manifests have different IDs/order")
+            self.rows = self.rows.merge(labels, on="example_id", validate="one_to_one", sort=False)
+        self.fasta_path = self.root / "reference" / "GRCh38.p13.genome.fa"
+        self.max_open_parts = max_open_parts
+        self.include_targets = include_targets
+        self._fasta = None
+        self._parts: OrderedDict[str, tuple[zarr.Group, object | None]] = OrderedDict()
+
+    def __len__(self) -> int:
+        return len(self.rows)
+
+    def _reference(self):
+        if self._fasta is None:
+            self._fasta = pysam.FastaFile(str(self.fasta_path))
+        return self._fasta
+
+    def _part(self, relative: str):
+        if relative in self._parts:
+            opened = self._parts.pop(relative)
+            self._parts[relative] = opened
+            return opened[0]
+        group, store = _open_part(self.root / relative)
+        if len(self._parts) >= self.max_open_parts:
+            _, (_, old_store) = self._parts.popitem(last=False)
+            if old_store is not None:
+                old_store.close()
+        self._parts[relative] = (group, store)
+        return group
+
+    @staticmethod
+    def _one_hot(sequence: str) -> np.ndarray:
+        encoded = np.frombuffer(sequence.upper().encode("ascii"), dtype=np.uint8)
+        output = np.zeros((len(encoded), 4), dtype=np.float32)
+        for index, letter in enumerate(b"ACGT"):
+            output[:, index] = encoded == letter
+        return output
+
+    def _sequence(self, row) -> tuple[np.ndarray, np.ndarray]:
+        reference = self._reference()
+        chromosome_length = reference.get_reference_length(str(row.chromosome))
+        start, end = int(row.input_start), int(row.input_end)
+        clipped_start, clipped_end = max(0, start), min(chromosome_length, end)
+        sequence = reference.fetch(str(row.chromosome), clipped_start, clipped_end)
+        left, right = clipped_start - start, end - clipped_end
+        if left or right:
+            sequence = "N" * left + sequence + "N" * right
+        valid = np.ones(end - start, dtype=bool)
+        if left:
+            valid[:left] = False
+        if right:
+            valid[-right:] = False
+        return self._one_hot(sequence), valid
+
+    @staticmethod
+    def _decode(example, name: str, *, asinh: bool) -> np.ndarray:
+        """Train targets may be stored as 8-bit codes with per-track ranges; they are decoded
+        here, one example at a time, so the release stays compressed on disk."""
+        array = example[name]
+        if array.dtype != np.uint8:
+            return np.asarray(array, dtype=np.float32)
+        lo = np.asarray(example[f"{name}_lo"], dtype=np.float32)
+        hi = np.asarray(example[f"{name}_hi"], dtype=np.float32)
+        x = lo + np.asarray(array, dtype=np.float32) * ((hi - lo) / 255.0)
+        return np.sinh(x) if asinh else x
+
+    @staticmethod
+    def _dense_target(example, family: str) -> dict[str, torch.Tensor]:
+        values = AlphaGenomeDataset._decode(example, f"{family}/values", asinh=True)
+        mask = np.asarray(example[f"{family}/mask"], dtype=bool)
+        if mask.ndim == 1:
+            mask = np.broadcast_to(mask[None, :], values.shape).copy()
+        return {
+            "values": torch.from_numpy(values),
+            "mask": torch.from_numpy(mask),
+        }
+
+    def __getitem__(self, item: int):
+        row = self.rows.iloc[item]
+        dna, input_mask = self._sequence(row)
+        result = {
+            "example_id": str(row.example_id),
+            "dna": torch.from_numpy(dna),
+            "input_mask": torch.from_numpy(input_mask),
+            "junction_track_halves": self.junction_track_halves,
+        }
+        if not self.include_targets:
+            return result
+
+        part = self._part(str(row.target_shard))
+        example = part[str(row.target_group)]
+        result["dense"] = {
+            family: self._dense_target(example, family) for family in DENSE_FAMILIES
+        }
+        result["splice_sites"] = torch.from_numpy(
+            np.asarray(example["splice_sites/values"], dtype=np.float32)
+        )
+        result["splice_usage"] = {
+            "positions": torch.from_numpy(
+                np.asarray(example["splice_site_usage/positions"], dtype=np.int64)
+            ),
+            "values": torch.from_numpy(
+                np.asarray(example["splice_site_usage/values"], dtype=np.float32)
+            ),
+            "mask": torch.from_numpy(
+                np.asarray(example["splice_site_usage/mask"], dtype=bool)
+            ),
+        }
+        result["usage_positions"] = result["splice_usage"]["positions"]
+        result["junctions"] = {
+            name: torch.from_numpy(
+                np.asarray(
+                    example[f"splice_junctions/{name}"],
+                    dtype=np.float32 if name == "value" else np.int64,
+                )
+            )
+            for name in ("row", "column", "track", "value")
+        }
+        result["junctions"]["site_positions"] = torch.from_numpy(
+            np.asarray(example["splice_junctions/site_positions"], dtype=np.int64)
+        )
+        site_positions = normalize_splice_positions(row.splice_site_positions)
+        result["site_positions"] = torch.from_numpy(site_positions)
+        if not torch.equal(result["junctions"]["site_positions"], result["site_positions"]):
+            raise ValueError(f"public/private splice positions differ for {row.example_id}")
+        scoring_path = self.root / "scoring" / self.split / f"part-{item:06d}.parquet"
+        scoring = pd.read_parquet(scoring_path)
+        if not (scoring.example_id.astype(str) == str(row.example_id)).all():
+            raise ValueError(f"scoring part ID differs for {row.example_id}")
+        result["junction_scoring"] = {
+            "donor_position": torch.from_numpy(
+                scoring.donor_position.to_numpy(np.int64)
+            ),
+            "acceptor_position": torch.from_numpy(
+                scoring.acceptor_position.to_numpy(np.int64)
+            ),
+            "track": torch.from_numpy(scoring.track.to_numpy(np.int64)),
+            "target_value": torch.from_numpy(
+                scoring.target_value.to_numpy(np.float32)
+            ),
+            "valid": torch.from_numpy(scoring.valid.to_numpy(bool)),
+        }
+        result["contact_maps"] = torch.from_numpy(
+            self._decode(example, "contact_maps/upper_triangle", asinh=False)
+        )
+        result["contact_map_mask"] = torch.from_numpy(
+            np.asarray(example["contact_maps/mask"], dtype=bool)
+        )
+        return result
+
+
+def single_example_collate(items):
+    """Keep variable-size event tensors intact; the reference currently trains at batch one."""
+
+    if len(items) != 1:
+        raise ValueError("The compact event loader currently requires batch_size=1")
+    return items[0]

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/layers.py

@@ -0,0 +1,124 @@
+"""Shared neural-network layers for the single compact AlphaGenome model."""
+
+from __future__ import annotations
+
+import math
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F
+
+
+class ChannelRMSNorm(nn.Module):
+    def __init__(self, channels: int, eps: float = 1e-6):
+        super().__init__()
+        self.weight = nn.Parameter(torch.ones(channels))
+        self.eps = eps
+
+    def forward(self, x: Tensor) -> Tensor:
+        variance = x.float().square().mean(dim=1, keepdim=True)
+        normalized = x * torch.rsqrt(variance + self.eps).to(x.dtype)
+        return normalized * self.weight[None, :, None].to(x.dtype)
+
+
+class StandardizedConv1d(nn.Conv1d):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int):
+        super().__init__(in_channels, out_channels, kernel_size, padding="same", bias=True)
+        self.scale = nn.Parameter(torch.ones(out_channels))
+        nn.init.trunc_normal_(self.weight, std=1.0 / math.sqrt(in_channels * kernel_size))
+        nn.init.trunc_normal_(self.bias, std=1e-4)
+
+    def forward(self, x: Tensor) -> Tensor:
+        centered = self.weight - self.weight.mean(dim=(1, 2), keepdim=True)
+        variance = centered.float().square().mean(dim=(1, 2), keepdim=True)
+        fan_in = self.weight.shape[1] * self.weight.shape[2]
+        multiplier = self.scale[:, None, None] * torch.rsqrt(
+            (fan_in * variance).clamp_min(1e-4)
+        ).to(self.weight.dtype)
+        return F.conv1d(x, centered * multiplier, self.bias, padding="same")
+
+
+class ConvBlock(nn.Module):
+    def __init__(self, in_channels: int, out_channels: int, kernel_size: int):
+        super().__init__()
+        self.norm = ChannelRMSNorm(in_channels)
+        self.conv = StandardizedConv1d(in_channels, out_channels, kernel_size)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.conv(F.gelu(self.norm(x), approximate="tanh"))
+
+
+def _apply_rope(x: Tensor) -> Tensor:
+    rotary_dim = x.shape[-1] - x.shape[-1] % 2
+    if rotary_dim == 0:
+        return x
+    positions = torch.arange(x.shape[-2], device=x.device, dtype=torch.float32)
+    inverse_frequency = 1.0 / (
+        10_000 ** (
+            torch.arange(0, rotary_dim, 2, device=x.device, dtype=torch.float32)
+            / rotary_dim
+        )
+    )
+    angles = torch.outer(positions, inverse_frequency)
+    cos = angles.cos()[None, None, :, :].to(x.dtype)
+    sin = angles.sin()[None, None, :, :].to(x.dtype)
+    even, odd = x[..., :rotary_dim:2], x[..., 1:rotary_dim:2]
+    rotated = torch.stack((even * cos - odd * sin, even * sin + odd * cos), dim=-1)
+    return torch.cat((rotated.flatten(-2), x[..., rotary_dim:]), dim=-1)
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.num_heads = config.num_attention_heads
+        self.head_dim = config.attention_head_dim
+        inner_dim = self.num_heads * self.head_dim
+        self.norm = nn.RMSNorm(config.hidden_dim)
+        self.qkv = nn.Linear(config.hidden_dim, 3 * inner_dim, bias=False)
+        self.output = nn.Linear(inner_dim, config.hidden_dim)
+        self.dropout = config.dropout
+        nn.init.trunc_normal_(self.output.weight, std=1e-3)
+        nn.init.zeros_(self.output.bias)
+
+    def forward(self, x: Tensor, attention_bias: Tensor | None = None) -> Tensor:
+        batch, length, _ = x.shape
+        qkv = self.qkv(self.norm(x)).view(
+            batch, length, 3, self.num_heads, self.head_dim
+        )
+        q, k, value = qkv.unbind(dim=2)
+        attended = F.scaled_dot_product_attention(
+            _apply_rope(q.transpose(1, 2)),
+            _apply_rope(k.transpose(1, 2)),
+            value.transpose(1, 2),
+            attn_mask=attention_bias,
+            dropout_p=self.dropout if self.training else 0.0,
+        )
+        return self.output(attended.transpose(1, 2).reshape(batch, length, -1))
+
+
+class MLPBlock(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        expanded = int(config.hidden_dim * config.mlp_expansion)
+        self.norm = nn.RMSNorm(config.hidden_dim)
+        self.input = nn.Linear(config.hidden_dim, expanded)
+        self.output = nn.Linear(expanded, config.hidden_dim)
+        self.dropout = nn.Dropout(config.dropout)
+        nn.init.trunc_normal_(self.output.weight, std=1e-3)
+        nn.init.zeros_(self.output.bias)
+
+    def forward(self, x: Tensor) -> Tensor:
+        return self.dropout(
+            self.output(F.gelu(self.input(self.norm(x)), approximate="tanh"))
+        )
+
+
+class SequenceBlock(nn.Module):
+    def __init__(self, config):
+        super().__init__()
+        self.attention = MultiHeadAttention(config)
+        self.mlp = MLPBlock(config)
+
+    def forward(self, x: Tensor, attention_bias: Tensor | None = None) -> Tensor:
+        x = x + self.attention(x, attention_bias)
+        return x + self.mlp(x)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/model.py

@@ -0,0 +1,426 @@
+"""Affordable multi-resolution baseline for the compact AlphaGenome task."""
+
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass, fields
+import math
+from pathlib import Path
+from typing import Any, Iterable
+
+import torch
+from torch import Tensor, nn
+from torch.nn import functional as F
+from torch.utils.checkpoint import checkpoint
+import yaml
+
+from .layers import ChannelRMSNorm, ConvBlock, SequenceBlock
+
+
+DENSE_TRACKS = {
+    "atac": 167,
+    "dnase": 305,
+    "procap": 12,
+    "cage": 546,
+    "rna_seq": 667,
+    "chip_tf": 1_617,
+    "chip_histone": 1_116,
+}
+ALL_FAMILIES = (*DENSE_TRACKS, "splice_sites", "splice_usage", "junctions", "contact_maps")
+
+
+@dataclass(frozen=True)
+class ModelConfig:
+    input_length: int = 1_048_576
+    target_length: int = 196_608
+    dense_bin_size: int = 128
+    trunk_bin_size: int = 1_024
+    contact_bin_size: int = 2_048
+    stem_stride: int = 8
+    encoder_width: int = 32
+    channel_growth: int = 32
+    num_downsampling_blocks: int = 7
+    conv_kernel_size: int = 5
+    dna_kernel_size: int = 15
+    hidden_dim: int = 384
+    num_sequence_blocks: int = 6
+    num_attention_heads: int = 6
+    attention_head_dim: int = 64
+    mlp_expansion: float = 4.0
+    dropout: float = 0.0
+    head_hidden_size: int = 256
+    junction_rank: int = 32
+    splice_usage_tracks: int = 734
+    junction_tracks: int = 734
+    contact_tracks: int = 28
+    gradient_checkpointing: bool = True
+    enable_pairwise: bool = False
+    pair_width: int = 32
+    pair_downsample: int = 16
+    pair_update_interval: int = 2
+    local_width: int = 0
+
+    def __post_init__(self) -> None:
+        downsample = self.stem_stride * 2**self.num_downsampling_blocks
+        if downsample != self.trunk_bin_size:
+            raise ValueError("stem_stride * 2**num_downsampling_blocks must equal trunk_bin_size")
+        for length in (self.input_length, self.target_length):
+            if length % self.trunk_bin_size:
+                raise ValueError("input and target lengths must divide by trunk_bin_size")
+        if self.trunk_bin_size % self.dense_bin_size:
+            raise ValueError("trunk_bin_size must divide by dense_bin_size")
+        if self.input_length % self.contact_bin_size:
+            raise ValueError("input_length must divide by contact_bin_size")
+        if self.hidden_dim <= 0 or self.num_attention_heads <= 0:
+            raise ValueError("hidden dimensions and attention heads must be positive")
+
+    @property
+    def trunk_bins(self) -> int:
+        return self.input_length // self.trunk_bin_size
+
+    @property
+    def target_trunk_bins(self) -> int:
+        return self.target_length // self.trunk_bin_size
+
+    @property
+    def dense_bins(self) -> int:
+        return self.target_length // self.dense_bin_size
+
+    @property
+    def dense_upsample(self) -> int:
+        return self.trunk_bin_size // self.dense_bin_size
+
+    @property
+    def contact_bins(self) -> int:
+        return self.input_length // self.contact_bin_size
+
+    @property
+    def encoder_output_width(self) -> int:
+        return self.encoder_width + self.channel_growth * self.num_downsampling_blocks
+
+    @classmethod
+    def from_yaml(cls, path: str | Path) -> "ModelConfig":
+        values: dict[str, Any] = yaml.safe_load(Path(path).read_text()) or {}
+        known = {field.name for field in fields(cls)}
+        unknown = sorted(values.keys() - known)
+        if unknown:
+            raise ValueError(f"Unknown model configuration keys: {unknown}")
+        return cls(**values)
+
+    def to_dict(self) -> dict[str, Any]:
+        return asdict(self)
+
+
+class SequenceEncoder(nn.Module):
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        self.stem = nn.Conv1d(
+            4,
+            config.encoder_width,
+            config.dna_kernel_size,
+            stride=config.stem_stride,
+            padding=config.dna_kernel_size // 2,
+        )
+        blocks = []
+        width = config.encoder_width
+        for _ in range(config.num_downsampling_blocks):
+            output_width = width + config.channel_growth
+            blocks.append(ConvBlock(width, output_width, config.conv_kernel_size))
+            width = output_width
+        self.blocks = nn.ModuleList(blocks)
+
+    def forward(self, dna: Tensor) -> Tensor:
+        x = F.gelu(self.stem(dna.transpose(1, 2)), approximate="tanh")
+        for block in self.blocks:
+            x = F.max_pool1d(block(x), kernel_size=2, stride=2)
+        return x.transpose(1, 2)
+
+
+class LocalResidualBlock(nn.Module):
+    def __init__(self, width: int, dilation: int):
+        super().__init__()
+        self.norm = ChannelRMSNorm(width)
+        self.depthwise = nn.Conv1d(width, width, 9, dilation=dilation,
+                                   padding=4 * dilation, groups=width)
+        self.expand = nn.Conv1d(width, 2 * width, 1)
+        self.contract = nn.Conv1d(2 * width, width, 1)
+
+    def forward(self, x: Tensor) -> Tensor:
+        update = self.depthwise(self.norm(x))
+        update = self.contract(F.gelu(self.expand(update), approximate='tanh'))
+        return x + update
+
+
+class LocalSequencePath(nn.Module):
+    """Base-resolution motif path; 701-bp receptive field and aligned 128-bp pooling."""
+    def __init__(self, config: ModelConfig):
+        super().__init__()
+        width = config.local_width
+        self.stem = nn.Conv1d(4, width, 21, padding=10)
+        self.blocks = nn.Sequential(*(LocalResidualBlock(width, d) for d in [1, 4, 16, 64]))
+        self.norm = ChannelRMSNorm(width)
+        self.sites = nn.Conv1d(width, 4, 1)
+        self.bin_size = config.dense_bin_size
+
+    def forward(self, dna: Tensor) -> tuple[Tensor, Tensor]:
+        base = F.gelu(self.stem(dna), approximate='tanh')
+        base = F.gelu(self.norm(self.blocks(base)), approximate='tanh')
+        sites = self.sites(base).transpose(1, 2)
+        pooled = torch.cat((F.avg_pool1d(base, self.bin_size),
+                            F.max_pool1d(base, self.bin_size)), dim=1).transpose(1, 2)
+        return sites, pooled
+
+
+class CompactModel(nn.Module):
+    """One shared 1-kb trunk with representation-specific output heads."""
+
+    def __init__(self, config: ModelConfig | None = None):
+        super().__init__()
+        self.config = config or ModelConfig()
+        self.encoder = SequenceEncoder(self.config)
+        self.projection = nn.Linear(self.config.encoder_output_width, self.config.hidden_dim)
+        self.blocks = nn.ModuleList(
+            SequenceBlock(self.config) for _ in range(self.config.num_sequence_blocks)
+        )
+        self.final_norm = nn.RMSNorm(self.config.hidden_dim)
+        self.dense_decoder = nn.Sequential(
+            nn.RMSNorm(self.config.hidden_dim),
+            nn.Linear(self.config.hidden_dim, self.config.head_hidden_size),
+            nn.GELU(approximate="tanh"),
+        )
+        self.dense_heads = nn.ModuleDict(
+            {
+                family: nn.Linear(self.config.head_hidden_size, tracks)
+                for family, tracks in DENSE_TRACKS.items()
+            }
+        )
+        self.splice_site_head = nn.Linear(
+            self.config.head_hidden_size, self.config.dense_bin_size * 4
+        )
+        self.splice_usage_head = nn.Linear(
+            self.config.head_hidden_size, self.config.splice_usage_tracks
+        )
+        rank = self.config.junction_rank
+        self.junction_source = nn.Linear(self.config.head_hidden_size, rank)
+        self.junction_destination = nn.Linear(self.config.head_hidden_size, rank)
+        self.junction_track = nn.Embedding(self.config.junction_tracks, rank)
+        if self.config.junction_tracks % 2:
+            raise ValueError("junction tracks must split evenly into strand halves")
+        self.register_buffer(
+            "junction_track_half",
+            torch.arange(self.config.junction_tracks) // (self.config.junction_tracks // 2),
+            persistent=False,
+        )
+        self.contact_q = nn.Linear(self.config.hidden_dim, self.config.contact_tracks)
+        self.contact_k = nn.Linear(self.config.hidden_dim, self.config.contact_tracks)
+        row, column = torch.triu_indices(
+            self.config.contact_bins, self.config.contact_bins
+        )
+        self.register_buffer("contact_row", row, persistent=False)
+        self.register_buffer("contact_column", column, persistent=False)
+        if self.config.local_width:
+            self.local_path = LocalSequencePath(self.config)
+            self.local_projection = nn.Linear(2 * self.config.local_width, self.config.head_hidden_size)
+            # A new local path can be attached to our own checkpoint without changing its initial outputs.
+            nn.init.zeros_(self.local_path.sites.weight)
+            nn.init.zeros_(self.local_path.sites.bias)
+            nn.init.zeros_(self.local_projection.weight)
+            nn.init.zeros_(self.local_projection.bias)
+        self._local_sites = None
+        self._local_features = None
+
+    def set_junction_track_halves(self, halves: Tensor) -> None:
+        halves = torch.as_tensor(halves, dtype=torch.long, device=self.junction_track_half.device)
+        if halves.shape != (self.config.junction_tracks,) or not torch.isin(
+            halves, torch.tensor([0, 1], device=halves.device)
+        ).all():
+            raise ValueError("junction track halves must be a 734-element 0/1 mapping")
+        self.junction_track_half.copy_(halves)
+
+    def _trunk(self, dna: Tensor) -> Tensor:
+        if dna.ndim != 3 or dna.shape[1:] != (self.config.input_length, 4):
+            raise ValueError(
+                f"Expected DNA [B,{self.config.input_length},4], got {tuple(dna.shape)}"
+            )
+        if self.config.local_width:
+            if self.config.gradient_checkpointing and self.training:
+                sites, pooled = checkpoint(self.local_path, dna.transpose(1, 2), use_reentrant=False)
+            else:
+                sites, pooled = self.local_path(dna.transpose(1, 2))
+            self._local_sites = sites
+            self._local_features = self.local_projection(pooled)
+        x = self.projection(self.encoder(dna))
+        for block in self.blocks:
+            if self.config.gradient_checkpointing and self.training and x.requires_grad:
+                x = checkpoint(block, x, None, use_reentrant=False)
+            else:
+                x = block(x, None)
+        return self.final_norm(x)
+
+    def _dense_features(self, trunk: Tensor) -> Tensor:
+        start = (self.config.trunk_bins - self.config.target_trunk_bins) // 2
+        target = trunk[:, start : start + self.config.target_trunk_bins]
+        target = target.repeat_interleave(self.config.dense_upsample, dim=1)
+        features = self.dense_decoder(target)
+        if self.config.local_width:
+            first_bin = (self.config.input_length - self.config.target_length) // (2 * self.config.dense_bin_size)
+            features = features + self._local_features[:, first_bin:first_bin + self.config.dense_bins]
+        return features
+
+    def _all_dense_features(self, trunk: Tensor) -> Tensor:
+        features = self.dense_decoder(
+            trunk.repeat_interleave(self.config.dense_upsample, dim=1)
+        )
+        return features + self._local_features if self.config.local_width else features
+
+    def _splice_site_logits(self, trunk: Tensor) -> Tensor:
+        logits = self.splice_site_head(self._all_dense_features(trunk))
+        logits = logits.view(len(trunk), self.config.input_length, 4)
+        if self.config.local_width:
+            logits = logits + self._local_sites
+        return logits.float()
+
+    def _position_features(self, trunk: Tensor, positions: Tensor) -> Tensor:
+        features = self.dense_decoder(self._gather_bins(trunk, positions, self.config.trunk_bin_size))
+        if self.config.local_width:
+            features = features + self._gather_bins(self._local_features, positions, self.config.dense_bin_size)
+        return features
+
+    @staticmethod
+    def select_junction_positions(site_logits: Tensor, limit: int = 512) -> Tensor:
+        """Select each site type from model scores alone, then sort by coordinate.
+
+        This follows the four independent site classes in Google DeepMind's
+        AlphaGenome splicing implementation (pinned in docs/v3-author/PROTOCOL.md).  Padding is
+        -1 when an input is shorter than ``limit``.
+        """
+        count = min(limit, site_logits.shape[1])
+        selected = []
+        for site_type in range(4):
+            coordinates = torch.topk(site_logits[..., site_type], count, dim=1).indices
+            coordinates = coordinates.sort(dim=1).values
+            if count < limit:
+                coordinates = F.pad(coordinates, (0, limit - count), value=-1)
+            selected.append(coordinates)
+        return torch.stack(selected, dim=1)
+
+    @staticmethod
+    def _gather_bins(features: Tensor, positions: Tensor, bin_size: int) -> Tensor:
+        indices = torch.div(positions, bin_size, rounding_mode="floor")
+        indices = indices.clamp(0, features.shape[1] - 1)
+        return torch.gather(
+            features,
+            1,
+            indices[..., None].expand(-1, -1, features.shape[-1]),
+        )
+
+    def _junction_predictions(
+        self, trunk: Tensor, site_positions: Tensor, queries: Tensor
+    ) -> Tensor:
+        row, column, track = queries.unbind(dim=-1)
+        half = self.junction_track_half[track]
+        batch = torch.arange(len(trunk), device=trunk.device)[:, None]
+        donor = site_positions[batch, 2 * half, row]
+        acceptor = site_positions[batch, 2 * half + 1, column]
+        source = self._position_features(trunk, donor.clamp(0, self.config.input_length - 1))
+        destination = self._position_features(trunk, acceptor.clamp(0, self.config.input_length - 1))
+        interaction = self.junction_source(source) * self.junction_destination(destination)
+        track_embedding = self.junction_track(track)
+        return (interaction * track_embedding).sum(dim=-1) / math.sqrt(
+            self.config.junction_rank
+        )
+
+    def junction_block(
+        self,
+        trunk: Tensor,
+        site_positions: Tensor,
+        row_start: int,
+        row_end: int,
+        column_start: int,
+        column_end: int,
+        track_start: int,
+        track_end: int,
+        site_factors: tuple[Tensor, Tensor] | None = None,
+    ) -> Tensor:
+        """Compute a bounded block of the full predicted-position junction cube."""
+        tracks = torch.arange(track_start, track_end, device=trunk.device)
+        halves = self.junction_track_half[tracks]
+        if site_factors is None:
+            site_factors = self.junction_site_factors(trunk, site_positions)
+        source_all, destination_all = site_factors
+        source = source_all[:, halves, row_start:row_end]
+        destination = destination_all[:, halves, column_start:column_end]
+        embedding = self.junction_track(tracks)[None, :, None, None, :]
+        values = (
+            source[:, :, :, None, :] * destination[:, :, None, :, :] * embedding
+        ).sum(dim=-1) / math.sqrt(self.config.junction_rank)
+        return values.permute(0, 2, 3, 1).float()
+
+    def junction_site_factors(
+        self, trunk: Tensor, site_positions: Tensor
+    ) -> tuple[Tensor, Tensor]:
+        """Precompute the two strand-specific factors reused by all cube blocks."""
+        donor = torch.stack((site_positions[:, 0], site_positions[:, 2]), dim=1).clamp_min(0)
+        acceptor = torch.stack((site_positions[:, 1], site_positions[:, 3]), dim=1).clamp_min(0)
+        donor_features = self._position_features(trunk, donor.reshape(len(trunk), -1)).reshape(
+            len(trunk), 2, donor.shape[-1], -1)
+        acceptor_features = self._position_features(trunk, acceptor.reshape(len(trunk), -1)).reshape(
+            len(trunk), 2, acceptor.shape[-1], -1)
+        return self.junction_source(donor_features), self.junction_destination(acceptor_features)
+
+    def forward(
+        self,
+        dna: Tensor,
+        *,
+        families: Iterable[str] | None = None,
+        usage_positions: Tensor | None = None,
+        junction_site_positions: Tensor | None = None,
+        junction_queries: Tensor | None = None,
+    ) -> dict[str, Tensor]:
+        requested = set(families or ALL_FAMILIES)
+        unknown = requested - set(ALL_FAMILIES)
+        if unknown:
+            raise ValueError(f"Unknown output families: {sorted(unknown)}")
+        trunk = self._trunk(dna)
+        needs_dense = bool(
+            requested.intersection((*DENSE_TRACKS, "splice_sites", "splice_usage", "junctions"))
+        )
+        features = self._dense_features(trunk) if needs_dense else None
+        outputs: dict[str, Tensor] = {}
+        for family in DENSE_TRACKS:
+            if family in requested:
+                outputs[family] = self.dense_heads[family](features).float()
+        if "splice_sites" in requested:
+            all_logits = self._splice_site_logits(trunk)
+            start = (self.config.input_length - self.config.target_length) // 2
+            outputs["splice_sites"] = all_logits[:, start:start + self.config.target_length]
+        if "splice_usage" in requested:
+            if usage_positions is None:
+                raise ValueError("splice_usage requires usage_positions")
+            gathered = self._gather_bins(
+                features, usage_positions, self.config.dense_bin_size
+            )
+            outputs["splice_usage"] = self.splice_usage_head(gathered).float()
+        if "junctions" in requested:
+            if junction_site_positions is None or junction_queries is None:
+                raise ValueError("junctions require site positions and query triples")
+            outputs["junctions"] = self._junction_predictions(
+                trunk, junction_site_positions, junction_queries
+            ).float()
+        if "contact_maps" in requested:
+            contact = trunk.reshape(
+                len(dna), self.config.contact_bins, -1, self.config.hidden_dim
+            ).mean(dim=2)
+            q, k = self.contact_q(contact), self.contact_k(contact)
+            row, column = self.contact_row, self.contact_column
+            outputs["contact_maps"] = (
+                0.5
+                * (
+                    q[:, row] * k[:, column]
+                    + q[:, column] * k[:, row]
+                )
+            ).float()
+        return outputs
+
+
+def count_parameters(model: nn.Module) -> int:
+    return sum(parameter.numel() for parameter in model.parameters() if parameter.requires_grad)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/reference_large.yaml

@@ -0,0 +1,23 @@
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 96
+channel_growth: 96
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 1024
+num_sequence_blocks: 16
+num_attention_heads: 16
+attention_head_dim: 64
+mlp_expansion: 4.0
+dropout: 0.0
+head_hidden_size: 768
+junction_rank: 32
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: true

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/run_ddp.sh

@@ -0,0 +1,16 @@
+#!/usr/bin/env bash
+# run_ddp.sh DATA_DIR OUTPUT_DIR CONFIG EPOCHS [GPUS=8] [WORKERS_PER_GPU=12]
+# Train the reference on every train interval with one example per GPU per step, then score
+# validation with the verifier's own scorer. Runs inside the task image (torch, torchrun).
+set -Eeuo pipefail
+DATA=$1; OUT=$2; CONFIG=$3; EPOCHS=$4; GPUS=${5:-8}; WORKERS=${6:-12}
+BASELINE=$(cd "$(dirname "$0")/../.." && pwd)
+mkdir -p "$OUT"
+cd "$BASELINE"
+# Loopback rendezvous: works offline, where --standalone cannot resolve the hostname.
+torchrun --nnodes 1 --nproc-per-node "$GPUS" --master-addr 127.0.0.1 --master-port "${MASTER_PORT:-29511}" -m reference.alphagenome_50m.train_eval train \
+  --input "$DATA" --config "$CONFIG" --output "$OUT" --epochs "$EPOCHS" --workers "$WORKERS" \
+  --log-every 200 --save-every 2000 2>&1 | tee -a "$OUT/train.log"
+python predict.py "$DATA" "$OUT/valid-pred" --checkpoint "$OUT/last.pt" --split valid
+python /workspace/evaluation/score.py --predictions "$OUT/valid-pred/predictions.zarr" \
+  --labels "$DATA" --split valid --output "$OUT/valid-score"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/tiny_overfit.yaml

@@ -0,0 +1,24 @@
+# Keep the frozen 1-Mb input and every output track; shrink only learned widths.
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 8
+channel_growth: 4
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 32
+num_sequence_blocks: 1
+num_attention_heads: 2
+attention_head_dim: 16
+mlp_expansion: 2.0
+dropout: 0.0
+head_hidden_size: 32
+junction_rank: 8
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: false

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/reference/alphagenome_50m/train_eval.py

@@ -0,0 +1,534 @@
+"""Train and stream-evaluate the <=50M compact AlphaGenome baseline."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import math
+import os
+from pathlib import Path
+import time
+
+import numpy as np
+import torch
+from torch import Tensor
+from torch.nn import functional as F
+from torch.utils.data import DataLoader, Subset
+
+from .dataset import (
+    AlphaGenomeDataset,
+    DENSE_FAMILIES,
+    single_example_collate,
+)
+from .model import (
+    ALL_FAMILIES,
+    CompactModel,
+    ModelConfig,
+    count_parameters,
+)
+
+
+DEFAULT_CONFIG = Path(__file__).with_name("alphagenome_50m.yaml")
+
+
+def _device(name: str) -> torch.device:
+    if name == "auto":
+        name = "cuda" if torch.cuda.is_available() else "cpu"
+    if name == "cuda" and not torch.cuda.is_available():
+        raise RuntimeError("--device cuda requested but CUDA is unavailable")
+    return torch.device(name)
+
+
+def _autocast(device: torch.device):
+    enabled = device.type == "cuda"
+    dtype = torch.bfloat16 if enabled and torch.cuda.is_bf16_supported() else torch.float16
+    return torch.autocast(device_type=device.type, dtype=dtype, enabled=enabled)
+
+
+def _distributed() -> tuple[int, int, int]:
+    """(rank, local_rank, world_size) under torchrun; (0, 0, 1) otherwise."""
+    world = int(os.environ.get("WORLD_SIZE", "1"))
+    if world > 1 and not torch.distributed.is_initialized():
+        torch.distributed.init_process_group("nccl")
+    return int(os.environ.get("RANK", "0")), int(os.environ.get("LOCAL_RANK", "0")), world
+
+
+def _loader(dataset, *, workers: int, shuffle: bool, sampler=None) -> DataLoader:
+    return DataLoader(
+        dataset,
+        batch_size=1,
+        shuffle=shuffle and sampler is None,
+        sampler=sampler,
+        num_workers=workers,
+        persistent_workers=workers > 0,
+        pin_memory=torch.cuda.is_available(),
+        collate_fn=single_example_collate,
+    )
+
+
+def _to_device(value, device: torch.device):
+    if isinstance(value, Tensor):
+        return value.to(device, non_blocking=True)
+    if isinstance(value, dict):
+        return {key: _to_device(item, device) for key, item in value.items()}
+    return value
+
+
+def _match_coordinate_queries(
+    scoring: dict[str, Tensor], positions: Tensor, track_halves: Tensor
+) -> tuple[Tensor, Tensor, Tensor]:
+    """Match trusted coordinate queries to typed position axes like the grader."""
+    device = positions.device
+    tracks = scoring["track"]
+    halves = track_halves[tracks]
+    queries = torch.zeros((len(tracks), 3), dtype=torch.int64, device=device)
+    queries[:, 2] = tracks
+    valid = scoring["valid"].clone()
+    missing = torch.ones(len(tracks), dtype=torch.bool, device=device)
+    position_rows = positions.detach().cpu().numpy()
+    halves_cpu = halves.detach().cpu().numpy()
+    donors_cpu = scoring["donor_position"].detach().cpu().numpy()
+    acceptors_cpu = scoring["acceptor_position"].detach().cpu().numpy()
+    valid_indices = np.flatnonzero(valid.detach().cpu().numpy())
+    lookups = [
+        {int(coordinate): index for index, coordinate in enumerate(axis) if coordinate >= 0}
+        for axis in position_rows
+    ]
+    for index in valid_indices:
+        half = int(halves_cpu[index])
+        row = lookups[2 * half].get(int(donors_cpu[index]))
+        column = lookups[2 * half + 1].get(int(acceptors_cpu[index]))
+        if row is not None and column is not None:
+            queries[index, 0] = row
+            queries[index, 1] = column
+            missing[index] = False
+    return queries.unsqueeze(0), valid, missing
+
+
+def _model_inputs(sample: dict) -> tuple[dict, Tensor, Tensor]:
+    queries, query_valid, missing = _match_coordinate_queries(
+        sample["junction_scoring"],
+        sample["site_positions"],
+        sample["junction_track_halves"],
+    )
+    if (query_valid & missing).any():
+        raise ValueError("trusted scoring coordinates do not match target positions")
+    junction_target = torch.asinh(
+        sample["junction_scoring"]["target_value"]
+    ).unsqueeze(0)
+    return {
+        "dna": sample["dna"].unsqueeze(0),
+        "usage_positions": sample["usage_positions"].unsqueeze(0),
+        "junction_site_positions": sample["site_positions"].unsqueeze(0),
+        "junction_queries": queries,
+    }, junction_target, query_valid
+
+
+def _losses(outputs: dict[str, Tensor], sample: dict, junction_target: Tensor,
+            junction_valid: Tensor) -> dict[str, Tensor]:
+    losses = {}
+    for family in DENSE_FAMILIES:
+        target = torch.asinh(sample["dense"][family]["values"]).unsqueeze(0)
+        mask = sample["dense"][family]["mask"].unsqueeze(0)
+        residual = torch.where(mask, outputs[family] - target, 0.0)
+        losses[family] = residual.square().sum() / mask.sum().clamp_min(1)
+    losses["splice_sites"] = F.binary_cross_entropy_with_logits(
+        outputs["splice_sites"], sample["splice_sites"].unsqueeze(0)
+    )
+    usage_target = torch.asinh(sample["splice_usage"]["values"]).unsqueeze(0)
+    usage_mask = sample["splice_usage"]["mask"].unsqueeze(0)
+    usage_residual = torch.where(usage_mask, outputs["splice_usage"] - usage_target, 0.0)
+    losses["splice_usage"] = usage_residual.square().sum() / usage_mask.sum().clamp_min(1)
+    junction_residual = outputs["junctions"][0] - junction_target[0]
+    losses["junctions"] = (
+        junction_residual[junction_valid].square().mean()
+        if junction_valid.any() else junction_residual.sum() * 0
+    )
+    contact_target = torch.asinh(sample["contact_maps"]).unsqueeze(0)
+    contact_mask = sample["contact_map_mask"].unsqueeze(0)
+    contact_residual = torch.where(
+        contact_mask, outputs["contact_maps"] - contact_target, 0.0
+    )
+    losses["contact_maps"] = contact_residual.square().sum() / contact_mask.sum().clamp_min(1)
+    losses["total"] = torch.stack([losses[name] for name in ALL_FAMILIES]).mean()
+    return losses
+
+
+def _validation_inference(
+    model: CompactModel, sample: dict
+) -> tuple[dict[str, Tensor], Tensor, Tensor, Tensor]:
+    """Use the same predicted-position path as a formal v3 submission."""
+    trunk = model._trunk(sample["dna"].unsqueeze(0))
+    dense_features = model._dense_features(trunk)
+    outputs = {
+        family: model.dense_heads[family](dense_features).float()
+        for family in DENSE_FAMILIES
+    }
+    all_sites = model._splice_site_logits(trunk)
+    target_start = (model.config.input_length - model.config.target_length) // 2
+    outputs["splice_sites"] = all_sites[:, target_start:target_start + model.config.target_length]
+    usage_bins = model.splice_usage_head(dense_features).float()
+    usage_indices = torch.div(sample["usage_positions"], model.config.dense_bin_size,
+                              rounding_mode="floor")
+    outputs["splice_usage"] = usage_bins[:, usage_indices]
+    predicted_positions = model.select_junction_positions(all_sites)
+
+    matched, valid, missing = _match_coordinate_queries(
+        sample["junction_scoring"],
+        predicted_positions[0],
+        sample["junction_track_halves"],
+    )
+    junction_target = torch.asinh(
+        sample["junction_scoring"]["target_value"]
+    ).unsqueeze(0)
+    junction_prediction = torch.zeros(len(valid), device=valid.device)
+    if (~missing & valid).any():
+        selected = ~missing & valid
+        junction_prediction[selected] = model._junction_predictions(
+            trunk, predicted_positions, matched[:, selected]
+        )[0]
+    outputs["junctions"] = junction_prediction.unsqueeze(0)
+
+    contact = trunk.reshape(
+        1, model.config.contact_bins, -1, model.config.hidden_dim
+    ).mean(dim=2)
+    q, k = model.contact_q(contact), model.contact_k(contact)
+    row, column = model.contact_row, model.contact_column
+    outputs["contact_maps"] = (0.5 * (q[:, row] * k[:, column] + q[:, column] * k[:, row])).float()
+    return outputs, junction_target, valid, missing
+
+
+def _atomic_save(payload: dict, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    temporary = path.with_name(f".{path.name}.tmp")
+    torch.save(payload, temporary)
+    os.replace(temporary, path)
+
+
+def _sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for chunk in iter(lambda: handle.read(8 * 1024 * 1024), b""):
+            digest.update(chunk)
+    return digest.hexdigest()
+
+
+def _resume_position(payload: dict, *, examples: int, epochs: int) -> tuple[int, int]:
+    epoch = int(payload["epoch"])
+    step = int(payload["global_step"])
+    kind = payload.get("checkpoint_kind")
+    if kind not in (None, "epoch") or step != epoch * examples:
+        raise ValueError("only a completed-epoch checkpoint can resume training")
+    if payload.get("examples", examples) != examples or payload.get("schedule_epochs", epochs) != epochs:
+        raise ValueError("checkpoint data size or training schedule differs from this run")
+    return epoch, step
+
+
+def train(args: argparse.Namespace) -> None:
+    # Multi-GPU with `torchrun --nproc-per-node N train_eval.py train ...`: one example per GPU per
+    # step (data parallel), rank 0 writes checkpoints and logs. Model size is bounded by the
+    # training budget, not by a parameter cap.
+    rank, local_rank, world = _distributed()
+    config = ModelConfig.from_yaml(args.config)
+    device = torch.device("cuda", local_rank) if world > 1 else _device(args.device)
+    if world > 1:
+        torch.cuda.set_device(device)
+    torch.manual_seed(args.seed)
+    model = CompactModel(config).to(device)
+    parameters = count_parameters(model)
+    optimizer = torch.optim.AdamW(
+        model.parameters(), lr=args.learning_rate, weight_decay=args.weight_decay
+    )
+    scaler = torch.amp.GradScaler("cuda", enabled=device.type == "cuda")
+    full_dataset = AlphaGenomeDataset(args.input, "train")
+    model.set_junction_track_halves(full_dataset.junction_track_halves)
+    size = min(len(full_dataset), args.max_examples or len(full_dataset))
+    dataset = Subset(full_dataset, range(size))
+    start_epoch, global_step = 0, 0
+    if args.resume:
+        payload = torch.load(args.resume, map_location="cpu", weights_only=True)
+        if payload.get("config") != config.to_dict():
+            raise ValueError("checkpoint configuration does not match --config")
+        model.load_state_dict(payload["model"], strict=True)
+        optimizer.load_state_dict(payload["optimizer"])
+        scaler.load_state_dict(payload.get("scaler", {}))
+        start_epoch, global_step = _resume_position(payload, examples=size, epochs=args.epochs)
+    per_rank = math.ceil(size / world)
+    steps = max(1, per_rank * args.epochs)
+    module = model
+    if world > 1:
+        model = torch.nn.parallel.DistributedDataParallel(
+            model, device_ids=[local_rank], find_unused_parameters=True)
+    sampler = (torch.utils.data.distributed.DistributedSampler(dataset, num_replicas=world, rank=rank,
+                                                               shuffle=True, seed=args.seed)
+               if world > 1 else None)
+    stop_after_epoch = args.stop_after_epoch or args.epochs
+    output = args.output.resolve()
+    output.mkdir(parents=True, exist_ok=True)
+    started = time.monotonic()
+    if rank == 0:
+        print(json.dumps({"event": "train_start", "parameters": parameters, "examples": size,
+                          "device": str(device), "world_size": world}), flush=True)
+
+    for epoch in range(start_epoch, stop_after_epoch):
+        model.train()
+        if sampler is not None:
+            sampler.set_epoch(epoch)
+        loader = _loader(dataset, workers=args.workers, shuffle=True, sampler=sampler)
+        for sample in loader:
+            sample = _to_device(sample, device)
+            inputs, junction_target, junction_valid = _model_inputs(sample)
+            progress = min((global_step + 1) / steps, 1.0)
+            learning_rate = args.min_learning_rate + 0.5 * (
+                args.learning_rate - args.min_learning_rate
+            ) * (1.0 + math.cos(math.pi * progress))
+            for group in optimizer.param_groups:
+                group["lr"] = learning_rate
+            optimizer.zero_grad(set_to_none=True)
+            with _autocast(device):
+                predictions = model(**inputs)
+                losses = _losses(predictions, sample, junction_target, junction_valid)
+            if not torch.isfinite(losses["total"]):
+                raise FloatingPointError(f"non-finite loss at step {global_step}")
+            scaler.scale(losses["total"]).backward()
+            scaler.unscale_(optimizer)
+            gradient_norm = torch.nn.utils.clip_grad_norm_(model.parameters(), args.max_gradient_norm)
+            scaler.step(optimizer)
+            scaler.update()
+            global_step += 1
+            if rank == 0 and (global_step == 1 or global_step % args.log_every == 0):
+                print(
+                    json.dumps(
+                        {
+                            "event": "train_step",
+                            "epoch": epoch + 1,
+                            "step": global_step,
+                            "loss": float(losses["total"].detach()),
+                            "gradient_norm": float(gradient_norm),
+                            "learning_rate": learning_rate,
+                            "elapsed_seconds": time.monotonic() - started,
+                        }
+                    ),
+                    flush=True,
+                )
+            if rank == 0 and global_step % args.save_every == 0:
+                _atomic_save(
+                    {
+                        "schema": "alphagenome-50m-real/v3",
+                        "model": module.state_dict(),
+                        "optimizer": optimizer.state_dict(),
+                        "scaler": scaler.state_dict(),
+                        "config": config.to_dict(),
+                        "epoch": epoch,
+                        "global_step": global_step,
+                        "checkpoint_kind": "progress",
+                        "examples": size,
+                        "schedule_epochs": args.epochs,
+                    },
+                    output / "progress.pt",
+                )
+        if world > 1:
+            torch.distributed.barrier()
+        if rank != 0:
+            continue
+        _atomic_save(
+            {
+                "schema": "alphagenome-50m-real/v3",
+                "model": module.state_dict(),
+                "optimizer": optimizer.state_dict(),
+                "scaler": scaler.state_dict(),
+                "config": config.to_dict(),
+                "epoch": epoch + 1,
+                "global_step": global_step,
+                "checkpoint_kind": "epoch",
+                "examples": size,
+                "schedule_epochs": args.epochs,
+            },
+            output / "last.pt",
+        )
+    if world > 1:
+        torch.distributed.barrier()
+        torch.distributed.destroy_process_group()
+    if rank != 0:
+        return
+    checkpoint = output / "last.pt"
+    manifest = {
+        "schema": "alphagenome-50m-real/v3",
+        "checkpoint": {"path": checkpoint.name, "sha256": _sha256(checkpoint)},
+        "parameters": parameters,
+        "config": config.to_dict(),
+        "output_families": list(ALL_FAMILIES),
+        "epochs": args.epochs,
+        "completed_epochs": stop_after_epoch,
+        "global_step": global_step,
+    }
+    (output / "model_manifest.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({"event": "train_complete", **manifest}), flush=True)
+
+
+class PerTrackMoments:
+    def __init__(self, tracks: int):
+        self.n = np.zeros(tracks, dtype=np.int64)
+        self.sum_x = np.zeros(tracks, dtype=np.float64)
+        self.sum_y = np.zeros(tracks, dtype=np.float64)
+        self.sum_x2 = np.zeros(tracks, dtype=np.float64)
+        self.sum_y2 = np.zeros(tracks, dtype=np.float64)
+        self.sum_xy = np.zeros(tracks, dtype=np.float64)
+
+    def update(self, prediction: Tensor, target: Tensor, mask: Tensor | None = None) -> None:
+        x = prediction.detach().double().cpu().numpy().reshape(-1, prediction.shape[-1])
+        y = target.detach().double().cpu().numpy().reshape(-1, target.shape[-1])
+        valid = np.ones_like(y, dtype=bool) if mask is None else mask.detach().cpu().numpy().reshape(y.shape).astype(bool)
+        self.n += valid.sum(axis=0)
+        self.sum_x += np.where(valid, x, 0).sum(axis=0, dtype=np.float64)
+        self.sum_y += np.where(valid, y, 0).sum(axis=0, dtype=np.float64)
+        self.sum_x2 += np.where(valid, x * x, 0).sum(axis=0, dtype=np.float64)
+        self.sum_y2 += np.where(valid, y * y, 0).sum(axis=0, dtype=np.float64)
+        self.sum_xy += np.where(valid, x * y, 0).sum(axis=0, dtype=np.float64)
+
+    def update_indexed(self, prediction: Tensor, target: Tensor, track: Tensor) -> None:
+        x = prediction.detach().double().cpu().numpy().reshape(-1)
+        y = target.detach().double().cpu().numpy().reshape(-1)
+        indices = track.detach().cpu().numpy().reshape(-1).astype(np.int64)
+        self.n += np.bincount(indices, minlength=len(self.n))
+        self.sum_x += np.bincount(indices, weights=x, minlength=len(self.n))
+        self.sum_y += np.bincount(indices, weights=y, minlength=len(self.n))
+        self.sum_x2 += np.bincount(indices, weights=x * x, minlength=len(self.n))
+        self.sum_y2 += np.bincount(indices, weights=y * y, minlength=len(self.n))
+        self.sum_xy += np.bincount(indices, weights=x * y, minlength=len(self.n))
+
+    def report(self) -> dict:
+        numerator = self.n * self.sum_xy - self.sum_x * self.sum_y
+        denominator = np.sqrt(
+            np.maximum(self.n * self.sum_x2 - self.sum_x**2, 0)
+            * np.maximum(self.n * self.sum_y2 - self.sum_y**2, 0)
+        )
+        target_ss = np.maximum(self.n * self.sum_y2 - self.sum_y**2, 0)
+        scorable = (self.n >= 2) & (target_ss > 0)
+        pearson = np.full_like(numerator, np.nan)
+        nonconstant = scorable & (denominator > 0)
+        pearson[nonconstant] = numerator[nonconstant] / denominator[nonconstant]
+        pearson[scorable & ~nonconstant] = 0.0
+        return {
+            "mean_pearson": float(pearson[scorable].mean()) if scorable.any() else 0.0,
+            "valid_tracks": int(scorable.sum()),
+            "per_track_pearson": [float(value) if np.isfinite(value) else None for value in pearson],
+            "values_per_track": self.n.tolist(),
+        }
+
+
+def evaluate(args: argparse.Namespace) -> None:
+    device = _device(args.device)
+    payload = torch.load(args.checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config).to(device)
+    model.load_state_dict(payload["model"], strict=True)
+    model.eval()
+    full_dataset = AlphaGenomeDataset(args.input, args.split)
+    model.set_junction_track_halves(full_dataset.junction_track_halves)
+    size = min(len(full_dataset), args.max_examples or len(full_dataset))
+    dataset = Subset(full_dataset, range(size))
+    metrics = {
+        **{family: PerTrackMoments(config_value) for family, config_value in {
+            "atac": 167, "dnase": 305, "procap": 12, "cage": 546,
+            "rna_seq": 667, "chip_tf": 1617, "chip_histone": 1116,
+        }.items()},
+        "splice_sites": PerTrackMoments(4),
+        "splice_usage": PerTrackMoments(config.splice_usage_tracks),
+        "junctions": PerTrackMoments(config.junction_tracks),
+        "contact_maps": PerTrackMoments(config.contact_tracks),
+    }
+    with torch.inference_mode():
+        for index, sample in enumerate(_loader(dataset, workers=args.workers, shuffle=False)):
+            sample = _to_device(sample, device)
+            outputs, junction_target, junction_valid, junction_missing = (
+                _validation_inference(model, sample)
+            )
+            # Match predict.py: FP32 inference is serialized to FP16 Zarr values.
+            outputs = {name: value.half().float() for name, value in outputs.items()}
+            for family in DENSE_FAMILIES:
+                metrics[family].update(
+                    outputs[family][0],
+                    torch.asinh(sample["dense"][family]["values"]),
+                    sample["dense"][family]["mask"],
+                )
+            metrics["splice_sites"].update(outputs["splice_sites"][0], sample["splice_sites"])
+            metrics["splice_usage"].update(
+                outputs["splice_usage"][0],
+                torch.asinh(sample["splice_usage"]["values"]),
+                sample["splice_usage"]["mask"],
+            )
+            junction_track = sample["junction_scoring"]["track"]
+            metrics["junctions"].update_indexed(
+                outputs["junctions"][0][junction_valid],
+                junction_target[0][junction_valid],
+                junction_track[junction_valid],
+            )
+            metrics["contact_maps"].update(
+                outputs["contact_maps"][0],
+                torch.asinh(sample["contact_maps"]),
+                sample["contact_map_mask"],
+            )
+            if index == 0 or (index + 1) % args.log_every == 0 or index + 1 == size:
+                print(json.dumps({"event": "evaluate_progress", "examples": index + 1, "total": size}), flush=True)
+    families = {name: accumulator.report() for name, accumulator in metrics.items()}
+    valid_family_scores = [item["mean_pearson"] for item in families.values()]
+    report = {
+        "schema": "alphagenome-50m-evaluation/v3",
+        "split": args.split,
+        "examples": size,
+        "metric_space": (
+            "asinh continuous targets and binary splice-site targets; "
+            "junction Pearson uses hidden coordinate queries and predicted endpoints; "
+            "FP32 inference rounded to FP16 prediction values"
+        ),
+        "families": families,
+        "overall_mean_family_pearson": float(np.mean(valid_family_scores)),
+    }
+    args.report.parent.mkdir(parents=True, exist_ok=True)
+    args.report.write_text(json.dumps(report, indent=2, sort_keys=True) + "\n")
+    print(json.dumps({"event": "evaluate_complete", "overall_mean_family_pearson": report["overall_mean_family_pearson"]}), flush=True)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    common = argparse.ArgumentParser(add_help=False)
+    common.add_argument("--input", required=True, type=Path)
+    common.add_argument("--config", type=Path, default=DEFAULT_CONFIG)
+    common.add_argument("--workers", type=int, default=2)
+    common.add_argument("--max-examples", type=int, default=0)
+    common.add_argument("--device", choices=("auto", "cuda", "cpu"), default="auto")
+    common.add_argument("--log-every", type=int, default=25)
+    subparsers = parser.add_subparsers(dest="command", required=True)
+    train_parser = subparsers.add_parser("train", parents=[common])
+    train_parser.add_argument("--output", required=True, type=Path)
+    train_parser.add_argument("--epochs", type=int, default=10)
+    train_parser.add_argument("--stop-after-epoch", type=int)
+    train_parser.add_argument("--learning-rate", type=float, default=2e-4)
+    train_parser.add_argument("--min-learning-rate", type=float, default=2e-5)
+    train_parser.add_argument("--weight-decay", type=float, default=1e-4)
+    train_parser.add_argument("--max-gradient-norm", type=float, default=5.0)
+    train_parser.add_argument("--save-every", type=int, default=250)
+    train_parser.add_argument("--seed", type=int, default=17)
+    train_parser.add_argument("--resume", type=Path)
+    train_parser.set_defaults(run=train)
+    evaluate_parser = subparsers.add_parser("evaluate", parents=[common])
+    evaluate_parser.add_argument("--checkpoint", required=True, type=Path)
+    evaluate_parser.add_argument("--split", choices=("train", "valid", "test"), required=True)
+    evaluate_parser.add_argument("--report", required=True, type=Path)
+    evaluate_parser.set_defaults(run=evaluate)
+    args = parser.parse_args()
+    if args.workers < 0 or args.max_examples < 0:
+        parser.error("workers/max-examples must be nonnegative")
+    if args.command == "train" and (
+        args.epochs < 1
+        or (args.stop_after_epoch is not None
+            and not 1 <= args.stop_after_epoch <= args.epochs)
+    ):
+        parser.error("epochs must be positive and stop-after-epoch must be within the schedule")
+    args.run(args)
+
+
+if __name__ == "__main__":
+    main()

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S003/validation_variants.json

@@ -0,0 +1,125 @@
+{
+  "eqtl_sign": {
+    "rows": 17052,
+    "perturbations": 165,
+    "metric": "auroc",
+    "model": 0.4398601030917572,
+    "anchors": {
+      "AlphaGenome": 0.8263569969634328
+    }
+  },
+  "eqtl_causality": {
+    "rows": 17934,
+    "perturbations": 174,
+    "metric": "auroc",
+    "model": 0.6803609732181162,
+    "anchors": {
+      "AlphaGenome": 0.8325427468284611
+    }
+  },
+  "eqtl_coefficient": {
+    "rows": 8575,
+    "perturbations": 165,
+    "metric": "spearman",
+    "model": -0.1098670364215773,
+    "anchors": {
+      "AlphaGenome": 0.4133539365891599
+    }
+  },
+  "sqtl_causality": {
+    "rows": 21340,
+    "perturbations": 194,
+    "metric": "auprc",
+    "model": 0.6716153991373395,
+    "anchors": {
+      "AlphaGenome": 0.8447114201904594
+    }
+  },
+  "clinvar_noncoding": {
+    "rows": 199,
+    "perturbations": 199,
+    "metric": "auprc",
+    "model": 0.19618952824625902,
+    "anchors": {
+      "AlphaGenome": 0.9409857958177288
+    }
+  },
+  "clinvar_splice_region": {
+    "rows": 194,
+    "perturbations": 194,
+    "metric": "auprc",
+    "model": 0.21548331119454472,
+    "anchors": {
+      "AlphaGenome": 0.7224791623996103
+    }
+  },
+  "clinvar_missense": {
+    "rows": 199,
+    "perturbations": 199,
+    "metric": "auprc",
+    "model": 0.2709509046987323,
+    "anchors": {
+      "AlphaGenome": 0.373826292978903
+    }
+  },
+  "mfass": {
+    "rows": 195,
+    "perturbations": 195,
+    "metric": "auprc",
+    "model": 0.15220958146626407,
+    "anchors": {
+      "AlphaGenome": 0.7342557141920668
+    }
+  },
+  "caqtl": {
+    "rows": 198,
+    "perturbations": 198,
+    "metric": "auprc",
+    "model": 0.3468004299934636,
+    "anchors": {
+      "AlphaGenome": 0.8075760167741196
+    }
+  },
+  "bqtl_spi1": {
+    "rows": 160,
+    "perturbations": 160,
+    "metric": "auprc",
+    "model": 0.2618951286619208,
+    "anchors": {
+      "AlphaGenome": 0.8167450781363793
+    }
+  },
+  "enhancer_gene": {
+    "rows": 200,
+    "perturbations": 200,
+    "metric": "auprc",
+    "model": 0.4727432591017893,
+    "anchors": {
+      "AlphaGenome": 0.9594307235541584
+    }
+  },
+  "traitgym_mendelian": {
+    "rows": 292,
+    "perturbations": 292,
+    "metric": "auprc",
+    "model": 0.2523424968266569,
+    "anchors": {
+      "Borzoi_L2_L2.plus.all": 0.5026323772738239,
+      "Enformer_L2_L2.plus.all": 0.5452938267693526,
+      "CADD.plus.RawScore": 0.7189111372856957,
+      "GPN-MSA_absLLR.plus.score": 0.6729149139043132
+    }
+  },
+  "traitgym_complex": {
+    "rows": 299,
+    "perturbations": 299,
+    "metric": "auprc",
+    "model": 0.14815618473839376,
+    "anchors": {
+      "Borzoi_L2_L2.plus.all": 0.294501577162467,
+      "Enformer_L2_L2.plus.all": 0.269227301087889,
+      "CADD.plus.RawScore": 0.41341570280137435,
+      "GPN-MSA_absLLR.plus.score": 0.4213971415058371
+    }
+  }
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/README.md

@@ -0,0 +1,77 @@
+# SeqFunc local01 at step 14,000
+
+One model with **13,256,456 parameters** serves every family and both entry points. It reads the entire
+1,048,576-bp DNA window through a convolutional encoder and 6 transformer
+blocks of width 384 over 1,024 tokens. Dense heads predict 128-bp bins over the central
+196,608 bp; other heads predict splice sites, sparse usage/junctions and full-window contacts.
+A width-32 base-resolution path uses a 21-bp stem and four dilated residual depthwise blocks (701-bp receptive field). Average/max pooling provides aligned 128-bp residual features to dense, usage and junction heads. Splice logits combine local base-resolution logits with the reference offset decoder. Junction values use low-rank donor/acceptor factors; contacts use a symmetric
+product of global features. Sites and junction endpoints are selected from model scores alone.
+
+All weights originate from local random initialization (seed 17) and locally trained
+checkpoints. The global parent trained for the first 2,000 updates. The local path was attached with zero residual outputs at step 2,000, retaining every parent parameter and optimizer moment, then training continued. This is the matched control for the uniform splice-context fork.
+
+This checkpoint records **14,000 updates**, 0 complete training permutations and
+14,000 intervals into the next permutation. Each permutation includes all **41,020**
+eligible FOLD_0 training intervals (folds 2–7), shuffled deterministically without replacement.
+Quantized train targets are decoded by the supplied reader. Validation is fold 0; no test labels,
+test-derived caches or pretrained model parameters were used. Development labels only evaluate
+and select models. Checkpoints before a complete permutation remain intermediate milestones.
+
+Training uses one H100 80 GB and at most 22 CPUs. The current loader uses 6 workers
+and 2 torch CPU threads. BF16 training uses AdamW (weight decay 1e-4), gradient
+clipping at 5, and a 4-epoch cosine learning-rate schedule from
+0.0002 to 2e-05, with
+500 warmup updates. The splice objective is `balanced_splice`;
+other family losses follow the reference. Recorded accumulated training-loop wall time is
+35.3 minutes, including inherited parent time. Runs can share this
+same physical GPU with experiments or evaluation. Setup, evaluation and discarded mechanical checks
+are additional research compute, documented in the research ledger. Matching training junction queries
+uses a verified, bit-identical CPU index construction followed by a bulk GPU transfer.
+
+The package contains model code, weights, training source/configuration/provenance, SHA-256 checksums,
+and the complete CPython 3.11 / PyTorch 2.7.1 CUDA 12.6 Python runtime archive. Both executable entry
+points take INPUT_ROOT and OUTPUT_ROOT, extract the vendored runtime temporarily, and run offline.
+The host supplies Linux, bash/tar/gzip and the NVIDIA driver. Inference reads only public manifests
+and the pinned reference FASTA. No target, splice-coordinate or prediction cache is packaged or read.
+Track outputs use float16; perturbation outputs use float32 to preserve small A/B differences.
+
+The appended validation results cover all 200 intervals and all 2,697 development perturbations,
+scored by the unmodified verifier tools. Published anchors use the same label rows. All results,
+including regressions, are retained in the package's JSON reports. Limitations include incomplete
+training at intermediate checkpoints, a 701-bp local receptive field, pooled usage/junction features,
+low-rank contact modeling, and uneven variant performance. Functional readouts do not provide the
+evolutionary constraint information used by conservation-based variant scorers.
+
+## Measured validation results
+
+Family-mean Pearson: **0.255588** on 200 validation intervals.
+
+| Family | Pearson |
+|---|---:|
+| atac | 0.449029 |
+| dnase | 0.581962 |
+| procap | 0.331749 |
+| cage | 0.180663 |
+| rna_seq | 0.200977 |
+| chip_tf | 0.366987 |
+| chip_histone | 0.352559 |
+| splice_sites | 0.039608 |
+| splice_usage | 0.130403 |
+| junctions | 0.158050 |
+| contact_maps | 0.019487 |
+
+| Development evaluation | Metric | Model | Published anchors on the same rows |
+|---|---|---:|---|
+| eqtl_sign | auroc | 0.3964 | AlphaGenome: 0.8264 |
+| eqtl_causality | auroc | 0.6965 | AlphaGenome: 0.8325 |
+| eqtl_coefficient | spearman | -0.1779 | AlphaGenome: 0.4134 |
+| sqtl_causality | auprc | 0.7404 | AlphaGenome: 0.8447 |
+| clinvar_noncoding | auprc | 0.2576 | AlphaGenome: 0.9410 |
+| clinvar_splice_region | auprc | 0.2616 | AlphaGenome: 0.7225 |
+| clinvar_missense | auprc | 0.2667 | AlphaGenome: 0.3738 |
+| mfass | auprc | 0.1634 | AlphaGenome: 0.7343 |
+| caqtl | auprc | 0.2635 | AlphaGenome: 0.8076 |
+| bqtl_spi1 | auprc | 0.1972 | AlphaGenome: 0.8167 |
+| enhancer_gene | auprc | 0.5022 | AlphaGenome: 0.9594 |
+| traitgym_mendelian | auprc | 0.1633 | Borzoi_L2_L2.plus.all: 0.5026; Enformer_L2_L2.plus.all: 0.5453; CADD.plus.RawScore: 0.7189; GPN-MSA_absLLR.plus.score: 0.6729 |
+| traitgym_complex | auprc | 0.1851 | Borzoi_L2_L2.plus.all: 0.2945; Enformer_L2_L2.plus.all: 0.2692; CADD.plus.RawScore: 0.4134; GPN-MSA_absLLR.plus.score: 0.4214 |

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/attach_local.py

@@ -0,0 +1,52 @@
+"""Attach a zero-initialized local residual path to a checkpoint trained in this workspace."""
+import argparse
+from dataclasses import replace
+import hashlib
+from pathlib import Path
+
+import torch
+import yaml
+
+from reference.alphagenome_50m.model import CompactModel, ModelConfig, count_parameters
+from reference.alphagenome_50m.train_eval import _atomic_save
+
+
+def main():
+    p = argparse.ArgumentParser(description=__doc__)
+    p.add_argument('checkpoint', type=Path)
+    p.add_argument('output', type=Path)
+    p.add_argument('--width', type=int, default=32)
+    args = p.parse_args()
+    state = torch.load(args.checkpoint, map_location='cpu', weights_only=True)
+    assert state['schema'] == 'seqfunc-single/v1', 'only locally trained single-GPU checkpoints'
+    parent_config = ModelConfig(**state['config'])
+    assert parent_config.local_width == 0
+    torch.manual_seed(state['seed'])
+    parent = CompactModel(parent_config)
+    config = replace(parent_config, local_width=args.width)
+    model = CompactModel(config)
+    result = model.load_state_dict(state['model'], strict=False)
+    assert not result.unexpected_keys
+    assert all(k.startswith(('local_path.', 'local_projection.')) for k in result.missing_keys)
+    parent_names = list(dict(parent.named_parameters()))
+    names = list(dict(model.named_parameters()))
+    assert names[:len(parent_names)] == parent_names, 'optimizer parameter order changed'
+    assert len(state['optimizer']['param_groups']) == 1
+    group = state['optimizer']['param_groups'][0]
+    assert group['params'] == list(range(len(parent_names)))
+    group['params'] = list(range(len(names)))
+    state['model'] = model.state_dict()
+    state['config'] = config.to_dict()
+    state['intervention'] = {
+        'kind': 'base_resolution_local_path', 'width': args.width,
+        'parent_sha256': hashlib.sha256(args.checkpoint.read_bytes()).hexdigest(),
+        'attachment_step': state['global_step'], 'initial_outputs_unchanged': True,
+    }
+    args.output.mkdir(parents=True, exist_ok=False)
+    (args.output / 'config.yaml').write_text(yaml.safe_dump(config.to_dict()))
+    _atomic_save(state, args.output / 'attached.pt')
+    print({'parameters': count_parameters(model), **state['intervention']})
+
+
+if __name__ == '__main__':
+    main()

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/infer.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: infer.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/predict.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/package_manifest.json

@@ -0,0 +1,30 @@
+{
+  "parameters": 13256456,
+  "source_checkpoint_sha256": "af8060229a79fbcb3e5ce34ee559af3724268ea7dc8e321bd12ce9d5f2d27e3a",
+  "files": {
+    "README.md": "101f591999fec21fdb5f09cabdab1e58f3d50ac366bc30458b67c4ce27c6b5f2",
+    "attach_local.py": "d0774e2711840783267914789ed303a3b61b64381b72d61f0886edbc04974f15",
+    "infer.sh": "ef810532b1e72b85fbe283e4f52c177bb70025977dbb2345d75837c9bbd51e37",
+    "last.pt": "fdef062e6c8de5ac6f73c764d638d6cd994fd001370628e19bf4365db4d57d86",
+    "perturb.py": "ba37a6f9f8b8eccb052903618bcb4c91d3f4cbed62dfe678ee362644dc80801e",
+    "perturb.sh": "113ec2383276a6e83fe1e4e8b0fa914f8d535d5dd0f5b2c34240140312dd5fb4",
+    "predict.py": "2725592456c55c188b22c376f0cb249e9f46b4ae1370d2226df7143da358a8b2",
+    "prediction_contract.py": "b11af8f7cff82b35afc6282be387358a48464b78bd1dfa44452dace26a5e0a83",
+    "reference/__init__.py": "45f3cf93f48859104e70bb58d717130dfd6521a45d2aba06b1a726afc0dc51dd",
+    "reference/alphagenome_50m/__init__.py": "a5a7e45d5940c3b201017c6322128e9f47efd37e1d29f717da2c1f787688eff9",
+    "reference/alphagenome_50m/alphagenome_50m.yaml": "3cac32e9f55e352dff78bb85ac892fdae1f9e412d9bba3e945750210c5252eee",
+    "reference/alphagenome_50m/dataset.py": "ad6670f742f4de9898064becc525d0aea98b402abe7b210bb1b26a9eee6402b9",
+    "reference/alphagenome_50m/layers.py": "26a116a72aa3f0e307a3606163547edbdecb7965f7fdcd96bc5f805cd21b3352",
+    "reference/alphagenome_50m/model.py": "2871dc8893879c3e14a526dea659701d72c8c4d0e2f835b0bfb857034a2c2e6d",
+    "reference/alphagenome_50m/reference_large.yaml": "68084d299b39418034c6bbf71db174c3ffa68bbeea8779c1694e44ec71f3529c",
+    "reference/alphagenome_50m/run_ddp.sh": "96d35a24a4e6789311501fb98203807ac0c4429375c44d5c6671908270c93bb0",
+    "reference/alphagenome_50m/tiny_overfit.yaml": "f7a104c3929de0530a9a8f73f66d794cca595aefad8ef262e09ecbeb9cfce6de",
+    "reference/alphagenome_50m/train_eval.py": "95d2dad279b23ed9c0c8a4f070035cf53c27eb8fe27da64c441343717174f784",
+    "runtime.tar.gz": "718da4c374e0c552b6e429b226c90b2fded5c900d95577d190d4df520aaf3901",
+    "train_single.py": "a6653431e850d448c414f48cc65cbaaec8c17a430c08376b281441a6f6bce987",
+    "training_config.yaml": "deab298b32f0aef33e66ddf538541ec470eee0c05a6ebc983684f2575287d791",
+    "training_provenance.json": "1a721e47432865cf50c2ff1a14ac3cc97b2926da28dff75023e7d008c55a9793",
+    "validation_tracks.json": "c8a25d419cc2df7c7d834d49d89cf7fe9f2975374c0048dca7035b0c20dc4420",
+    "validation_variants.json": "41cd2d3e0548c520def53c102fbb8e99c5c7c473d807d62b0d5bc0376f7adbd4"
+  }
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/perturb.py

@@ -0,0 +1,101 @@
+"""Predict both sequences of every perturbation (contract: perturbations/v1).
+
+    python perturb.py INPUT_ROOT OUTPUT_ROOT --checkpoint last.pt
+
+INPUT_ROOT holds `public/perturbations.parquet` and `reference/GRCh38.p13.genome.fa` (in the
+workspace, `/workspace/data` works too: the queries are then read from `variant_evals/public/`). Each row is a
+1,048,576-bp window starting at `input_start` and an edit spanning [edit_start, edit_end) in genomic
+0-based coordinates:
+
+- `snv`: sequence A carries `allele_a` at edit_start, sequence B carries `allele_b` (both are written
+  explicitly; either may differ from the reference genome);
+- `mask`: sequence A is the reference, sequence B has the interval replaced by N.
+
+For each perturbation the output group `perturbations/p{index:06d}` holds `a/<family>` and
+`b/<family>` for every family in `families`: dense families sliced to bins
+[dense_bin_start, dense_bin_end) of the central target window, and `splice_sites` sliced to bp
+[splice_start, splice_end). Values are the same quantities as predictions.zarr (asinh space for
+dense tracks, splice-site scores for splice_sites).
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import pandas as pd
+import pysam
+import torch
+import zarr
+
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+PERTURBATION_SCHEMA = "genome-sequence-to-function-perturbations/v1"
+COMPRESSOR = Blosc(cname="zstd", clevel=3, shuffle=Blosc.BITSHUFFLE)
+
+
+def sequences(fasta, row) -> tuple[str, str]:
+    length = fasta.get_reference_length(row.chrom)
+    start, end = int(row.input_start), int(row.input_start) + 1_048_576
+    sequence = fasta.fetch(row.chrom, max(0, start), min(length, end)).upper()
+    sequence = "N" * max(0, -start) + sequence + "N" * max(0, end - length)
+    lo, hi = int(row.edit_start) - start, int(row.edit_end) - start
+    if row.edit == "snv":
+        return sequence[:lo] + row.allele_a + sequence[hi:], sequence[:lo] + row.allele_b + sequence[hi:]
+    if row.edit == "mask":
+        return sequence, sequence[:lo] + "N" * (hi - lo) + sequence[hi:]
+    raise ValueError(f"unknown edit {row.edit!r}")
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, queries: Path | None = None) -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    if queries is None:
+        queries = input_root / "public/perturbations.parquet"
+        if not queries.exists():
+            queries = input_root / "variant_evals/public/perturbations.parquet"
+    rows = pd.read_parquet(queries)
+    fasta = pysam.FastaFile(str(input_root / "reference/GRCh38.p13.genome.fa"))
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "perturbations.zarr"), mode="w")
+    target_start = (config.input_length - config.target_length) // 2
+    with torch.inference_mode():
+        for index, row in enumerate(rows.itertuples(index=False)):
+            pair = sequences(fasta, row)
+            dna = torch.from_numpy(np.stack([AlphaGenomeDataset._one_hot(s) for s in pair])).to(device)
+            trunk = model._trunk(dna)
+            group = root.create_group(f"perturbations/p{index:06d}")
+            features = None
+            for family in row.families:
+                if family == "splice_sites":
+                    logits = model._splice_site_logits(trunk)[:, target_start:target_start + config.target_length]
+                    values = logits[:, row.splice_start:row.splice_end]
+                else:
+                    features = model._dense_features(trunk) if features is None else features
+                    values = model.dense_heads[family](features)[:, row.dense_bin_start:row.dense_bin_end]
+                # float32: one variant's effect is often below float16 resolution (about 0.004 at
+                # asinh values of 4-8), so A and B would round to the same numbers.
+                values = values.float().cpu().numpy()
+                for side, array in zip("ab", values):
+                    group.create_dataset(f"{side}/{family}", data=array, compressor=COMPRESSOR)
+            print(json.dumps({"event": "perturb", "done": index + 1, "total": len(rows)}), flush=True)
+    root.attrs.update({"schema": PERTURBATION_SCHEMA,
+                       "perturbation_ids": rows.perturbation_id.astype(str).tolist()})
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description=__doc__.split("\n\n")[0])
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--queries", type=Path, help="another query table, e.g. the development split")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.queries)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/perturb.sh

@@ -0,0 +1,12 @@
+#!/usr/bin/env bash
+set -euo pipefail
+[[ $# == 2 ]] || { echo "usage: perturb.sh INPUT_ROOT OUTPUT_ROOT" >&2; exit 2; }
+package_dir=$(cd "$(dirname "$0")" && pwd)
+runtime_dir=$(mktemp -d "${TMPDIR:-/tmp}/seqfunc-runtime.XXXXXXXX")
+trap 'rm -rf "$runtime_dir"' EXIT
+tar -xzf "$package_dir/runtime.tar.gz" -C "$runtime_dir"
+unset PYTHONPATH
+export PYTHONHOME="$runtime_dir" PYTHONNOUSERSITE=1 PYTHONDONTWRITEBYTECODE=1
+export LD_LIBRARY_PATH="$runtime_dir/lib${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
+export OMP_NUM_THREADS=4 MKL_NUM_THREADS=4 OPENBLAS_NUM_THREADS=1 NUMEXPR_NUM_THREADS=4
+"$runtime_dir/bin/python" -s "$package_dir/perturb.py" "$1" "$2" --checkpoint "$package_dir/last.pt"

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/predict.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+"""Stream the single benchmark model into the sharded prediction contract."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from numcodecs import Blosc
+import numpy as np
+import torch
+import zarr
+
+from prediction_contract import DENSE_TRACKS, MAX_JUNCTION_PAIRS, MAX_USAGE_SITES, PREDICTION_SCHEMA
+from reference.alphagenome_50m.dataset import AlphaGenomeDataset
+from reference.alphagenome_50m.model import CompactModel, ModelConfig
+
+
+COMPRESSOR = Blosc(cname="zstd", clevel=7, shuffle=Blosc.BITSHUFFLE)
+
+
+def main(input_root: Path, output_root: Path, checkpoint: Path, split: str = "test") -> None:
+    payload = torch.load(checkpoint, map_location="cpu", weights_only=True)
+    config = ModelConfig(**payload["config"])
+    model = CompactModel(config)
+    model.load_state_dict(payload["model"], strict=True)
+    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+    model.to(device).eval()
+    dataset = AlphaGenomeDataset(input_root, split, include_targets=False)
+    model.set_junction_track_halves(dataset.junction_track_halves)
+    output_root.mkdir(parents=True, exist_ok=True)
+    root = zarr.open_group(str(output_root / "predictions.zarr"), mode="w")
+    ids = []
+    with torch.inference_mode():
+        for sample in dataset:
+            example_id = sample["example_id"]
+            dna = sample["dna"][None].to(device)
+            trunk = model._trunk(dna)
+            dense_features = model._dense_features(trunk)
+            group = root.create_group(f"examples/{example_id}")
+            for family in DENSE_TRACKS:
+                values = model.dense_heads[family](dense_features)[0]
+                group.create_dataset(family, data=values.cpu().numpy().astype(np.float16), compressor=COMPRESSOR)
+
+            all_site_logits = model._splice_site_logits(trunk)
+            target_start = (config.input_length - config.target_length) // 2
+            group.create_dataset(
+                "splice_sites",
+                data=all_site_logits[0, target_start:target_start + config.target_length].cpu().numpy().astype(np.float16),
+                chunks=(4096, 4), compressor=COMPRESSOR,
+            )
+            predicted_positions = model.select_junction_positions(all_site_logits)[0]
+
+            # Usage at the model's own predicted sites (v4 is sparse; unlisted hidden sites score 0).
+            usage_bins = model.splice_usage_head(dense_features)[0].float()
+            sites = predicted_positions.cpu().numpy().astype(np.int64).reshape(-1)
+            sites = np.unique(sites[(sites >= target_start) & (sites < target_start + config.target_length)]
+                              - target_start)[:MAX_USAGE_SITES]
+            group.create_dataset("splice_usage_positions", data=sites.astype(np.int32), compressor=COMPRESSOR)
+            usage = usage_bins[torch.as_tensor(sites // 128, device=usage_bins.device)] if len(sites) \
+                else usage_bins[:0]
+            group.create_dataset("splice_usage", data=usage.cpu().numpy().astype(np.float16),
+                                 chunks=(1024, 734), compressor=COMPRESSOR)
+
+            # Junctions: score every donor x acceptor pair of each strand, keep the strongest pairs.
+            positions_batch = predicted_positions[None]
+            site_factors = model.junction_site_factors(trunk, positions_batch)
+            halves = model.junction_track_half
+            candidates = []
+            for row_start in range(0, 512, 128):
+                for column_start in range(0, 512, 128):
+                    block = torch.cat([
+                        model.junction_block(
+                            trunk, positions_batch, row_start, row_start + 128,
+                            column_start, column_start + 128, track_start,
+                            min(track_start + 64, config.junction_tracks), site_factors,
+                        )[0]
+                        for track_start in range(0, config.junction_tracks, 64)
+                    ], dim=-1).float()  # [128, 128, 734]
+                    for half in (0, 1):
+                        donors = predicted_positions[2 * half, row_start:row_start + 128]
+                        acceptors = predicted_positions[2 * half + 1, column_start:column_start + 128]
+                        valid = (donors[:, None] >= 0) & (acceptors[None, :] >= 0)
+                        strength = block[..., halves == half].amax(dim=-1).masked_fill(~valid, -torch.inf)
+                        keep = min(MAX_JUNCTION_PAIRS // 2, int(valid.sum()))
+                        if not keep:
+                            continue
+                        best = strength.flatten().topk(keep)
+                        rows, columns = best.indices // 128, best.indices % 128
+                        candidates.append((best.values, torch.full_like(rows, half), donors[rows],
+                                           acceptors[columns], block[rows, columns]))
+            if candidates:
+                score, half, donor, acceptor, values = (torch.cat(x) for x in zip(*candidates))
+                order = score.topk(min(MAX_JUNCTION_PAIRS, len(score))).indices
+                half, donor, acceptor, values = half[order], donor[order], acceptor[order], values[order]
+            else:
+                half = donor = acceptor = torch.zeros(0, dtype=torch.long)
+                values = torch.zeros(0, config.junction_tracks)
+            group.create_dataset("junction_half", data=half.cpu().numpy().astype(np.int8), compressor=COMPRESSOR)
+            group.create_dataset("junction_donor", data=donor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junction_acceptor", data=acceptor.cpu().numpy().astype(np.int32), compressor=COMPRESSOR)
+            group.create_dataset("junctions", data=values.cpu().numpy().astype(np.float16),
+                                 chunks=(4096, 734), compressor=COMPRESSOR)
+
+            contact = trunk.reshape(
+                1, config.contact_bins, -1, config.hidden_dim
+            ).mean(dim=2)
+            q, k = model.contact_q(contact), model.contact_k(contact)
+            row, column = model.contact_row, model.contact_column
+            contact_values = 0.5 * (q[:, row] * k[:, column] + q[:, column] * k[:, row])
+            group.create_dataset(
+                "contact_maps", data=contact_values[0].cpu().numpy().astype(np.float16),
+                chunks=(8192, 28), compressor=COMPRESSOR,
+            )
+            ids.append(example_id)
+            print(json.dumps({"event": "predict", "example": len(ids), "total": len(dataset)}), flush=True)
+    root.attrs.update({"schema": PREDICTION_SCHEMA, "example_ids": ids})
+    (output_root / "example_ids.json").write_text(json.dumps(ids) + "\n")
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser()
+    parser.add_argument("input_root", type=Path)
+    parser.add_argument("output_root", type=Path)
+    parser.add_argument("--checkpoint", type=Path, default=Path(__file__).resolve().parent / "last.pt")
+    parser.add_argument("--split", default="test", choices=("valid", "test"),
+                        help="manifest to predict; the verifier uses test, local validation uses valid")
+    args = parser.parse_args()
+    main(args.input_root, args.output_root, args.checkpoint, args.split)

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/prediction_contract.py

@@ -0,0 +1,23 @@
+"""Public prediction shapes; no trusted splice coordinates are exposed."""
+
+from __future__ import annotations
+
+DENSE_TRACKS = {
+    "atac": 167,
+    "dnase": 305,
+    "procap": 12,
+    "cage": 546,
+    "rna_seq": 667,
+    "chip_tf": 1_617,
+    "chip_histone": 1_116,
+}
+
+PREDICTION_SCHEMA = "genome-sequence-to-function-predictions/v4"
+MAX_USAGE_SITES = 4_096
+MAX_JUNCTION_PAIRS = 16_384
+# Fixed-shape arrays per example; splice usage and junctions are sparse (see contract.md).
+FIXED_SHAPES = {
+    **{name: (1_536, tracks) for name, tracks in DENSE_TRACKS.items()},
+    "splice_sites": (196_608, 4),
+    "contact_maps": (131_328, 28),
+}

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/reference/__init__.py

@@ -0,0 +1 @@
+"""The reference model of the alphagenome-reference baseline."""

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/reference/alphagenome_50m/__init__.py

@@ -0,0 +1,5 @@
+"""Compact 1-Mb, eleven-family AlphaGenome reference model."""
+
+from .model import CompactModel, ModelConfig, count_parameters
+
+__all__ = ["CompactModel", "ModelConfig", "count_parameters"]

tasks/genome-sequence-to-function/genome-sequence-to-function-astra-xhigh-1h100-48h-20261022a/submissions/S004/reference/alphagenome_50m/alphagenome_50m.yaml

@@ -0,0 +1,23 @@
+input_length: 1048576
+target_length: 196608
+dense_bin_size: 128
+trunk_bin_size: 1024
+contact_bin_size: 2048
+stem_stride: 8
+encoder_width: 32
+channel_growth: 32
+num_downsampling_blocks: 7
+conv_kernel_size: 5
+dna_kernel_size: 15
+hidden_dim: 384
+num_sequence_blocks: 6
+num_attention_heads: 6
+attention_head_dim: 64
+mlp_expansion: 4.0
+dropout: 0.0
+head_hidden_size: 256
+junction_rank: 32
+splice_usage_tracks: 734
+junction_tracks: 734
+contact_tracks: 28
+gradient_checkpointing: true