Add normalized Parquet train/test mmCIF index

README.md

@@ -0,0 +1,154 @@
+---
+pretty_name: PDB mmCIF Entry Index
+license: cc0-1.0
+tags:
+- biology
+- proteins
+- protein-structure
+- pdb
+- rcsb
+- mmcif
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# PDB mmCIF Entry Index
+
+This repository contains mirrored Protein Data Bank mmCIF files under `mmcif/` plus the PDB `entries.idx` index. The added Parquet files make the mirrored entries loadable in the Hugging Face Dataset Viewer and the `datasets` API.
+
+The default dataset table has one row per mmCIF file present in this repository. Rows are joined with matching metadata from `entries.idx`, including classification, accession date, title, source organism, author list, resolution, and experimental method.
+
+## Splits
+
+| Split | Rows |
+|---|---:|
+| train | 88,873 |
+| test | 9,951 |
+| total | 98,824 |
+
+The split is deterministic: `sha256(pdb_id) % 10 == 0` goes to `test`; buckets `1` through `9` go to `train`.
+
+## Dataset Statistics
+
+| Metric | Value |
+|---|---:|
+| mmCIF files in this repo | 98,824 |
+| Rows joined to `entries.idx` metadata | 98,824 |
+| Full `entries.idx` rows | 252,816 |
+| Total mirrored mmCIF compressed size | 31.08 GB |
+| Known-resolution rows | 93,997 |
+| Unknown-resolution rows | 4,827 |
+| Median known resolution | 2.10 A |
+| Mean known resolution | 2.33 A |
+
+Top experimental methods:
+
+| Method | Rows |
+|---|---:|
+| X-RAY DIFFRACTION | 82,380 |
+| ELECTRON MICROSCOPY | 11,433 |
+| SOLUTION NMR | 4,707 |
+| ELECTRON CRYSTALLOGRAPHY | 101 |
+| X-RAY DIFFRACTION, NEUTRON DIFFRACTION | 50 |
+
+Top classifications:
+
+| Classification | Rows |
+|---|---:|
+| HYDROLASE | 14,117 |
+| TRANSFERASE | 9,970 |
+| OXIDOREDUCTASE | 7,743 |
+| VIRAL PROTEIN | 4,333 |
+| MEMBRANE PROTEIN | 3,206 |
+
+## Load With `datasets`
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/PDB")
+print(ds)
+
+row = ds["train"][0]
+print(row)
+```
+
+Load one split directly:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/PDB", split="train")
+test = load_dataset("LiteFold/PDB", split="test")
+```
+
+Stream rows without materializing the full table locally:
+
+```python
+from datasets import load_dataset
+
+streamed = load_dataset("LiteFold/PDB", split="train", streaming=True)
+first_row = next(iter(streamed))
+```
+
+Use the `mmcif_path` column with `hf_hub_download` to fetch a structure file:
+
+```python
+from datasets import load_dataset
+from huggingface_hub import hf_hub_download
+
+row = load_dataset("LiteFold/PDB", split="train[0]")[0]
+local_path = hf_hub_download(
+    repo_id="LiteFold/PDB",
+    repo_type="dataset",
+    filename=row["mmcif_path"],
+)
+```
+
+Filter to X-ray structures with known resolution:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/PDB", split="train")
+xray = train.filter(
+    lambda row: row["experimental_method"] == "X-RAY DIFFRACTION"
+    and not row["resolution_is_unknown"]
+)
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `pdb_id` | Four-character PDB identifier in lowercase. |
+| `mmcif_path` | Path to the mirrored gzipped mmCIF file in this repository. |
+| `mmcif_file_size_bytes` | Compressed mmCIF file size from Hugging Face Hub file metadata. |
+| `mmcif_blob_id` | Hub blob identifier for the mmCIF object. |
+| `pdb_url` | RCSB PDB structure page URL. |
+| `rcsb_download_url` | Direct RCSB mmCIF download URL. |
+| `classification` | PDB header classification. |
+| `accession_date` | Original `entries.idx` accession date string. |
+| `accession_date_iso` | Parsed ISO date when available. |
+| `title` | Structure title from `entries.idx`. |
+| `source_organism` | Source organism field from `entries.idx`. |
+| `authors` | Author list from `entries.idx`. |
+| `raw_resolution` | Original resolution field from `entries.idx`. |
+| `resolution_angstrom` | Numeric resolution in Angstroms, nullable for non-numeric values such as `NOT`. |
+| `resolution_is_unknown` | Whether `resolution_angstrom` is null. |
+| `experimental_method` | Experimental method field from `entries.idx`. |
+| `has_entries_idx_metadata` | Whether the mmCIF file matched a row in `entries.idx`. |
+| `split_bucket` | Deterministic hash bucket; bucket 0 is test. |
+
+## Source Files Used
+
+- `entries.idx`
+- Hub file metadata for paths under `mmcif/**/*.cif.gz`
+
+The full parsed `entries.idx` table is also included as `metadata/entries_idx.parquet`. The preparation script is included at `scripts/prepare_pdb_dataset.py`.

data/test-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:76872f95cd05e29c6b8db16dcdea43e1812b22a616f293156bddbc71ca8b9cc8
+size 1183585

data/train-00000-of-00001.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:031ab8fc3a3f1d632cf72ee13d52e18f8e51b3b69f711cf10fdfdb12f23b3210
+size 7506645

dataset_summary.json

@@ -0,0 +1,84 @@
+{
+  "source": "LiteFold/PDB",
+  "full_entries_idx_rows": 252816,
+  "mmcif_rows_in_repo": 98824,
+  "metadata_joined_rows": 98824,
+  "splits": {
+    "train": 88873,
+    "test": 9951
+  },
+  "split_strategy": "deterministic sha256(pdb_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "total_mmcif_size_bytes": 31077163473,
+  "resolution": {
+    "known_rows": 93997,
+    "unknown_rows": 4827,
+    "min": 0.0,
+    "median": 2.1,
+    "mean": 2.3307838436333053,
+    "max": 50.0
+  },
+  "top_experimental_methods": {
+    "X-RAY DIFFRACTION": 82380,
+    "ELECTRON MICROSCOPY": 11433,
+    "SOLUTION NMR": 4707,
+    "ELECTRON CRYSTALLOGRAPHY": 101,
+    "X-RAY DIFFRACTION, NEUTRON DIFFRACTION": 50,
+    "SOLID-STATE NMR": 37,
+    "NEUTRON DIFFRACTION": 29,
+    "FIBER DIFFRACTION": 28,
+    "SOLUTION SCATTERING": 16,
+    "POWDER DIFFRACTION": 12,
+    "SOLUTION NMR, SOLUTION SCATTERING": 7,
+    "NEUTRON DIFFRACTION, X-RAY DIFFRACTION": 6,
+    "X-RAY DIFFRACTION, SOLUTION SCATTERING": 4,
+    "SOLUTION NMR, THEORETICAL MODEL": 4,
+    "X-RAY DIFFRACTION, EPR": 3,
+    "INFRARED SPECTROSCOPY": 2,
+    "X-RAY DIFFRACTION, SOLUTION NMR": 1,
+    "SOLID-STATE NMR, SOLUTION SCATTERING, ELECTRON MICROSCOPY": 1,
+    "ELECTRON MICROSCOPY, SOLUTION NMR": 1,
+    "ELECTRON MICROSCOPY, SOLUTION NMR, SOLID-STATE NMR": 1
+  },
+  "top_classifications": {
+    "HYDROLASE": 14117,
+    "TRANSFERASE": 9970,
+    "OXIDOREDUCTASE": 7743,
+    "VIRAL PROTEIN": 4333,
+    "MEMBRANE PROTEIN": 3206,
+    "IMMUNE SYSTEM": 2912,
+    "TRANSCRIPTION": 2611,
+    "LYASE": 2562,
+    "TRANSPORT PROTEIN": 2384,
+    "SIGNALING PROTEIN": 2367,
+    "LIGASE": 1617,
+    "ISOMERASE": 1500,
+    "DNA BINDING PROTEIN": 1369,
+    "STRUCTURAL PROTEIN": 1278,
+    "PROTEIN BINDING": 1265,
+    "DNA": 1218,
+    "HYDROLASE/HYDROLASE INHIBITOR": 1167,
+    "METAL BINDING PROTEIN": 1038,
+    "SUGAR BINDING PROTEIN": 955,
+    "CHAPERONE": 884
+  },
+  "columns": [
+    "pdb_id",
+    "mmcif_path",
+    "mmcif_file_size_bytes",
+    "mmcif_blob_id",
+    "pdb_url",
+    "rcsb_download_url",
+    "classification",
+    "accession_date",
+    "accession_date_iso",
+    "title",
+    "source_organism",
+    "authors",
+    "raw_resolution",
+    "resolution_angstrom",
+    "resolution_is_unknown",
+    "experimental_method",
+    "has_entries_idx_metadata",
+    "split_bucket"
+  ]
+}

metadata/entries_idx.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:275b08dd96248e366203bd94e03f2101642414b0b16f6cbd36d13266c736155e
+size 11586301

scripts/prepare_pdb_dataset.py

@@ -0,0 +1,211 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/PDB."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from datetime import date, datetime
+from pathlib import Path
+
+import pandas as pd
+import pyarrow as pa
+import pyarrow.parquet as pq
+from huggingface_hub import HfApi
+
+
+ENTRY_COLUMNS = [
+    "pdb_id",
+    "classification",
+    "accession_date",
+    "title",
+    "source_organism",
+    "authors",
+    "raw_resolution",
+    "experimental_method",
+]
+
+
+def load_hf_token(env_path: Path) -> str | None:
+    if not env_path.exists():
+        return None
+    for line in env_path.read_text(encoding="utf-8").splitlines():
+        line = line.strip()
+        if not line or line.startswith("#") or "=" not in line:
+            continue
+        key, value = line.split("=", 1)
+        if key.strip() in {"HF_TOKEN", "HUGGINGFACE_HUB_TOKEN"}:
+            return value.strip().strip('"').strip("'")
+    return None
+
+
+def parse_accession_date(value: str, current_year: int) -> str | None:
+    value = (value or "").strip()
+    if not value:
+        return None
+    try:
+        month, day, year = [int(part) for part in value.split("/")]
+    except ValueError:
+        return None
+
+    current_two_digit_year = current_year % 100
+    full_year = 2000 + year if year <= current_two_digit_year else 1900 + year
+    try:
+        return date(full_year, month, day).isoformat()
+    except ValueError:
+        return None
+
+
+def parse_entries_idx(path: Path) -> pd.DataFrame:
+    rows = []
+    current_year = datetime.utcnow().year
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for line_number, line in enumerate(handle, start=1):
+            line = line.rstrip("\n")
+            if line_number <= 2 or not line:
+                continue
+            parts = line.split("\t")
+            if len(parts) < len(ENTRY_COLUMNS):
+                parts = parts + [""] * (len(ENTRY_COLUMNS) - len(parts))
+            elif len(parts) > len(ENTRY_COLUMNS):
+                parts = parts[: len(ENTRY_COLUMNS) - 1] + [" ".join(parts[len(ENTRY_COLUMNS) - 1 :])]
+            rows.append(dict(zip(ENTRY_COLUMNS, parts)))
+
+    df = pd.DataFrame.from_records(rows)
+    df["pdb_id"] = df["pdb_id"].str.lower()
+    df["accession_date_iso"] = df["accession_date"].map(
+        lambda value: parse_accession_date(value, current_year)
+    )
+    df["resolution_angstrom"] = pd.to_numeric(df["raw_resolution"], errors="coerce")
+    df["resolution_is_unknown"] = df["resolution_angstrom"].isna()
+    for column in ["classification", "title", "source_organism", "authors", "experimental_method"]:
+        df[column] = df[column].fillna("").str.strip()
+    return df
+
+
+def mmcif_rows_from_hub(repo_id: str, token: str | None) -> pd.DataFrame:
+    api = HfApi(token=token)
+    info = api.dataset_info(repo_id, files_metadata=True)
+    records = []
+    for sibling in info.siblings or []:
+        path = sibling.rfilename
+        if not path.startswith("mmcif/") or not path.endswith(".cif.gz"):
+            continue
+        filename = Path(path).name
+        pdb_id = filename.removesuffix(".cif.gz").lower()
+        records.append(
+            {
+                "pdb_id": pdb_id,
+                "mmcif_path": path,
+                "mmcif_file_size_bytes": int(sibling.size) if sibling.size is not None else None,
+                "mmcif_blob_id": sibling.blob_id,
+            }
+        )
+    return pd.DataFrame.from_records(records)
+
+
+def stable_bucket(value: str, buckets: int = 10) -> int:
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
+    return int(digest, 16) % buckets
+
+
+def write_parquet(df: pd.DataFrame, path: Path) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    table = pa.Table.from_pandas(df, preserve_index=False)
+    pq.write_table(table, path, compression="zstd")
+
+
+def build_dataset(raw_dir: Path, out_dir: Path, repo_id: str, token: str | None) -> dict:
+    entries = parse_entries_idx(raw_dir / "entries.idx")
+    mmcif = mmcif_rows_from_hub(repo_id, token)
+    if mmcif.empty:
+        raise RuntimeError(f"No mmCIF files found in {repo_id}")
+
+    df = mmcif.merge(entries, on="pdb_id", how="left", validate="one_to_one")
+    df["has_entries_idx_metadata"] = df["title"].notna()
+    for column in ["classification", "accession_date", "accession_date_iso", "title", "source_organism", "authors", "raw_resolution", "experimental_method"]:
+        df[column] = df[column].fillna("")
+    df["resolution_angstrom"] = df["resolution_angstrom"].astype("Float64")
+    df["resolution_is_unknown"] = df["resolution_angstrom"].isna()
+    df["pdb_url"] = "https://www.rcsb.org/structure/" + df["pdb_id"].str.upper()
+    df["rcsb_download_url"] = "https://files.rcsb.org/download/" + df["pdb_id"] + ".cif.gz"
+    df["split_bucket"] = df["pdb_id"].map(stable_bucket).astype("int64")
+    df["split"] = df["split_bucket"].map(lambda bucket: "test" if bucket == 0 else "train")
+
+    ordered_columns = [
+        "pdb_id",
+        "mmcif_path",
+        "mmcif_file_size_bytes",
+        "mmcif_blob_id",
+        "pdb_url",
+        "rcsb_download_url",
+        "classification",
+        "accession_date",
+        "accession_date_iso",
+        "title",
+        "source_organism",
+        "authors",
+        "raw_resolution",
+        "resolution_angstrom",
+        "resolution_is_unknown",
+        "experimental_method",
+        "has_entries_idx_metadata",
+        "split_bucket",
+    ]
+    df = df[ordered_columns + ["split"]].sort_values(["split", "pdb_id"], kind="mergesort")
+
+    data_dir = out_dir / "data"
+    for split in ["train", "test"]:
+        split_df = df[df["split"].eq(split)].drop(columns=["split"])
+        write_parquet(split_df, data_dir / f"{split}-00000-of-00001.parquet")
+
+    metadata_dir = out_dir / "metadata"
+    write_parquet(entries.sort_values("pdb_id", kind="mergesort"), metadata_dir / "entries_idx.parquet")
+
+    method_counts = (
+        df["experimental_method"].replace("", "UNKNOWN").value_counts().head(20).to_dict()
+    )
+    class_counts = df["classification"].replace("", "UNKNOWN").value_counts().head(20).to_dict()
+    summary = {
+        "source": repo_id,
+        "full_entries_idx_rows": int(len(entries)),
+        "mmcif_rows_in_repo": int(len(df)),
+        "metadata_joined_rows": int(df["has_entries_idx_metadata"].sum()),
+        "splits": {
+            "train": int(df["split"].eq("train").sum()),
+            "test": int(df["split"].eq("test").sum()),
+        },
+        "split_strategy": "deterministic sha256(pdb_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "total_mmcif_size_bytes": int(df["mmcif_file_size_bytes"].fillna(0).sum()),
+        "resolution": {
+            "known_rows": int(df["resolution_angstrom"].notna().sum()),
+            "unknown_rows": int(df["resolution_angstrom"].isna().sum()),
+            "min": float(df["resolution_angstrom"].min(skipna=True)),
+            "median": float(df["resolution_angstrom"].median(skipna=True)),
+            "mean": float(df["resolution_angstrom"].mean(skipna=True)),
+            "max": float(df["resolution_angstrom"].max(skipna=True)),
+        },
+        "top_experimental_methods": method_counts,
+        "top_classifications": class_counts,
+        "columns": ordered_columns,
+    }
+    (out_dir / "dataset_summary.json").write_text(json.dumps(summary, indent=2) + "\n", encoding="utf-8")
+    return summary
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--raw-dir", type=Path, default=Path("LiteFold_PDB_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_PDB_processed"))
+    parser.add_argument("--repo-id", default="LiteFold/PDB")
+    parser.add_argument("--env-file", type=Path, default=Path(".env"))
+    args = parser.parse_args()
+
+    summary = build_dataset(args.raw_dir, args.out_dir, args.repo_id, load_hf_token(args.env_file))
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()