Raw sequences and GO labels are pulled from AmelieSchreiber/cafa_5 (public mirror of the CAFA5 challenge files: train_sequences.fasta, train_terms.tsv, testsuperset.fasta, testsuperset-taxon-list.tsv, IA.txt, go-basic.obo). Per-protein metadata (protein_names, protein_function, organism, subcellular_location) is fetched from the UniProt REST API via the /accessions batch endpoint. The test split's protein_function field is rewound to the 2023-01 SwissProt snapshot (parsed from uniprot_sprot.xml) to remove any post-CAFA5 leakage, and PubMed citations are stripped.

Configs

`cafa5_reasoning`

train: 132,791 rows
test: 141,798 rows
Columns: protein_id, protein_names, protein_function, organism, length, subcellular_location, sequence, go_ids, go_bp, go_mf, go_cc

`go_metadata`

43,248 rows
Columns: go_id, go_name, go_def, go_aspect, go_depth, go_weight
go_weight is the CAFA5 information-accretion (IA) score; go_depth is the shortest-path depth in go-basic.obo.

Usage

from datasets import load_dataset

ds = load_dataset("emngarcia/cafa5", "cafa5_reasoning")
go = load_dataset("emngarcia/cafa5", "go_metadata", split="train")

Methodology and design choices

This section documents the decisions that produced this dataset and the modality-ablation experiments shipped alongside it under ablations/.

Why this dataset exists

BioReason-Pro's training and evaluation pipelines default to wanglab/cafa5. That repo is a gated dataset on Hugging Face — downloads require manual approval from the wanglab maintainers, and our access request returned the "awaiting review" status for an extended period. To unblock the project, we rebuilt the pieces of wanglab/cafa5 we actually need from public inputs and published them here.

Dataset build: choices and trade-offs

Raw source. Pulled from public AmelieSchreiber/cafa_5 because it contains the exact CAFA5 challenge files (train_sequences.fasta, train_terms.tsv, testsuperset.fasta, testsuperset-taxon-list.tsv, IA.txt, go-basic.obo) with no gating.
UniProt metadata fetch. The first implementation used 500-accession OR-joined queries against the UniProt search endpoint and hit HTTP 400. Replaced with the /accessions batch endpoint (comma-separated, batch size 200) with skip-if-exists guards so the long fetch is resumable. This covers all ~140k train + ~141k test accessions.
Temporal leakage fix for the test split. UniProt's current entries may have protein_function text written after the CAFA5 challenge closed, so a model trained on UniProt-derived prompts could see future knowledge at eval time. We re-parsed uniprot_sprot.xml (the 2023-01 SwissProt snapshot, 7.1 GB extracted, ~569k entries) and rewound protein_function for the test split to its 2023-01 form. The pure-Python parser replaces an earlier seqkit shell-out so the pipeline doesn't depend on shelling out.
PubMed citation cleanup. Function descriptions in UniProt carry (PubMed:N) and (PMID:N) markers that bias the model toward citation patterns. Stripped in cells 96–108.
GO term metadata. go_depth is computed by shortest-path traversal in go-basic.obo; go_weight is the official CAFA5 IA (information accretion) score taken straight from IA.txt.
Storage. We initially tried push_to_hub("wanglab/cafa5", ...) (writes were 403; that token has no write access there anyway). We pivoted to local parquet files at _local_dataset/ and then pushed here from a write-scoped token.

Configs we did not publish (yet)

wanglab/cafa5 ships dozens of derived configs (interlabel_test_dataset_with_gogpt_memorized_copy, interpro_metadata, ppi_metadata, structures_*, temporal_holdout_*, …). This release only contains the two raw-ish configs that the project depends on for ablations:

cafa5_reasoning — the joined CAFA5 + UniProt-metadata table
go_metadata — per-term GO definitions, aspects, depth, IA weight

Downstream notebooks 002 … 021 in BioReason-Pro/data/ build the remaining configs (PPI, InterPro features, the InterLabel test set, GoGPT-augmented prompts, temporal holdouts). Those still reference wanglab/cafa5 for inputs and have not been retargeted.

Ablation pipeline adaptations

The eval entry point — ablations/eval_cafa5.py — was originally written to consume wanglab/cafa5's curated interlabel_test_dataset_with_gogpt_memorized_copy config (chat-template prompts pre-assembled, plus GoGPT predictions in go_pred and InterPro features). That config is not in this repo. We adapted instead of reproducing it.

Bypass load_cafa5_dataset for this dataset. Added ablations/dataset_adapter.py::load_emngarcia_cafa5_eval. When --cafa5_dataset emngarcia/cafa5 is passed, eval_cafa5 calls the adapter directly and the heavy multi-config loader is skipped.
Prompt template choice. Selected CAFA5_REASONING_TEMPLATE (the simplest of the available templates: no InterPro, no PPI, no GoGPT hint, no UniProt summary). The richer templates require fields this dataset does not carry.
Sample shape per row. One sample per protein, asking about all three GO aspects at once (go_aspect="all", split_go_aspects=False). Each row carries the protein/go_graph special-token slots that the model's process_protein_embeddings and process_go_aspects will scatter encoder outputs into.
Ground-truth caveat. The CAFA5 challenge test split has no public ground-truth GO terms — that is the whole point of CAFA. The go_bp, go_mf, go_cc columns on the test rows of this dataset are placeholder ["None"] lists, mirroring the original. The adapter builds an assistant message containing "MF: None\nBP: None\nCC: None" so downstream code that reads from sample["prompt"] doesn't crash, but F-max scoring against ground truth is not meaningful for these rows.

Modality-ablation method

Four ablation modes are implemented in ablations/ablation.py. Each one wraps the model's encoder-output methods (process_protein_embeddings, process_go_aspects) with a hook that transforms the projected per-batch-item tensors after the encoder runs but before the LLM scatters them into input embeddings at modality-pad-token positions.

mode	what the hook does
`full`	passthrough (sanity baseline)
`protein_zero`	replace projected protein embeddings with zeros of identical shape/dtype/device
`protein_noise`	replace with Gaussian noise matched to the real embeddings' per-tensor mean/std
`go_zero`	replace projected GO embeddings with zeros

Bugs fixed during the run:

The noise generator was created with device="cpu" but the projected encoder outputs live on CUDA, so protein_noise failed every sample with "Expected a 'cuda' device type for generator but found 'cpu'". Fixed in ablations/ablation.py by lazily re-creating the generator on the tensor's device the first time the hook fires.

Scoring choice

Because the test split has no public ground truth, F-max is not computable for this evaluation. Instead ablations/analyze_results.py treats each ablation as a perturbation of the baseline (full) and reports, per protein:

jaccard(full_preds, ablated_preds) — overlap of predicted GO sets
recall_of_full — fraction of the baseline's predicted terms that survive the ablation
size_ratio — |ablated_preds| / |full_preds|

Means across proteins are reported in ablations/cross_config_summary.json.

Results (N=30, max_new_tokens=512, A100 80GB)

config	jaccard vs full	recall of full	preds / protein
`full` (baseline)	1.000	—	1.70
`protein_zero`	0.208	0.251	1.30
`protein_noise`	0.220	0.311	2.73
`go_zero`	0.209	0.293	2.27

Both modalities are load-bearing: any single-modality ablation drops the predicted-set overlap with the baseline to ~21%. The direction of the distortion differs — protein_zero makes the model under-predict, while protein_noise and go_zero make it over-predict. Sample size is small (N=30), so these numbers are best read as a sanity check that the ablation hooks fire correctly and modality-removal has the expected qualitative effect, not as a precise quantification.

`ablations/` directory layout (round 1, N=30, no GT)

ablations/
├── full/<protein_id>_all_k00.json         # 30 records per config
├── protein_zero/<...>.json
├── protein_noise/<...>.json
├── go_zero/<...>.json
├── run_full_protein_zero_go_zero.json     # original 3-config run summary
├── run_protein_noise.json                 # protein_noise rerun summary (after the CUDA-generator fix)
└── cross_config_summary.json              # per-config Jaccard / recall / size-ratio means

Round 2: ablation with ground truth (N=100, train split)

The round-1 results above are a sanity-check baseline — the test split has no public ground truth, so we could only measure deviation from baseline, not correctness. Round 2 swaps the test split for the train split (cafa5_reasoning/train, which has real go_bp/go_mf/go_cc lists), adds a protein_zero_go_zero "text-only floor" control, and scores precision/recall/F1 per GO aspect.

Caveat: the BioReason-Pro RL checkpoint was trained on these proteins. The full baseline is therefore near-ceiling, and absolute numbers should not be read as held-out performance. The relative degradation across ablation configs is what's interpretable.

Round 2 setup

Split: cafa5_reasoning/train, filtered to rows with at least one non-empty go_bp/mf/cc list (--require_ground_truth true)
N=100, seed=23
Configs: full, protein_zero, protein_noise, go_zero, protein_zero_go_zero
--max_new_tokens 1000, --gpu_memory_utilization 0.6 (the first attempt at 1500 / 0.7 OOM'd; tightening both fixed it)
A100 80GB, ~15h total runtime (ablated configs run 2–5× slower than full because the model hedges and generates longer responses)

Round 2 results: overall precision / recall / F1 (N=100)

Predicted GO terms are extracted from the generated response with the regex GO:\d{7}. Each is compared against the union of go_bp ∪ go_mf ∪ go_cc ground-truth terms for the protein. Metrics are micro-averaged (pooled across proteins).

config	precision	recall	F1	jaccard vs full	preds / protein
`full` (baseline)	0.245	0.010	0.018	1.000	2.00
`go_zero`	0.196	0.007	0.014	0.281	1.94
`protein_noise`	0.158	0.007	0.014	0.196	2.28
`protein_zero`	0.118	0.004	0.007	0.250	1.61
`protein_zero_go_zero`	0.126	0.004	0.008	0.223	1.75

Recall is universally tiny because the model predicts ~2 terms per protein while ground truth has ~50 terms per protein. The model isn't asked to enumerate, so this is more a property of the prompt template than of the modality. Precision is the meaningful axis here.

Round 2 results: per-aspect precision

GO terms are bucketed into MF / BP / CC using go-basic.obo namespaces.

	MF	BP	CC
`full`	0.433	0.129	0.176
`go_zero`	0.377	0.036	0.145
`protein_noise`	0.278	0.053	0.154
`protein_zero`	0.109	0.050	0.196
`protein_zero_go_zero`	0.143	0.032	0.226

What the round-2 numbers say

Protein encoder is the primary driver of accuracy. protein_zero drops overall precision by 52% (0.245 → 0.118); go_zero drops it by 20% (0.245 → 0.196). Protein matters about 2.6× more than GO for the prediction precision in this setup.
The GO encoder contributes nothing once protein is dead. protein_zero_go_zero (0.126) is statistically indistinguishable from protein_zero alone (0.118). Either GO embeddings are downstream of protein embeddings (the GO encoder's contribution requires a meaningful protein representation to condition on), or the GO encoder is doing a small enough amount of work that protein-encoder noise dominates. The fact that add-on contribution of GO disappears when protein is ablated is the strongest architectural finding of this experiment.
Molecular function is protein-shaped. MF precision falls 75% under protein_zero (0.433 → 0.109) but only 13% under go_zero (0.433 → 0.377). MF is the aspect closest to sequence — catalytic sites, binding pockets, enzymatic activity — and the model picks these up from the protein encoder.
Biological process is GO-shaped. BP precision falls 72% under go_zero (0.129 → 0.036) and 61% under protein_zero (0.129 → 0.050). BP is ontological reasoning over pathways and processes, exactly what the GO graph encoder is designed for.
Cellular component is modality-robust. CC precision stays in 0.145 – 0.226 across all five configs and is not consistently damaged by any single ablation. The most likely explanation is that CC information leaks from the text prompt: organism name + protein name + the prior the LLM acquired from pretraining are enough to guess "this is probably nuclear / cytoplasmic / membrane-bound." This is the kind of shortcut the ablation framework was designed to surface.
Noise > zero on precision. protein_noise (0.158) is consistently better than protein_zero (0.118). Stat-matched Gaussian noise preserves some of the protein embedding's moments, and the model evidently uses at least some of that low-frequency information.

Answers to the originally-open questions

Question	Round 2 answer
Does the ablation hurt accuracy?	Yes. All four ablations drop precision; the strongest hit is from `protein_zero` (−52%).
Which modality matters more?	Protein, by ~2.6×. Removing protein hurts precision more than removing GO.
Is the model shortcutting from text alone?	For CC, yes. Cellular-component predictions barely change across ablations, suggesting the text prompt (organism + protein name) carries most of that signal. For MF and BP the modalities are doing real work.
Per-aspect breakdown?	MF is protein-driven, BP is GO-driven, CC is text-driven.
Does the framework actually work?	Yes. Hook installation, encoder-output transformation, and the noise/zero/swap modes all execute without errors across N=500 inference calls (100 proteins × 5 configs).

Caveats and what's still open

Train leakage. All 100 proteins are in the model's training set. The full baseline is near-ceiling; the relative gaps are real but absolute precision is inflated. A held-out evaluation against a 2024+ SwissProt set (the project has data/018-temporal-holdout-ext.ipynb for this) would test whether the per-aspect pattern holds out of domain.
One prompt template. Everything here uses CAFA5_REASONING_TEMPLATE (no InterPro, no PPI, no GoGPT hints, no UniProt summary). Richer prompts may shift the protein-vs-GO balance — the GO encoder might do more work when the prompt already supplies some GO speculations.
Low recall is a prompt artifact, not a model property. The model is not asked to enumerate exhaustively; F-max under a multi-threshold CAFA-style protocol would change the numbers.

Round 2 directory layout

ablations_v2/
├── full/<protein_id>_all_k00.json         # 100 records per config
├── protein_zero/<...>.json
├── protein_noise/<...>.json
├── go_zero/<...>.json
├── protein_zero_go_zero/<...>.json
├── run_summary.json                       # CLI args + per-config processed/error counts
└── cross_config_summary.json              # the per-config / per-aspect numbers tabled above

Each per-protein record additionally carries go_mf, go_bp, go_cc ground-truth lists (not present in the round-1 records), which is what makes the round-2 accuracy metrics possible.

Round 3: temporal holdout (N=100, 2025+ SwissProt)

Round 2 ran on training-set proteins, so the full baseline was near-ceiling and the ablation drops we measured could be a mix of "real modality reliance" and "the encoders memorized these proteins, and breaking them reveals memorization loss." Round 3 fixes this with an out-of-distribution split: reviewed SwissProt entries that were created on or after 2025-01-01, which is after every plausible training cutoff for the BioReason-Pro RL checkpoint, its base model (Qwen3), and its protein encoder (ESM3).

Round 3 setup

Built temporal_holdout_2025 config on this dataset by querying the UniProt REST API for (reviewed:true) AND (date_created:[2025-01-01 TO *]) AND (go:*). Resulting 1,784 entries published under temporal_holdout_2025/test.parquet.
Per protein in the holdout, ground truth is ~5 GO terms (1.57 BP + 1.86 MF + 1.24 CC on average) — versus ~50 on train. Newly curated proteins have fewer annotations.
Same 5 ablation configs, same N=100, same --max_new_tokens 1000, same --gpu_memory_utilization 0.6. Total runtime 13.9h.

Round 3 results: overall

config	precision	recall	F1	jaccard vs full	preds / protein
`full` (baseline)	0.088	0.030	0.045	1.000	1.70
`go_zero`	0.059	0.020	0.030	0.275	1.70
`protein_noise`	0.056	0.024	0.034	0.177	2.16
`protein_zero`	0.031	0.012	0.017	0.217	1.96
`protein_zero_go_zero`	0.035	0.014	0.020	0.194	2.00

full precision drops from 0.245 (train) to 0.088 (holdout) — about a 2.8× memorization premium on the training set, confirming the train-leakage caveat we flagged in round 2.

Round 3 results: per-aspect precision (the key chart)

	MF	BP	CC
`full`	0.000	0.039	0.232
`go_zero`	0.000	0.000	0.175
`protein_noise`	0.027	0.000	0.152
`protein_zero`	0.000	0.000	0.100
`protein_zero_go_zero`	0.000	0.000	0.113

Side-by-side with train:

aspect	train `full`	holdout `full`	meaning
MF	0.433	0.000	MF accuracy was almost entirely memorization. On unseen sequences the model produces 0/239 correct MF terms.
BP	0.129	0.039	BP accuracy was largely memorization (−70%) but a small residual generalizes.
CC	0.176	0.232	CC accuracy is robust to the train→holdout shift. It is the only aspect the model actually generalizes on.

What round 3 changes about the round-2 story

Round 2 framed the architecture as "protein encoder dominates, GO encoder is conditional, MF/BP/CC each have a primary modality." On held-out proteins:

The MF reliance pattern collapses. "MF depends on the protein encoder" was true on train but vacuous on holdout — there is no MF signal to depend on. The protein encoder is not transferring MF knowledge to unseen sequences.
The BP reliance pattern weakens. The GO encoder still matters proportionally (go_zero drops BP precision to 0.000), but the absolute level is so low that "biggest aspect for GO" is more of a technicality than a useful capability.
The CC text-shortcut pattern strengthens. CC precision is the only aspect that's stable across all five configs and across train/holdout. Organism + protein name in the text prompt continues to dominate CC predictions, and this is the model's most reliable capability.
The "GO adds nothing once protein is dead" finding survives. protein_zero_go_zero (0.035) ≈ protein_zero (0.031), same qualitative pattern as on train (0.126 vs 0.118). This is now a cross-distribution architectural claim.
protein_noise > protein_zero survives. 0.056 vs 0.031 on holdout; 0.158 vs 0.118 on train. The model uses statistical moments of the protein embedding even out of distribution.

Updated bottom line

The strongest claim that survives both runs:

The GO encoder's marginal contribution is conditional on a working protein representation, and CC predictions are dominated by a text shortcut (organism name) rather than the protein or GO encoders.

The claim that does not survive:

~~"The protein encoder is the primary driver of MF accuracy."~~ Restated: the protein encoder produces MF predictions that score well on training proteins because those proteins are memorized. On novel sequences the model has near-zero MF capability regardless of which modality is ablated.

Round 3 directory layout

ablations_v3_holdout/
├── full/<protein_id>_all_k00.json         # 100 records per config
├── protein_zero/<...>.json
├── protein_noise/<...>.json
├── go_zero/<...>.json
├── protein_zero_go_zero/<...>.json
├── run_summary.json
└── cross_config_summary.json

Round 4A: organism scramble (N=100, holdout, 2 configs)

Round 3 concluded that "CC predictions are dominated by a text shortcut (organism name) rather than the protein or GO encoders." Round 4A tests that directly: take the same 100 holdout proteins, but randomly permute the organism column across them (each protein gets some other protein's organism — deterministic by seed+1). Sequences and GO labels stay attached to the original protein. If CC really rides on organism, CC precision should collapse to the "no encoders" floor.

Round 4A setup

Same 100 holdout proteins as round 3 (temporal_holdout_2025/test, same seed=23 selection).
--scramble_organism true — adapter permutes the organism field with a derangement so no protein keeps its own organism.
Two configs: full (test whether full CC depends on organism) and protein_zero_go_zero (test whether the floor depends on organism).
All other settings identical to round 3: --max_new_tokens 1000, --gpu_memory_utilization 0.6. Runtime 8.8h (model hedges harder when sequence and organism disagree, so generation is ~2× longer than unscrambled).

Round 4A results: precision

config	overall	BP	CC
`full` unscrambled (round 3)	0.088	0.039	0.232
`full` scrambled (round 4A)	0.065	0.000	0.204
`protein_zero_go_zero` unscrambled (round 3)	0.035	0.000	0.113
`protein_zero_go_zero` scrambled (round 4A)	0.036	0.016	0.108

Decomposing the 0.232 CC precision

If we treat protein_zero_go_zero as the "encoders off" condition and the scramble as "organism off," the round-3 + round-4A combination lets us split CC precision into three sources:

source	contribution to CC precision
base rate (encoders dead, organism wrong or right — doesn't matter)	~0.108
protein/GO encoders	0.232 − 0.108 ≈ 0.124
organism string	0.232 − 0.204 ≈ 0.028

Encoders contribute ~4× more than the organism for CC. The encoder-dead floor is unchanged by organism scramble (0.113 → 0.108), which means that residual ~0.11 precision is not a text shortcut — it is base-rate luck on common CC terms like "cytoplasm" and "nucleus."

Round 4A revises the round-3 story

round-3 claim	round-4A finding	revised claim
"CC predictions are dominated by a text shortcut (organism name)"	Scrambling organism drops CC by only 12% (0.232 → 0.204)	CC is encoder-driven; organism is a minor (~12%) modulator.
"The encoders' marginal contribution to CC is small"	At `protein_zero_go_zero`, CC = 0.113 unscrambled, 0.108 scrambled. Encoders contribute 0.124, organism contributes 0.028.	Encoders contribute ~4× more than organism to CC.
"BP predictions have a small residual on holdout"	BP collapses from 0.039 to 0.000 under scramble	The BP residual on holdout was organism-dependent, not modality-dependent.

What round 4A does not refute

The OOD memorization story (round 3) is unchanged. full precision on holdout is still ~3× lower than on train; MF predictions are still near-zero on novel proteins.
The GO-encoder-conditional-on-protein claim is unchanged. Both runs see protein_zero_go_zero ≈ protein_zero in precision.
The "noise > zero" finding is unchanged (we didn't re-run protein_noise under scramble, but no reason to expect a change).
CC remains the only useful aspect on holdout. Even under scramble, CC precision (0.20) far exceeds MF (0.00) or BP (0.00) — the model is much better at CC than the other aspects, and that excess is now attributed to the encoders rather than to the text.

Round 4A directory layout

ablations_v4_scramble/
├── full/<protein_id>_all_k00.json         # 100 records: organism scrambled, full encoders
├── protein_zero_go_zero/<...>.json        # 100 records: organism scrambled, both encoders dead
├── run_summary.json
└── cross_config_summary.json

The scramble itself is not stored separately — it is reproducible from seed=23 plus --scramble_organism true against the same temporal_holdout_2025 split. The input_prompt field on each per-protein record shows the (mismatched) organism that was actually used at generation time.

Each per-protein record contains the full generated response, the input prompt (so the run is reproducible), the ablation config name, the ground-truth string (placeholder on test split), and basic accounting fields (sequence_length, success, etc.).

Downloads last month: 15

Total file size:

362 MB

You need to agree to share your contact information to access this dataset

CAFA5 with UniProt metadata

Source