--- license: other license_name: atlasfold-data license_link: https://github.com/SeonghwanSeo/atlasfold/blob/444f376d85b9954a5f2f5f3f8b3cbcae1201ebb1/LICENSE pretty_name: AtlasFold-Data tags: - biology - protein - protein-structure - structure-prediction - alphafold - pdb size_categories: - 10M_index` config with one row per training sample in AtlasFold's order. Small original files (msgpack and JSON manifests, FASTA, cluster CSVs, the ColabFold PDB tarball of `disordered_pdb_af2`) are stored unchanged under `source//`. ## Load ```bash pip install "datasets>=4,<6" "huggingface_hub>=1" pyarrow numpy ``` Stream a subset without downloading it: ```python from datasets import load_dataset rows = load_dataset("Synthyra/AtlasFold-Data", "rcsb_multimer_val", split="validation", streaming=True) row = next(iter(rows.with_format("numpy"))) print(row["id"], row["num_chains"], row["atom14_positions"].shape) # (l, 14, 3) ``` Download a subset and its index when you need random access or exact sampling: ```bash hf download Synthyra/AtlasFold-Data --repo-type dataset --local-dir AtlasFold-Data --include "data/rcsb/*" "data/rcsb_index/*" ``` Large training jobs should download rather than stream: every remote read counts against the Hub's request limits. ## Structure columns | Column | Type | Meaning | | --- | --- | --- | | `id` | string | AtlasFold entry key: `{pdb}_{label_asym_id}` for PDB chains, `{pdb}` for complexes, file stems for predictions | | `subset` | string | Config name | | `manifest_index` | int64 | Position of the entry in the original `manifest.msgpack` | | `num_chains`, `num_residues` | int32 | Chain count and total residues | | `sequence` | string | One-letter sequence over `ARNDCQEGHILKMFPSTWYVX`; chains are joined with `:` | | `chains` | list of struct | Per-chain manifest fields: `id`, `num_residues`, `label_asym_id`, `auth_asym_id`, `entity_id`, `asym_id`, `sym_id`, `cluster_id`, `cluster_size`, `is_low_homology` | | `interfaces` | list of struct | Chain pairs (`chain_a`, `chain_b`, 0-based) with a resolved Cα–Cα distance below 15 Å, with `cluster_id`, `cluster_size`, `is_low_homology` | | `exp_pdb_id`, `exp_release_date`, `exp_method`, `exp_resolution` | string, string, string, float64 | PDB entry, first release date, method, and resolution in Å | | `pred_model`, `pred_plddt` | string, float64 | Predictor and mean Cα pLDDT of a predicted structure | | `in_manifest_confidence` | bool | Entry appears in AtlasFold's `manifest_confidence.msgpack` (resolution 0.1 to 3.0 Å) | | `in_manifest_plddt70` | bool | Entry appears in `manifest_plddt70.msgpack` | | `atom14_positions` | Array3D (l, 14, 3) float32 | Heavy-atom coordinates in Å, atom14 order; NaN for slots a residue type lacks and for unresolved atoms | | `atom14_b_factors` | Array2D (l, 14) float32 | Per-atom B-factor column; NaN where coordinates are absent | A null manifest field means AtlasFold omitted that key; a null `is_low_homology` means false. A null `in_manifest_*` column means the subset has no such manifest. Chain `id`s can repeat within a complex because AtlasFold removed digits from assembly copy names, so identify chains by position. `atom14_b_factors` holds experimental B-factors for the PDB-derived subsets, pLDDT (0 to 100) for `disordered_pdb_af2` and the MGnify subsets, and a constant 20.0 for `disordered_pdb_afm`, whose predictions carry no pLDDT. The released MGnify manifests are not filtered by pLDDT. Atom14 slot order per residue type, the same as AlphaFold2 except that `X` keeps five slots: ```python import numpy as np RESTYPES = "ARNDCQEGHILKMFPSTWYVX" RESIDUE_ATOMS = { "A": ("N", "CA", "C", "O", "CB"), "R": ("N", "CA", "C", "O", "CB", "CG", "CD", "NE", "CZ", "NH1", "NH2"), "N": ("N", "CA", "C", "O", "CB", "CG", "OD1", "ND2"), "D": ("N", "CA", "C", "O", "CB", "CG", "OD1", "OD2"), "C": ("N", "CA", "C", "O", "CB", "SG"), "Q": ("N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "NE2"), "E": ("N", "CA", "C", "O", "CB", "CG", "CD", "OE1", "OE2"), "G": ("N", "CA", "C", "O"), "H": ("N", "CA", "C", "O", "CB", "CG", "ND1", "CD2", "CE1", "NE2"), "I": ("N", "CA", "C", "O", "CB", "CG1", "CG2", "CD1"), "L": ("N", "CA", "C", "O", "CB", "CG", "CD1", "CD2"), "K": ("N", "CA", "C", "O", "CB", "CG", "CD", "CE", "NZ"), "M": ("N", "CA", "C", "O", "CB", "CG", "SD", "CE"), "F": ("N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ"), "P": ("N", "CA", "C", "O", "CB", "CG", "CD"), "S": ("N", "CA", "C", "O", "CB", "OG"), "T": ("N", "CA", "C", "O", "CB", "OG1", "CG2"), "W": ("N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "NE1", "CE2", "CE3", "CZ2", "CZ3", "CH2"), "Y": ("N", "CA", "C", "O", "CB", "CG", "CD1", "CD2", "CE1", "CE2", "CZ", "OH"), "V": ("N", "CA", "C", "O", "CB", "CG1", "CG2"), "X": ("N", "CA", "C", "O", "CB"), } ATOM37_NAMES = ( "N", "CA", "C", "CB", "O", "CG", "CG1", "CG2", "OG", "OG1", "SG", "CD", "CD1", "CD2", "ND1", "ND2", "OD1", "OD2", "SD", "CE", "CE1", "CE2", "CE3", "NE", "NE1", "NE2", "OE1", "OE2", "CH2", "NH1", "NH2", "OH", "CZ", "CZ2", "CZ3", "NZ", "OXT", ) ATOM14_EXISTS = np.zeros((21, 14), dtype=bool) # (restype, slot) ATOM14_TO_ATOM37 = np.zeros((21, 14), dtype=np.int64) # (restype, slot) atom37 index for restype_index, restype in enumerate(RESTYPES): atoms = RESIDUE_ATOMS[restype] ATOM14_EXISTS[restype_index, : len(atoms)] = True ATOM14_TO_ATOM37[restype_index, : len(atoms)] = [ATOM37_NAMES.index(atom) for atom in atoms] def restype_indices(sequence): """Residue type index per residue, shape (l,); chain separators are skipped.""" return np.array([RESTYPES.index(letter) for letter in sequence.replace(":", "")]) def chain_bounds(sequence): """(start, end) residue offsets of each chain in the concatenated arrays.""" ends = np.cumsum([len(chain) for chain in sequence.split(":")]) return list(zip(np.concatenate([[0], ends[:-1]]).tolist(), ends.tolist())) def derived_chain_ids(sequence): """Entity, asym, and sym ids per chain, assigned as AtlasFold's ProteinMultimer does.""" entity_ids, sym_ids, entity_of, copies = [], [], {}, {} for chain in sequence.split(":"): entity_of.setdefault(chain, len(entity_of) + 1) copies[chain] = copies.get(chain, 0) + 1 entity_ids.append(entity_of[chain]) sym_ids.append(copies[chain]) return entity_ids, list(range(1, len(entity_ids) + 1)), sym_ids def atom14_to_atom37(positions, sequence): """Scatter (l, 14, 3) atom14 coordinates into (l, 37, 3) atom37 slots; empty slots stay NaN.""" restypes = restype_indices(sequence) # (l,) atom37 = np.full((len(restypes), 37, 3), np.nan, dtype=positions.dtype) # (l, 37, 3) residues, slots = np.nonzero(ATOM14_EXISTS[restypes]) # (n_atom,), (n_atom,) atom37[residues, ATOM14_TO_ATOM37[restypes[residues], slots]] = positions[residues, slots] return atom37 ``` The resolved-atom mask is `np.isfinite(row["atom14_positions"]).all(-1)`, shape (l, 14). ## Index and template columns `_index` rows follow AtlasFold's sampling order and point into the structure files: rows of `data//` sorted by file name, where `file_index` selects the file and `row_index` the row. | Config kind | Columns | | --- | --- | | Monomer subsets | `manifest_index`, `id`, `num_residues`, `cluster_size`, `plddt`, `resolution`, `file_index`, `row_index` | | Complex subsets | `sample_index`, `manifest_index`, `kind` (`chain` or `interface`), `chain_a`, `chain_b`, `cluster_size`, `file_index`, `row_index` | `rcsb_multimer_templates` stores the 950,691 template chains of `template.lmdb` (`template_id`, `manifest_index`, `num_residues`, `sequence`, `atom14_positions`). Their stored b-factors are NaN in every slot, so that column is omitted. `rcsb_multimer_template_hits` stores `template_mapping.lmdb`: `mapping_key` (`{pdb}_{entity_id}`), `pdb_id`, `entity_id`, and `hits` with `template_id`, `index`, `release_date`, and 1-based aligned residue indices `entry_indices` and `template_indices`. AtlasFold already removed templates released less than 60 days before their entry. ## Reproduce AtlasFold's training sampler AtlasFold draws every training example with replacement from one weight vector. Weights are normalized within a subset, multiplied by the subset's stage weight, and concatenated in config order. - Monomer subsets multiply per-entry factors: `length` gives `min(max(num_residues, 256), 512)`, `cluster` gives `1 / cluster_size`, and `plddt` gives `min(max(plddt - 30, 0), 40)`. - `rcsb_multimer` and `disordered_pdb_afm` draw chains with weight `1 / cluster_size` and interfaces with `2 / cluster_size`, a missing size counting as 1, in float32. - MGnify subsets in multimer stages are uniform. - The sampler seeds NumPy with `0 + epoch`. An epoch is 256,000 draws for monomer stages and 128,000 for multimer stages, and a draw that fails cropping is replaced by a uniform draw from the same subset. - Confidence losses use only non-distillation entries with resolution from 0.1 to 3.0 Å. | Monomer stage | Crop / LM tokens | `rcsb` | `disordered_pdb_af2` | `mgnify_long` | `mgnify_short` | | --- | --- | --- | --- | --- | --- | | 1 | 256 / 512 | 0.120 length, cluster | 0.005 length, cluster | 0.865 length, plddt | 0.010 length, plddt | | 2 | 384 / 768 | 0.123 length, cluster | 0.002 length, cluster | 0.865 length, plddt | 0.010 length, plddt | | 3 | 512 / 1024 | 0.240 length, cluster | 0.010 length, cluster | 0.740 plddt | 0.010 plddt | | 4 | 640 / 1280 | 0.240 length, cluster | 0.010 length, cluster | 0.740 plddt | 0.010 plddt | | Multimer stage | Crop / LM tokens | `rcsb_multimer` | `disordered_pdb_afm` | `mgnify_long` | `mgnify_short` | | --- | --- | --- | --- | --- | --- | | 1 | 384 / 768 | 0.73 | 0.02 | 0.245 | 0.005 | | 2 | 640 / 1280 | 0.490 | 0.010 | 0.495 | 0.005 | | 3 | 768 / 1536 | 0.490 | 0.010 | 0.495 | 0.005 | Multimer stages use templates for `rcsb_multimer` with probability 0.4 and at most two per chain. The stage settings come from `configs/{monomer,multimer}/train_stage*.yaml` at commit `444f376`. The following code reproduces the index sequence of AtlasFold's `DistributedWeightedSampler` from a local download that includes the needed `data/*_index/` folders: ```python import math import numpy as np import pyarrow.parquet as pq from pathlib import Path MONOMER_STAGES = { 1: [("rcsb", 0.120, ("length", "cluster")), ("disordered_pdb_af2", 0.005, ("length", "cluster")), ("mgnify_long", 0.865, ("length", "plddt")), ("mgnify_short", 0.010, ("length", "plddt"))], 2: [("rcsb", 0.123, ("length", "cluster")), ("disordered_pdb_af2", 0.002, ("length", "cluster")), ("mgnify_long", 0.865, ("length", "plddt")), ("mgnify_short", 0.010, ("length", "plddt"))], 3: [("rcsb", 0.240, ("length", "cluster")), ("disordered_pdb_af2", 0.010, ("length", "cluster")), ("mgnify_long", 0.740, ("plddt",)), ("mgnify_short", 0.010, ("plddt",))], 4: [("rcsb", 0.240, ("length", "cluster")), ("disordered_pdb_af2", 0.010, ("length", "cluster")), ("mgnify_long", 0.740, ("plddt",)), ("mgnify_short", 0.010, ("plddt",))], } MULTIMER_STAGES = { 1: [("rcsb_multimer", 0.73), ("disordered_pdb_afm", 0.02), ("mgnify_long", 0.245), ("mgnify_short", 0.005)], 2: [("rcsb_multimer", 0.490), ("disordered_pdb_afm", 0.010), ("mgnify_long", 0.495), ("mgnify_short", 0.005)], 3: [("rcsb_multimer", 0.490), ("disordered_pdb_afm", 0.010), ("mgnify_long", 0.495), ("mgnify_short", 0.005)], } COMPLEX_SUBSETS = {"rcsb_multimer", "disordered_pdb_afm", "rcsb_multimer_val"} def read_index(root, subset): return pq.read_table(next(Path(root, "data", f"{subset}_index").glob("*.parquet"))) def monomer_weights(index, strategies): """TrainingDataset.get_sampling_weights with the same float64 operations.""" weights = np.ones(index.num_rows) for strategy in strategies: if strategy == "length": weights *= np.minimum(np.maximum(index["num_residues"].to_numpy().astype(np.float64), 256), 512) elif strategy == "cluster": if index["cluster_size"].null_count: raise ValueError("AtlasFold raises on a missing cluster_size") sizes = index["cluster_size"].to_numpy().astype(np.float64) weights *= 1 / np.where(sizes == 0, 1, sizes) elif strategy == "plddt": weights *= np.minimum(np.maximum(index["plddt"].fill_null(0.0).to_numpy() - 30, 0), 40) return weights / weights.sum() def complex_sample_weights(index): """RCSBTrainingDataset weights: chains 1 / cluster_size, interfaces 2 / cluster_size, float32.""" sizes = index["cluster_size"].fill_null(0).to_numpy().astype(np.float64) kind = np.where(index["kind"].to_numpy(zero_copy_only=False) == "interface", 2.0, 1.0) weights = (1.0 / np.where(sizes == 0, 1, sizes) * kind).astype(np.float32) return weights / weights.sum() def stage_weights(root, mode, stage): """Return the stage weight vector, its subset names, and cumulative subset sizes.""" parts, subsets = [], [] if mode == "monomer": for subset, weight, strategies in MONOMER_STAGES[stage]: parts.append(monomer_weights(read_index(root, subset), strategies) * weight) subsets.append(subset) else: for subset, weight in MULTIMER_STAGES[stage]: index = read_index(root, subset) if subset in COMPLEX_SUBSETS: base = complex_sample_weights(index) else: base = np.full(index.num_rows, 1 / index.num_rows, dtype=np.float32) parts.append(base * weight) subsets.append(subset) return np.concatenate(parts), subsets, np.cumsum([len(part) for part in parts]) def sampled_indices(weights, epoch, rank=0, world_size=1, seed=0): """Indices that DistributedWeightedSampler yields to `rank` for `epoch`.""" probabilities = weights.astype(np.float64) probabilities = probabilities / probabilities.sum() total = math.ceil(len(probabilities) / world_size) * world_size indices = np.random.default_rng(seed + epoch).choice(len(probabilities), total, p=probabilities, replace=True) return indices[rank:total:world_size] def locate(index_value, subsets, cumulative): """Map a global sampler index to its subset and index-table row.""" position = int(np.searchsorted(cumulative, index_value, side="right")) return subsets[position], int(index_value - (cumulative[position - 1] if position else 0)) ``` For example, `weights, subsets, cumulative = stage_weights("AtlasFold-Data", "multimer", 1)`, then `locate(sampled_indices(weights, epoch=0)[0], subsets, cumulative)` names the first sample of the first multimer epoch. The index row gives the structure file, row, and for complexes the chain or interface that AtlasFold uses to center its crop. Read indexed structures from a local download: ```python import datasets # registers the Array2D and Array3D column types with pyarrow import pyarrow as pa import pyarrow.parquet as pq from pathlib import Path ARRAY_SHAPES = {"atom14_positions": (-1, 14, 3), "atom14_b_factors": (-1, 14)} def row_arrays(batch, index): """One row of a record batch as Python values, with structure columns as NumPy arrays.""" row = {} for name in batch.schema.names: column = batch[name] if name not in ARRAY_SHAPES: row[name] = column[index].as_py() continue values = (column.storage if isinstance(column, pa.ExtensionArray) else column)[index].values while pa.types.is_list(values.type): values = values.flatten() row[name] = values.to_numpy(zero_copy_only=False).reshape(ARRAY_SHAPES[name]) return row def read_structure(root, subset, file_index, row_index): """Return the structure row that an index table points to.""" path = sorted(Path(root, "data", subset).glob("*.parquet"))[file_index] parquet = pq.ParquetFile(path) start = 0 for group in range(parquet.num_row_groups): rows_in_group = parquet.metadata.row_group(group).num_rows if row_index < start + rows_in_group: batch = parquet.read_row_group(group).combine_chunks().to_batches()[0] return row_arrays(batch, row_index - start) start += rows_in_group raise IndexError(f"{path.name} has no row {row_index}") ``` ## Use AtlasFold's own trainer Row-group reads are slow for random access over `mgnify_long`. To train with AtlasFold's code, rebuild its native layout (`manifest.msgpack` plus `structure.lmdb`) from a local download. The rebuilt LMDB values decode to arrays identical to the original release; the NPZ bytes differ only in zip metadata. ```python import io import lmdb import numpy as np import pickle import pyarrow.parquet as pq import shutil from pathlib import Path def compact_arrays(sequence, positions, b_factors): """Keep only existing atom14 slots, as AtlasFold's DataPipeline stores them.""" exists = ATOM14_EXISTS[restype_indices(sequence)] # (l, 14) return positions[exists], b_factors[exists] # (n_atom, 3), (n_atom,) def npz_bytes(arrays): buffer = io.BytesIO() np.savez_compressed(buffer, **arrays) return buffer.getvalue() def rebuild_native_subset(root, subset, output_root, is_complex): target = Path(output_root, subset) target.mkdir(parents=True, exist_ok=True) for source in Path(root, "source", subset).iterdir(): shutil.copyfile(source, target / source.name) environment = lmdb.open(str(target / "structure.lmdb"), map_size=1 << 41) columns = ["id", "chains", "sequence", "atom14_positions", "atom14_b_factors"] for path in sorted(Path(root, "data", subset).glob("*.parquet")): for batch in pq.ParquetFile(path).iter_batches(batch_size=256, columns=columns): with environment.begin(write=True) as transaction: for index in range(batch.num_rows): row = row_arrays(batch, index) arrays = {"name": np.array([row["id"]], dtype="S")} chains = list(zip(row["chains"], row["sequence"].split(":"), chain_bounds(row["sequence"]))) if is_complex: arrays["num_chains"] = np.array([len(chains)], dtype=np.int64) for chain_index, (chain, sequence, (start, end)) in enumerate(chains): prefix = f"{chain_index}." if is_complex else "" coordinates, b_factors = compact_arrays( sequence, row["atom14_positions"][start:end], row["atom14_b_factors"][start:end] ) arrays[f"{prefix}name"] = np.array([chain["id"]], dtype="S") arrays[f"{prefix}sequence"] = np.array([sequence], dtype="S") arrays[f"{prefix}coordinates"] = coordinates arrays[f"{prefix}b_factors"] = b_factors transaction.put(row["id"].encode(), npz_bytes(arrays)) environment.close() def rebuild_native_templates(root, output_root): """Restore `template.lmdb` and `template_mapping.lmdb` for `rcsb_multimer`.""" target = Path(output_root, "rcsb_multimer") target.mkdir(parents=True, exist_ok=True) templates = lmdb.open(str(target / "template.lmdb"), map_size=1 << 41) for path in sorted(Path(root, "data", "rcsb_multimer_templates").glob("*.parquet")): for batch in pq.ParquetFile(path).iter_batches(batch_size=512, columns=["template_id", "sequence", "atom14_positions"]): with templates.begin(write=True) as transaction: for index in range(batch.num_rows): row = row_arrays(batch, index) positions = row["atom14_positions"] # (l, 14, 3) coordinates, b_factors = compact_arrays(row["sequence"], positions, np.full(positions.shape[:2], np.nan, np.float32)) arrays = { "name": np.array([row["template_id"]], dtype="S"), "sequence": np.array([row["sequence"]], dtype="S"), "coordinates": coordinates, "b_factors": b_factors, } transaction.put(row["template_id"].encode(), npz_bytes(arrays)) templates.close() mapping = lmdb.open(str(target / "template_mapping.lmdb"), map_size=1 << 40) for path in sorted(Path(root, "data", "rcsb_multimer_template_hits").glob("*.parquet")): with mapping.begin(write=True) as transaction: for row in pq.read_table(path).to_pylist(): hits = [ { "template_id": hit["template_id"], "index": hit["index"], "release_date": hit["release_date"], "entry_indices": np.array(hit["entry_indices"], dtype=np.uint16), "template_indices": np.array(hit["template_indices"], dtype=np.uint16), } for hit in row["hits"] ] transaction.put(row["mapping_key"].encode(), pickle.dumps(hits, protocol=pickle.HIGHEST_PROTOCOL)) mapping.close() ``` Call `rebuild_native_subset(root, subset, output_root, subset in COMPLEX_SUBSETS)` for each subset and `rebuild_native_templates(root, output_root)` for multimer training, then set AtlasFold's `train.data.data_root` to `output_root`. ## License and attribution AtlasFold's code, weights, and released datasets are distributed under the MIT License (Copyright (c) 2026 Seonghwan Seo); this conversion keeps that license. The structures come from upstream resources with their own terms: PDB entries (CC0 1.0), MGnify sequences (CC0 1.0), and the OpenFold3 training data behind `mgnify_long`, `mgnify_short`, and the `rcsb_multimer` templates (CC BY 4.0, [OpenFold Consortium](https://registry.opendata.aws/openfold3/)). AtlasFold's documentation asks users to check the upstream terms before redistribution or commercial use. ```bibtex @article{seo2026atlasfold, author = {Seo, Seonghwan and Kim, Hyeongwoo and Moon, Seokhyun and Kim, Woo Youn and {Team KAIST}}, title = {AtlasFold: Protein structure prediction with metagenomic-scale language models}, year = {2026}, doi = {10.64898/2026.09.04.749352}, URL = {https://www.biorxiv.org/content/10.64898/2026.09.04.749352v2}, journal = {bioRxiv} } ``` ## Build record Converted from the AtlasFold release at commit `444f376d85b9954a5f2f5f3f8b3cbcae1201ebb1` with the `atlasfold_data` package in [Synthyra/DatasetDev](https://github.com/Synthyra/DatasetDev). `mgnify_long` could not be downloaded from the release Drive folder because of Google Drive download quotas, so it was rebuilt from the same source AtlasFold used: the OpenFold3 AlphaFold2 MGnify predictions on the AWS Registry of Open Data. The rebuild parses each entry's `best_structure_relaxed.pdb` with AtlasFold's own reader (`scripts/preprocess/af2/a1_process.py`) and writes the released LMDB and manifest formats. The same procedure reproduced the released `mgnify_short` exactly: all 430,418 LMDB values byte for byte, `manifest.msgpack` byte for byte, and the uncompressed `manifest.json.zst` text. | Subset | Source | SHA-256 | Converted with | | --- | --- | --- | --- | | `rcsb` | Drive file `1TEH73v9oxA1oYYnsPZntHqES_04vEz8P` | archive `905b248e1baee4e7e8b7a3536e5596af9c7cbf2c249b30b50fa7c45f5ebd9562` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `rcsb_multimer` | Drive file `1aN9zUL4JokQc0L6AWVUNlsnftQBi8pjr` | archive `c29a7cf85dc9a4ca46523fa65b74e2a19dd382c90d08c2f15a209e86686b682a` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `cameo_val` | Drive file `10fhgH7nnVA022nvN-v3bTg1Xor97t2Ne` | archive `0e9c635b9a1196630d5c540e1a2b5abb718b5325163b9443da2608405629857c` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `rcsb_multimer_val` | Drive file `17meo4uBvvFfB2M-uor17KWwqQDYdSGFI` | archive `be0300ebee91c93b92d9a5ebcd8c1b94c41e26e0261b139607630435ce0f2ac4` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `disordered_pdb_af2` | Drive file `1f79fRsVOK5SloBo-wVYLuAXDyBX5bOTR` | archive `3adc4928e7da6cf22eaed2462bb1728eb914cb307f85703a3524a1ba428c8c69` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `disordered_pdb_afm` | Drive file `1f7pw1T7Bdho3r2P7cT5KTv4AvkY4joqb` | archive `589ea53a7a18cc19d854b75c1c8e398a11487fdc829970431880a26e65d95c10` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `mgnify_short` | Drive file `1VN9XQsd9d5ulsyO4XICXhIMYqqVk7Ag_` | archive `b7da9a2f9ce2453fa57428060e0ab47afe3939a0153dae0cd3cc8adfbccc1879` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 | | `mgnify_long` | rebuilt from `s3://openfold3-data/monomer_distillation_sets_v2/long_monomers/raw/` | entry list `6c9697f29f845180ea37fd795d561c3f67bc179ff4eecc75f0a7f9b5747846b6` | pyarrow 25.0.1, datasets 4.8.5, NumPy 2.5.3 |