PocketWatch

A temporally held-out benchmark for ligand-binding-site prediction on predicted protein structures. Two tasks over the same pockets: score every residue, and localize each pocket as a point.

Pockets are defined from Q-BioLiP/PDB contacts at 5.0 Å, clustered into sites across every entry that observes them, and projected onto a single predicted fold per protein: an ESMFold2 prediction of the canonical sequence. Splits are cut by date, not by random assignment: a site belongs to a split by when it was first released, so a test pocket is one the field had not seen when the cutoff passed.

split	cutoff (first release)	proteins	sites	scored sites
train	—	11,016	14,331	11,850
validation	2021-09-30	1,553	2,165	1,505
test	2024-01-01	1,566	2,301	1,573

The test split's scored pockets span 1,279 chains, 627,986 scoreable residues, at a 4.86% positive rate.

Read site_policy.parquet first

Not every site is scored, and which ones are is a property of the benchmark rather than of your model. data/site_policy.parquet carries the decision and its reason for all 18,797 sites:

reason	sites	what it means
interface_only	3,318	the pocket exists only where two chains meet, so a single-chain fold cannot support it
pre_cutoff	495	first observed before the split's own cutoff — not novel to this split
no_expressible_residue	49	no residue survives into the modelled sequence
subsumed_by_seen	7	wholly contained in a pocket that was already public

A masked site is still a real pocket. It is never a negative, and its residues stay out of every other pocket's background. Scoring it as a false positive, or as a miss, makes numbers that cannot be compared with anything here.

Files

data/pocket_labels.parquet        14,135 proteins — per-residue label + mask
data/pocket_label_sites.parquet   18,797 sites — lining residues, dates, ligand statistics
data/sequences.parquet            14,135 sequences, keyed by UniProt and sha256
data/site_policy.parquet          18,797 rows — which sites are scored, and why
data/site_centroids.parquet        4,466 sites (validation + test) — localization ground truth
data/paper_excluded_test_proteins.csv  4 test proteins the paper's tables leave out, and why
msas_test.tar                      1,566 pre-merged test-split MSAs, one a3m.gz per protein
msas_test_manifest.parquet         MSA paths, row counts, source coverage, and content hashes
msas_test_manifest.json            archive hash, merge recipe, source revision, and aggregate counts
build_msas_test.py                 deterministic reference builder for msas_test.tar and its manifests
verify_msas_test.py                verifies the release against source searches and production inputs
strata/                           three stratifications of the test split, with the searches behind them
projection/                       entry-frame inputs to re-derive centroids on your own structures
structures/                        3,119 ESMFold2 folds (validation + test), gzipped mmCIF
structures_train.zip              11,016 ESMFold2 folds (train), gzipped mmCIF, zipped (see below)
labels_manifest.json              cutoffs, contact distance, row counts, provenance
verify_bundle.py                  rebuilds site_centroids.parquet from projection/ + structures/
CHECKSUMS.txt                     md5 of every other file, with structures_train.zip and msas_test.tar unpacked (md5sum -c CHECKSUMS.txt)

One fold per protein, named by UniProt accession, numbered 1..L against the canonical sequence in sequences.parquet. Each is ESMFold2's sample 0. structures/manifest.parquet carries each fold's pLDDT, pTM and sequence hash.

Unpacking the train folds

A HuggingFace repository directory holds at most 10,000 files, so the train folds ship as a single uncompressed zip rather than a structures_train/ directory. Unpack it in the repository root before running md5sum -c CHECKSUMS.txt, which lists the folds individually:

unzip structures_train.zip    # creates structures_train/, including its manifest.parquet

You don't have to unpack it to read a single fold:

import zipfile
with zipfile.ZipFile("structures_train.zip") as zf:
    cif_gz = zf.read("structures_train/A0A003.cif.gz")

The coordinate frame, which matters

site_centroids.parquet holds coordinates in the ESMFold2 sample-0 fold frame — the folds in structures/, not the deposited entry. Used against any other structure they are meaningless.

Sites were clustered in a different frame. Pocket instances were grouped into sites on a Protenix fold of the same sequence, and that clustering was not repeated for ESMFold2, so site membership and the labels come from the Protenix-frame clustering. Each site's centroid was then re-projected onto the ESMFold2 fold directly from its members' deposited entries, by the procedure below, never chained through the Protenix fold. As a result:

• median_fit_rmsd_angstrom in site_centroids.parquet and fit_rmsd_angstrom in projection/ligand_centroids.parquet are fits onto the ESMFold2 folds.
• The fit-quality columns of pocket_label_sites.parquet (retained_mean_fit_rmsd_angstrom, retained_max_fit_rmsd_angstrom, high_residual_member_count, residual_quality, median_pocket_confidence, projection_failure_count) describe the clustering step, so they are Protenix-fold figures. median_pocket_confidence is Protenix pLDDT.

If you want the localization task against your own folds, use projection/ instead. It is the frame-independent form of the same ground truth:

• ligand_centroids.parquet — 45,787 member observations, each with its ligand centroid in its own deposited-entry frame, plus pdb_id and the site it belongs to
• contact_residues.parquet — 889,631 rows, the entry-frame CA coordinates of each observation's contact residues, tagged with the canonical sequence position each maps to

Superpose an observation's CAs onto your structure by canonical position, apply the transform to its ligand centroid, and average over the site's members. That is exactly how site_centroids.parquet was built, and verify_bundle.py does it from the files in this repository alone. It is standalone, with no dependency beyond numpy and polars:

pip install numpy polars
python verify_bundle.py --sample 0    # all 4,466 sites; --sample N checks a random N

Over all 4,466 sites it reproduces every centroid to within 2e-5 Å, along with each site's member count, spread and median fit RMSD. The script is also a reference implementation of the projection: Kabsch on the matched contact CAs, applied to the entry-frame ligand centroid, averaged over members.

MSAs (test split)

msas_test.tar holds the exact merged and truncated alignments the trunk actually read, so test results can be reproduced without reimplementing the historical merge. That matters for a temporal benchmark: a search run later, against newer database releases, can pick up homologs deposited after the cutoff.

tar -xf msas_test.tar      # creates msas_test/<uniprot_id>.a3m.gz

Each file has the query first under a header beginning query and at most 16,384 rows. Lowercase insertions are preserved in the A3M; ESMFold2 removes them while parsing with MSA.from_a3m(remove_insertions=True, max_sequences=16384). zPocket can therefore pass each file directly to ESMFold2 with no runtime merge or random row truncation.

msas_test_manifest.parquet maps UniProt accession and sequence_sha256 to each file and records its row count, compressed and uncompressed hashes, source coverage, pre-merge row count, and whether either source cap bound. msas_test_manifest.json records the archive SHA-256, source dataset revision, and full merge recipe. The deterministic builder and verifier are included for provenance; normal use needs neither.

Strata (test split)

Full coverage: every one of the 1,573 scored test sites appears in all three.

file	unit	what it splits on
test_structural_strata.parquet	site (2,046)	max_qcov — the largest share of the pocket's residues covered by a pocket that was already public before the cutoff
test_sequence_strata.parquet	protein (1,566)	sequence identity against Protenix's pretraining set and this dataset's own train/validation splits
cryptic_stratification.parquet	site (2,301)	apo/holo evidence for crypticity, crossed with whether the ESMFold2 fold in structures/ already agrees with the holo pocket to 2 Å

The searches behind the first two ship alongside them, so the strata can be audited or re-cut. Neither search reads a predicted fold.

• test_query.fasta holds the 1,566 test sequences that were queried.
• test_vs_reference.m8 holds their 213,796 MMseqs2 hits, without a header. The columns are query target fident alnlen qcov tcov qlen tlen evalue bits, and each target is prefixed with its source: pretrain|, train| or validation|.
• test_structural_members.parquet holds 13,606 rows, one foldseek search per member observation's deposited structure against pre-cutoff RCSB assemblies. Each site's max_qcov is the maximum over its members.

Each strata manifest (*_manifest.json) records the sha256 of every file it describes.

max_qcov is heavily skewed: 1,453 of 2,046 sites sit in the top 80-100 bin. An aggregate number is dominated by pockets with close structural precedent, which is why the stratification exists. Reporting only the mean hides where a method actually differs.

unknown is 70% of the crypticity strata and is not missing at random. A site is unknown when no admissible apo structure exists, which concentrates the class in recently characterised proteins whose only entries are the site's own holo structures — and makes it the easiest stratum, not a middle tier. Do not fold it into refuted.

Only the fold-agreement axis follows the ESMFold2 folds. fold_within_threshold, and the stratum built from it, compare the ESMFold2 fold with the holo pocket. Of the 1,573 scored test sites, 17 are cryptic with the fold more than 2 Å from the holo pocket, and 23 are cryptic with the fold already within 2 Å. Two references are still Protenix's. The crypticity labels' model-relative criterion uses Protenix's training cutoff (2021-09-30) and was not recomputed; the ESMFold2 model card gives a Sept 2021 data cutoff. The sequence strata's pretraining reference, the protenix_v1_train_* files named in stratification_manifest.json, is Protenix's pretraining set. Protenix v1 and v2 share it (an AlphaFold3-style 2021-09-30 cutoff), which is why the files say v1. It was not rebuilt for ESMFold2, whose training data differ, so identity_pretrain and has_structure_in_pretrain measure overlap with Protenix's pretraining set.

Scoring

Reimplementations diverge on details that move numbers by more than the effects being measured.

• Average precision, computed by the step-wise sum, never auc(recall, precision). The trapezoidal form differs by up to 0.167 on a single target here.
• Per-target: compute AUPRC within each protein from that protein's residue ranking, then average over proteins with equal weight. Not pooled — pooling lets long proteins dominate.
• Per-pocket: compute once per pocket with positives from other pockets masked out, then average over pockets with equal weight.
• Localization: DCC — distance from a predicted centre to the ground-truth ligand centroid, with 4 Å counted a hit. Budgets are per protein: top-N, where N is that protein's number of scored pockets, and the more forgiving top-(N+2).
• Confidence intervals: percentile bootstrap over units (pockets or targets) — sampling error, not training variance.

Matching the paper's numbers

The benchmark scores 1,279 test chains and 1,573 sites. Two narrower bases appear in the paper and in the published checkpoints, and reporting one number against the other's target set is the easiest way to be off by ~0.01 without noticing:

basis	targets	what it is
every scoreable target	1,559	interface-only contacts left unmasked; what a training-time scorer logs
interface-only masked	1,279	interface-only contacts count as neither positive nor negative, which drops the 280 proteins whose only post-cutoff pockets are interface-only. The paper's headline basis — the comparison a single-chain method is owed.
paper tables, minus unreadable proteins	1,275	the above, less the four proteins in data/paper_excluded_test_proteins.csv

Those four carry 11 scored pockets between them and contain non-standard residues (X, written UNK in the folds) that the VN-EGNN baseline cannot read, so the paper's comparison tables drop them from every method to keep all columns on one protein set. They are valid benchmark targets and site_policy.parquet scores them: drop them only to reproduce a table that includes VN-EGNN, and keep them otherwise. The same issue affects 3 validation and 22 train proteins if you train or validate a method that cannot read UNK.

What is not here, and why

Trunk features. Regenerable by running ESMFold2, whose weights are public, and shipping them would freeze one modelling choice into the dataset.

Model weights. Weights for the ESMFold2-trunk zPocket heads will live at https://huggingface.co/genesisml/zPocket.

Protenix folds. The sites were clustered on Protenix folds, but this release ships one fold set, so the localization ground truth has one frame. A second fold set would be a second modelling choice without a second ground truth.

Validation and train MSAs. Only the test split's alignments ship, since they are what reproducing the test numbers needs. Full MSAs for every split are much larger; they may be added later.

Nothing else. Train folds are included, in structures_train.zip: without them the train split cannot be featurized, and a benchmark you cannot train on is only half a benchmark. The test-split MSAs are included too, in msas_test.tar.

Provenance and licence

This dataset is released under the MIT licence, and that includes the ESMFold2 folds.

• Labels derive from Q-BioLiP contact annotations over PDB entries.
• Coordinates in projection/ are deposited PDB coordinates, and PDB data are CC0.
• structures/ and structures_train.zip hold ESMFold2 predictions computed for this dataset. ESMFold2 and its ESMC-6B language model are released by Chan Zuckerberg Biohub under the MIT licence (Copyright 2026 Chan Zuckerberg Biohub, Inc.).
• The Protenix folds used to cluster the sites are not redistributed.

Full input hashes and the recipe id are in labels_manifest.json.

Citation

[paper reference]