kevinlu4588/protein-multimer-esmc6b

Protein-protein complexes with ESMC-6B residue embeddings

A multimer training set for models that fold or reason over two interacting chains at once. Every complex is a pair of experimentally determined chains from a single PDB entry, so both chains are already in one shared crystal frame and the relative placement of the two chains is ground truth. Nothing here is docked or predicted.

Each chain carries final-layer ESMC-6B residue embeddings, verified bitwise identical to the embeddings used to train the LLMFold folding checkpoints, so this data can be mixed with existing monomer corpora without a representation change.

	complexes	heteromeric	homomeric	<= 512 residues	PDB entries
train	166,355	108,455	57,900	91,236	53,879
val	3,380	2,529	851	1,893	1,567
test	4,214	2,974	1,240	2,376	1,764

260,287 chains, 127,808 embedded unique sequences, 80 embedding shards (158 GB).

What a complex is

A chain pair is kept when at least 10 CA-CA pairs fall within 8 A, both chains are at least 16 residues, and the two chains total at most 1024 residues. Interface statistics per complex are in the catalog, so a stricter cutoff can be applied without re-mining.

Splits are controlled for two leakage channels

Held-out complexes are chosen by interface cluster, the unordered pair of the two chains' MMseqs2 clusters (30% identity, 80% coverage). A complex is held out only if neither of its chain clusters appears in training. Training complexes that touch a held-out chain cluster are dropped rather than reassigned, which costs 60,920 complexes and buys an exact guarantee:

• chain clusters shared between train and val: 0
• chain clusters shared between train and test: 0

Both are asserted when the splits are built. Note the remaining honest limit: clustering is by sequence, so a held-out pair could still reuse a structurally similar interface between non-homologous chains. Interface-structure clustering is not applied.

Layout

catalog/chains.parquet       id, entry, chain, sequence, sequence_sha256, length,
                             n_observed, backbone_shard, backbone_row, cluster,
                             residue_seq (deposited numbering), has_insertion_code
catalog/complexes.parquet    id, entry, chain_a, chain_b, sha_a, sha_b, len_a, len_b,
                             total_len, iface_pairs, iface_res_a, iface_res_b, min_dist,
                             homomer, split, ri_offset_b, shard_a/row_a, shard_b/row_b,
                             cluster_a, cluster_b, iface_cluster
embeddings/shard-*.safetensors   bf16 [residues, 2560], single tensor key 'embeddings'
embeddings/shard-*.parquet       sequence_sha256 -> shard_path, residue_offset, residue_end
backbone/shard-*.npz             backbone [atoms, 3, 3] float32 (N, CA, C), offsets, ids
provenance/encoder-v1.json       encoder identity, checksums, numerical policy
provenance/pipeline-v1.json      mining and split options, stage script checksums

Coordinates are (N, CA, C) per residue in the deposited frame, NaN where unobserved. residue_index for a chain is 0..L-1; ri_offset_b is the offset to add to chain B's residue index when the two chains are concatenated into one context, so the two chains do not share position ids. The default offset is len_a + 200.

Reading a complex

import json, numpy as np, pyarrow.parquet as pq
from safetensors import safe_open

cx = pq.read_table('catalog/complexes.parquet').to_pylist()
loc = {}
for p in sorted(glob.glob('embeddings/*.parquet')):
    t = pq.read_table(p).to_pydict()
    for s, f, a, b in zip(t['sequence_sha256'], t['shard_path'],
                          t['residue_offset'], t['residue_end']):
        loc[s] = (f, a, b)

r = cx[0]
fa, a0, a1 = loc[r['sha_a']]
esm_a = safe_open(fa, framework='pt').get_slice('embeddings')[a0:a1]   # [len_a, 2560] bf16

d = np.load(f"backbone/shard-{r['shard_a']:05d}.npz")
o = d['offsets']
bb_a = d['backbone'][o[r['row_a']]:o[r['row_a'] + 1]]                  # [len_a, 3, 3]

Concatenating esm_a/esm_b and bb_a/bb_b, with chain B's residue index offset by ri_offset_b, gives a single co-folding example whose target is the complex in its shared frame.

Known limits

• Mined from PDB entries already present in one working set, not a fresh PDB snapshot, so coverage is not the complete PDB.
• The first deposited model and altloc A only; no assembly expansion, so crystallographic symmetry mates are absent and some biological interfaces are missing.
• No resolution or R-free filter is applied. Interface statistics and n_observed are provided so users can filter themselves.
• Pairs are capped at 1024 total residues, which excludes large assemblies.
• Homomeric complexes are labelled but chain-permutation symmetry is not resolved here; a trainer that supervises relative placement must handle permutation itself.
• Embeddings are per chain, computed on the isolated chain sequence. They carry no information about the partner.