Add normalized Parquet train/test accession index

README.md

@@ -0,0 +1,127 @@
+---
+pretty_name: AlphaFoldDB Prediction Index
+license: cc-by-4.0
+tags:
+- biology
+- proteins
+- protein-structure
+- alphafold
+- alphafolddb
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train/*.parquet
+  - split: test
+    path: data/test/*.parquet
+---
+
+# AlphaFoldDB Prediction Index
+
+This repository contains the AlphaFold Protein Structure Database bulk-download files mirrored under `LiteFold/AlphaFoldDB`. The added Parquet files make the accession index loadable in the Hugging Face Dataset Viewer and the `datasets` API.
+
+The default dataset table is built from `accession_ids.csv`. Each row represents one AlphaFold DB prediction entry and includes its UniProt accession, AlphaFold DB identifier, residue range, latest model version, derived sequence length, parsed fragment number, and deterministic split bucket.
+
+The raw FASTA file and structure tar archives are preserved in the repository but are not embedded in the default Parquet table.
+
+## Splits
+
+| Split | Rows | Parquet files |
+|---|---:|---:|
+| train | 222,017,452 | 12 |
+| test | 24,672,064 | 2 |
+| total | 246,689,516 | 14 |
+
+The split is deterministic: `hash(uniprot_accession) % 10 == 0` goes to `test`; buckets `1` through `9` go to `train`.
+
+## Dataset Statistics
+
+| Metric | Value |
+|---|---:|
+| Rows | 246,689,516 |
+| Minimum sequence length | 5 |
+| Approximate median sequence length | 278 |
+| Mean sequence length | 328.55 |
+| Maximum sequence length | 4,186 |
+| Rows without parsed fragment number | 5,619,027 |
+
+Latest-version distribution:
+
+| Latest version | Rows |
+|---|---:|
+| 1 | 5,271,725 |
+| 2 | 347,302 |
+| 6 | 241,070,489 |
+
+The mirrored `download_metadata.json` describes 48 bulk archive files: 16 proteome archives, 30 global-health archives, and 2 Swiss-Prot archives.
+
+## Load With `datasets`
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/AlphaFoldDB")
+print(ds)
+
+row = ds["train"][0]
+print(row)
+```
+
+Load one split directly:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/AlphaFoldDB", split="train")
+test = load_dataset("LiteFold/AlphaFoldDB", split="test")
+```
+
+Stream rows without materializing the full table locally:
+
+```python
+from datasets import load_dataset
+
+streamed = load_dataset("LiteFold/AlphaFoldDB", split="train", streaming=True)
+first_row = next(iter(streamed))
+```
+
+Construct an AlphaFold DB entry URL from a row:
+
+```python
+entry_url = f"https://alphafold.ebi.ac.uk/entry/{row['alphafold_id']}"
+```
+
+Filter to current v6 entries:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/AlphaFoldDB", split="train")
+v6_train = train.filter(lambda row: row["latest_version"] == 6)
+```
+
+For large jobs, prefer streaming or process the Parquet files with a columnar engine such as DuckDB, PyArrow, Polars, or Spark.
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `uniprot_accession` | UniProt accession from `accession_ids.csv`. |
+| `alphafold_id` | AlphaFold DB identifier, for example `AF-Q5VSL9-F1`. |
+| `latest_version` | Latest available AlphaFold DB model version for the entry. |
+| `first_residue_index` | First residue index in UniProt numbering. |
+| `last_residue_index` | Last residue index in UniProt numbering. |
+| `sequence_length` | Derived as `last_residue_index - first_residue_index + 1`. |
+| `fragment_number` | Parsed `F<number>` suffix from `alphafold_id`, nullable when the suffix is absent or nonstandard. |
+| `is_fragmented_prediction` | Whether `fragment_number` is greater than 1. |
+| `split_bucket` | Deterministic bucket from `hash(uniprot_accession) % 10`; bucket 0 is test. |
+
+## Source Files Used
+
+- `accession_ids.csv`
+- `download_metadata.json`
+- `README.txt`
+- `CHANGELOG.txt`
+
+The processed files were generated from the raw files already present in this repository. The preparation script is included at `scripts/prepare_alphafolddb_dataset.py`.

data/test/test-00000-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:56076b3a34849a8c058e57ee1a00a9ad5a857a1dff22be2208c53d0a0cf5240c
+size 267557174

data/test/test-00001-of-00002.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:686fe293d4105b230b7493e10a04735686a06b2d1eaffdc53752b1ae3dd22544
+size 59583977

data/train/train-00000-of-00012.parquet

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

data/train/train-00001-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:60510115338ae3fc65553183b85426f8dff3b83d8a04011a51f85034dca2dca6
+size 262013686

data/train/train-00002-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:53f2eeb4257f550f5513fd1b8ca5b4e3919a8b728b9bca5e797973a9e1533c5d
+size 262074376

data/train/train-00003-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6d30239c9bc7b862dfe62826276ae768786a86b2de35e67d14a6c644af50c278
+size 262022848

data/train/train-00004-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:157784c8c22e1bffac41fae6637ed9a7eb013c4f591a1d72669008af7b4986b2
+size 262091863

data/train/train-00005-of-00012.parquet

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

data/train/train-00006-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:196d7be70d12857e7e888227f645011e96a15a8bbeb4e83527a0736aaa7f27b3
+size 262033933

data/train/train-00007-of-00012.parquet

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

data/train/train-00008-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4dcbfcc9b71397eb384253bd2d13322031f4b4777d239a6f62e2f1074d53faf7
+size 261982412

data/train/train-00009-of-00012.parquet

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

data/train/train-00010-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:14f8ee760e9d630e8df6a6d395dc66e26323ec749ee064d21814a4e062d4915f
+size 262017198

data/train/train-00011-of-00012.parquet

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:239059c7efb0d35975c255a9b0b3526d94e75af947bf8cff1bf54d848ac2e557
+size 144308419

dataset_summary.json

@@ -0,0 +1,52 @@
+{
+  "source": "LiteFold/AlphaFoldDB",
+  "table_source_file": "accession_ids.csv",
+  "split_strategy": "deterministic hash(uniprot_accession) % 10; bucket 0 is test, buckets 1-9 are train",
+  "splits": {
+    "train": 222017452,
+    "test": 24672064
+  },
+  "total_rows": 246689516,
+  "sequence_length": {
+    "min": 5,
+    "median_approx": 278,
+    "mean": 328.55367611974236,
+    "max": 4186
+  },
+  "fragmented_predictions": 0,
+  "rows_without_fragment_number": 5619027,
+  "latest_version": {
+    "min": 1,
+    "max": 6,
+    "counts": {
+      "1": 5271725,
+      "2": 347302,
+      "6": 241070489
+    }
+  },
+  "parquet_files": {
+    "train": 12,
+    "test": 2
+  },
+  "columns": [
+    "uniprot_accession",
+    "alphafold_id",
+    "latest_version",
+    "first_residue_index",
+    "last_residue_index",
+    "sequence_length",
+    "fragment_number",
+    "is_fragmented_prediction",
+    "split_bucket"
+  ],
+  "archive_metadata": {
+    "archive_rows": 48,
+    "archive_types": {
+      "global_health": 30,
+      "proteome": 16,
+      "swissprot": 2
+    },
+    "archive_predicted_structures": 1656090,
+    "archive_size_bytes": 153231764480
+  }
+}

metadata/archive_metadata.parquet

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

scripts/prepare_alphafolddb_dataset.py

@@ -0,0 +1,281 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/AlphaFoldDB."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import re
+import shutil
+from pathlib import Path
+
+import duckdb
+import pandas as pd
+import pyarrow.parquet as pq
+
+
+CSV_COLUMNS_SQL = (
+    "{"
+    "'uniprot_accession':'VARCHAR',"
+    "'first_residue_index':'BIGINT',"
+    "'last_residue_index':'BIGINT',"
+    "'alphafold_id':'VARCHAR',"
+    "'latest_version':'BIGINT'"
+    "}"
+)
+
+
+def sql_string(path: Path) -> str:
+    return "'" + path.as_posix().replace("'", "''") + "'"
+
+
+def entry_source_sql(accession_csv: Path) -> str:
+    source = (
+        f"read_csv({sql_string(accession_csv)}, "
+        f"header=false, columns={CSV_COLUMNS_SQL}, sample_size=100000, "
+        f"strict_mode=false, parallel=false)"
+    )
+    return f"""
+        SELECT
+          uniprot_accession,
+          alphafold_id,
+          latest_version,
+          first_residue_index,
+          last_residue_index,
+          sequence_length,
+          fragment_number,
+          coalesce(fragment_number > 1, false) AS is_fragmented_prediction,
+          split_bucket
+        FROM (
+          SELECT
+            uniprot_accession,
+            alphafold_id,
+            latest_version::UTINYINT AS latest_version,
+            first_residue_index::INTEGER AS first_residue_index,
+            last_residue_index::INTEGER AS last_residue_index,
+            (last_residue_index - first_residue_index + 1)::INTEGER AS sequence_length,
+            try_cast(nullif(regexp_extract(alphafold_id, '-F([0-9]+)$', 1), '') AS INTEGER) AS fragment_number,
+            (hash(uniprot_accession) % 10)::UTINYINT AS split_bucket
+          FROM {source}
+        )
+    """
+
+
+def copy_split(
+    con: duckdb.DuckDBPyConnection,
+    base_sql: str,
+    split: str,
+    condition: str,
+    split_dir: Path,
+    target_file_size: str,
+    row_group_size: int,
+) -> None:
+    split_dir.mkdir(parents=True, exist_ok=True)
+    copy_sql = f"""
+        COPY (
+          SELECT *
+          FROM ({base_sql})
+          WHERE {condition}
+        )
+        TO {sql_string(split_dir)}
+        (
+          FORMAT PARQUET,
+          COMPRESSION ZSTD,
+          ROW_GROUP_SIZE {row_group_size},
+          FILE_SIZE_BYTES {sql_string(Path(target_file_size))}
+        )
+    """
+    con.execute(copy_sql)
+
+    files = sorted(
+        split_dir.glob("data_*.parquet"),
+        key=lambda path: int(re.search(r"data_(\d+)\.parquet$", path.name).group(1)),
+    )
+    total = len(files)
+    for index, path in enumerate(files):
+        path.rename(split_dir / f"{split}-{index:05d}-of-{total:05d}.parquet")
+
+
+def write_archive_metadata(raw_dir: Path, out_dir: Path) -> dict:
+    metadata_path = raw_dir / "download_metadata.json"
+    if not metadata_path.exists():
+        return {}
+
+    records = json.loads(metadata_path.read_text(encoding="utf-8"))
+    df = pd.DataFrame.from_records(records)
+    if df.empty:
+        return {}
+
+    for column in [
+        "archive_name",
+        "species",
+        "common_name",
+        "reference_proteome",
+        "label",
+        "type",
+    ]:
+        if column not in df.columns:
+            df[column] = None
+    if "latin_common_name" not in df.columns:
+        df["latin_common_name"] = None
+
+    df["archive_path"] = "latest/" + df["archive_name"]
+    df["size_gb"] = df["size_bytes"].astype("float64") / 1_000_000_000
+    ordered_columns = [
+        "archive_name",
+        "archive_path",
+        "type",
+        "species",
+        "common_name",
+        "latin_common_name",
+        "reference_proteome",
+        "label",
+        "num_predicted_structures",
+        "size_bytes",
+        "size_gb",
+    ]
+    df = df[ordered_columns]
+
+    metadata_dir = out_dir / "metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+    df.to_parquet(metadata_dir / "archive_metadata.parquet", index=False, compression="zstd")
+
+    return {
+        "archive_rows": int(len(df)),
+        "archive_types": df["type"].value_counts(dropna=False).to_dict(),
+        "archive_predicted_structures": int(df["num_predicted_structures"].sum()),
+        "archive_size_bytes": int(df["size_bytes"].sum()),
+    }
+
+
+def parquet_row_count(paths: list[Path]) -> int:
+    return sum(pq.ParquetFile(path).metadata.num_rows for path in paths)
+
+
+def build_dataset(raw_dir: Path, out_dir: Path, target_file_size: str, row_group_size: int) -> dict:
+    accession_csv = raw_dir / "accession_ids.csv"
+    if not accession_csv.exists():
+        raise FileNotFoundError(f"Missing {accession_csv}")
+
+    data_dir = out_dir / "data"
+    if data_dir.exists():
+        shutil.rmtree(data_dir)
+    data_dir.mkdir(parents=True, exist_ok=True)
+
+    con = duckdb.connect()
+    con.execute("SET preserve_insertion_order=false")
+    con.execute("PRAGMA disable_progress_bar")
+    base_sql = entry_source_sql(accession_csv)
+
+    copy_split(
+        con,
+        base_sql,
+        "train",
+        "split_bucket <> 0",
+        data_dir / "train",
+        target_file_size,
+        row_group_size,
+    )
+    copy_split(
+        con,
+        base_sql,
+        "test",
+        "split_bucket = 0",
+        data_dir / "test",
+        target_file_size,
+        row_group_size,
+    )
+
+    archive_summary = write_archive_metadata(raw_dir, out_dir)
+    train_files = sorted((data_dir / "train").glob("*.parquet"))
+    test_files = sorted((data_dir / "test").glob("*.parquet"))
+    split_counts = {
+        "train": parquet_row_count(train_files),
+        "test": parquet_row_count(test_files),
+    }
+
+    parquet_glob = sql_string(data_dir / "*" / "*.parquet")
+    stats_row = con.execute(
+        f"""
+        SELECT
+          count(*)::UBIGINT AS total_rows,
+          min(sequence_length)::INTEGER AS min_sequence_length,
+          approx_quantile(sequence_length, 0.5)::INTEGER AS median_sequence_length,
+          avg(sequence_length)::DOUBLE AS mean_sequence_length,
+          max(sequence_length)::INTEGER AS max_sequence_length,
+          sum(CASE WHEN is_fragmented_prediction THEN 1 ELSE 0 END)::UBIGINT AS fragmented_predictions,
+          sum(CASE WHEN fragment_number IS NULL THEN 1 ELSE 0 END)::UBIGINT AS rows_without_fragment_number,
+          min(latest_version)::UTINYINT AS min_latest_version,
+          max(latest_version)::UTINYINT AS max_latest_version
+        FROM read_parquet({parquet_glob})
+        """
+    ).fetchone()
+    version_counts = {
+        str(version): int(count)
+        for version, count in con.execute(
+            f"""
+            SELECT latest_version, count(*) AS row_count
+            FROM read_parquet({parquet_glob})
+            GROUP BY 1
+            ORDER BY 1
+            """
+        ).fetchall()
+    }
+
+    summary = {
+        "source": "LiteFold/AlphaFoldDB",
+        "table_source_file": "accession_ids.csv",
+        "split_strategy": "deterministic hash(uniprot_accession) % 10; bucket 0 is test, buckets 1-9 are train",
+        "splits": {
+            "train": split_counts.get("train", 0),
+            "test": split_counts.get("test", 0),
+        },
+        "total_rows": int(stats_row[0]),
+        "sequence_length": {
+            "min": int(stats_row[1]),
+            "median_approx": int(stats_row[2]),
+            "mean": float(stats_row[3]),
+            "max": int(stats_row[4]),
+        },
+        "fragmented_predictions": int(stats_row[5]),
+        "rows_without_fragment_number": int(stats_row[6]),
+        "latest_version": {
+            "min": int(stats_row[7]),
+            "max": int(stats_row[8]),
+            "counts": version_counts,
+        },
+        "parquet_files": {
+            "train": len(train_files),
+            "test": len(test_files),
+        },
+        "columns": [
+            "uniprot_accession",
+            "alphafold_id",
+            "latest_version",
+            "first_residue_index",
+            "last_residue_index",
+            "sequence_length",
+            "fragment_number",
+            "is_fragmented_prediction",
+            "split_bucket",
+        ],
+        "archive_metadata": archive_summary,
+    }
+    (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_AlphaFoldDB_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_AlphaFoldDB_processed"))
+    parser.add_argument("--target-file-size", default="256MB")
+    parser.add_argument("--row-group-size", type=int, default=1_000_000)
+    args = parser.parse_args()
+
+    summary = build_dataset(args.raw_dir, args.out_dir, args.target_file_size, args.row_group_size)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()