Add normalized Parquet train/test splits

README.md

@@ -0,0 +1,135 @@
+---
+pretty_name: CATH Domain Classification
+license: cc-by-4.0
+tags:
+- biology
+- proteins
+- protein-structure
+- cath
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# CATH Domain Classification
+
+This repository contains CATH v4.4.0 protein domain classification data packaged for the Hugging Face Dataset Viewer and the `datasets` API.
+
+The original raw CATH files are preserved in this dataset repository. The added Parquet files normalize the domain list, domain FASTA sequences, hierarchy names, and nonredundant subset membership into a single tabular dataset with deterministic train/test splits.
+
+## Splits
+
+| Split | Rows |
+|---|---:|
+| train | 541,123 |
+| test | 60,205 |
+| total | 601,328 |
+
+The split is deterministic and S35-cluster-aware: all domains sharing the same CATH homologous superfamily and S35 cluster key are kept in the same split. This avoids putting close S35-cluster relatives in both train and test.
+
+## Dataset Statistics
+
+| Metric | Value |
+|---|---:|
+| Domains | 601,328 |
+| Unique S35 cluster keys | 37,350 |
+| Unique homologous superfamilies | 6,630 |
+| Unique topologies | 1,472 |
+| Unique architectures | 43 |
+| Train/test S35 cluster overlap | 0 |
+| Unknown structure-resolution sentinel rows | 9,726 |
+
+Class distribution:
+
+| CATH class | Rows |
+|---|---:|
+| Alpha Beta | 305,361 |
+| Mainly Beta | 158,943 |
+| Mainly Alpha | 126,178 |
+| Few Secondary Structures | 6,034 |
+| Special | 4,812 |
+
+Sequence length ranges from 9 to 1,275 amino acids, with a median length of 140.
+
+## Load With `datasets`
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/CATH")
+print(ds)
+
+train = ds["train"]
+test = ds["test"]
+
+print(train[0])
+```
+
+Load one split directly:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/CATH", split="train")
+test = load_dataset("LiteFold/CATH", split="test")
+```
+
+Stream rows without downloading the full dataset first:
+
+```python
+from datasets import load_dataset
+
+streamed = load_dataset("LiteFold/CATH", split="train", streaming=True)
+first_row = next(iter(streamed))
+```
+
+Filter to one of the CATH nonredundant representative subsets:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/CATH", split="train")
+s35_train = ds.filter(lambda row: row["in_s35_nonredundant_subset"])
+```
+
+## Main Columns
+
+| Column | Description |
+|---|---|
+| `domain_id` | CATH domain identifier, for example `1oaiA00`. |
+| `pdb_id`, `chain_id`, `pdb_chain_id` | Parsed PDB and chain identifiers. |
+| `cath_version` | CATH release version from the FASTA headers. |
+| `cath_code` | Full CATH classification code at homologous superfamily level. |
+| `class_*`, `architecture_*`, `topology_*`, `homologous_superfamily_*` | Numeric codes, full hierarchy codes, names, and example domains. |
+| `s35_cluster_id`, `s60_cluster_id`, `s95_cluster_id`, `s100_cluster_id` | CATH sequence cluster identifiers from the domain list. |
+| `s35_cluster_key` | Composite key used for leakage-aware splitting. |
+| `domain_length` | Domain length from the CATH domain list. |
+| `raw_structure_resolution_angstrom` | Original structure resolution value. |
+| `structure_resolution_angstrom` | Resolution with CATH's `999.000` unknown sentinel converted to null. |
+| `sequence` | Amino acid sequence from `cath-domain-seqs.fa`. |
+| `sequence_length` | Length of `sequence`. |
+| `sequence_range` | Source FASTA residue range, including discontinuous ranges such as `2-78_187-208`. |
+| `sequence_range_start`, `sequence_range_end` | Parsed min start and max end residue positions when available. |
+| `sequence_segment_count` | Number of underscore-separated residue segments in `sequence_range`. |
+| `in_s35_nonredundant_subset`, `in_s60_nonredundant_subset`, `in_s95_nonredundant_subset`, `in_s100_nonredundant_subset` | Whether the domain appears in the corresponding CATH nonredundant subset list. |
+
+## Source Files Used
+
+- `cath-domain-list.txt`
+- `cath-domain-list-S35.txt`
+- `cath-domain-list-S60.txt`
+- `cath-domain-list-S95.txt`
+- `cath-domain-list-S100.txt`
+- `cath-domain-seqs.fa`
+- `cath-names.txt`
+
+The raw PDB tarball remains in the repository, but it is not embedded in the Parquet table.
+
+## Reproducibility
+
+The processed files were generated from the raw files already present in this repository. The preparation script parses CATH v4.4.0 source rows, joins sequences and hierarchy names, adds subset flags, and writes `data/train-00000-of-00001.parquet` and `data/test-00000-of-00001.parquet`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,64 @@
+{
+  "source": "LiteFold/CATH",
+  "cath_version": "4.4.0",
+  "total_rows": 601328,
+  "splits": {
+    "train": 541123,
+    "test": 60205
+  },
+  "test_size_requested": 0.1,
+  "split_strategy": "deterministic S35-cluster-aware split using sha256(s35_cluster_key)",
+  "unique_s35_clusters": 37350,
+  "columns": [
+    "domain_id",
+    "pdb_id",
+    "chain_id",
+    "pdb_chain_id",
+    "domain_suffix",
+    "domain_index",
+    "cath_version",
+    "cath_code",
+    "class_number",
+    "class_code",
+    "class_name",
+    "class_example_domain_id",
+    "architecture_number",
+    "architecture_code",
+    "architecture_name",
+    "architecture_example_domain_id",
+    "topology_number",
+    "topology_code",
+    "topology_name",
+    "topology_example_domain_id",
+    "homologous_superfamily_number",
+    "homologous_superfamily_code",
+    "homologous_superfamily_name",
+    "homologous_superfamily_example_domain_id",
+    "s35_cluster_id",
+    "s60_cluster_id",
+    "s95_cluster_id",
+    "s100_cluster_id",
+    "s100_sequence_count",
+    "s35_cluster_key",
+    "domain_length",
+    "raw_structure_resolution_angstrom",
+    "structure_resolution_angstrom",
+    "structure_resolution_is_unknown",
+    "sequence",
+    "sequence_length",
+    "sequence_range",
+    "sequence_range_start",
+    "sequence_range_end",
+    "sequence_segment_count",
+    "in_s35_nonredundant_subset",
+    "in_s60_nonredundant_subset",
+    "in_s95_nonredundant_subset",
+    "in_s100_nonredundant_subset"
+  ],
+  "subset_rows": {
+    "s35": 37350,
+    "s60": 52974,
+    "s95": 73535,
+    "s100": 123251
+  }
+}

scripts/prepare_cath_dataset.py

@@ -0,0 +1,319 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/CATH."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from pathlib import Path
+
+import pandas as pd
+
+
+DOMAIN_COLUMNS = [
+    "domain_id",
+    "class_number",
+    "architecture_number",
+    "topology_number",
+    "homologous_superfamily_number",
+    "s35_cluster_id",
+    "s60_cluster_id",
+    "s95_cluster_id",
+    "s100_cluster_id",
+    "s100_sequence_count",
+    "domain_length",
+    "raw_structure_resolution_angstrom",
+]
+
+
+def iter_data_lines(path: Path):
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.rstrip("\n")
+            if not line or line.startswith("#"):
+                continue
+            yield line
+
+
+def parse_domain_list(path: Path) -> pd.DataFrame:
+    records = []
+    for line in iter_data_lines(path):
+        parts = line.split()
+        if len(parts) != len(DOMAIN_COLUMNS):
+            raise ValueError(f"Expected {len(DOMAIN_COLUMNS)} columns in {path}, got {len(parts)}: {line}")
+        records.append(parts)
+
+    df = pd.DataFrame(records, columns=DOMAIN_COLUMNS)
+    int_columns = [
+        "class_number",
+        "architecture_number",
+        "topology_number",
+        "homologous_superfamily_number",
+        "s35_cluster_id",
+        "s60_cluster_id",
+        "s95_cluster_id",
+        "s100_cluster_id",
+        "s100_sequence_count",
+        "domain_length",
+    ]
+    for col in int_columns:
+        df[col] = df[col].astype("int64")
+    df["raw_structure_resolution_angstrom"] = df["raw_structure_resolution_angstrom"].astype("float64")
+    df["structure_resolution_is_unknown"] = df["raw_structure_resolution_angstrom"].eq(999.0)
+    df["structure_resolution_angstrom"] = df["raw_structure_resolution_angstrom"].mask(
+        df["structure_resolution_is_unknown"]
+    )
+    df["structure_resolution_angstrom"] = df["structure_resolution_angstrom"].astype("Float64")
+
+    df["pdb_id"] = df["domain_id"].str.slice(0, 4)
+    df["chain_id"] = df["domain_id"].str.slice(4, 5)
+    df["pdb_chain_id"] = df["domain_id"].str.slice(0, 5)
+    df["domain_suffix"] = df["domain_id"].str.slice(5, 7)
+    df["domain_index"] = df["domain_suffix"].astype("int64")
+
+    df["class_code"] = df["class_number"].astype(str)
+    df["architecture_code"] = df["class_code"] + "." + df["architecture_number"].astype(str)
+    df["topology_code"] = df["architecture_code"] + "." + df["topology_number"].astype(str)
+    df["homologous_superfamily_code"] = (
+        df["topology_code"] + "." + df["homologous_superfamily_number"].astype(str)
+    )
+    df["cath_code"] = df["homologous_superfamily_code"]
+    df["s35_cluster_key"] = df["homologous_superfamily_code"] + ":S35:" + df["s35_cluster_id"].astype(str)
+    return df
+
+
+def parse_names(path: Path) -> pd.DataFrame:
+    records = []
+    for line in iter_data_lines(path):
+        if ":" not in line:
+            continue
+        left, name = line.split(":", 1)
+        parts = left.split()
+        if len(parts) < 2:
+            continue
+        records.append(
+            {
+                "cath_node_code": parts[0],
+                "example_domain_id": parts[1],
+                "cath_node_name": name.strip(),
+            }
+        )
+    return pd.DataFrame.from_records(records)
+
+
+_RANGE_SEGMENT_RE = re.compile(r"^\s*(-?\d+)(?:\([A-Za-z0-9]+\))?-(-?\d+)(?:\([A-Za-z0-9]+\))?\s*$")
+
+
+def parse_range_summary(sequence_range: str) -> tuple[int | None, int | None, int]:
+    starts: list[int] = []
+    ends: list[int] = []
+    segments = [segment for segment in sequence_range.split("_") if segment]
+    for segment in segments:
+        match = _RANGE_SEGMENT_RE.match(segment)
+        if not match:
+            continue
+        starts.append(int(match.group(1)))
+        ends.append(int(match.group(2)))
+    if not starts:
+        return None, None, len(segments)
+    return min(starts), max(ends), len(segments)
+
+
+def parse_fasta(path: Path) -> pd.DataFrame:
+    records = []
+    header: str | None = None
+    sequence_chunks: list[str] = []
+
+    def flush() -> None:
+        if header is None:
+            return
+        try:
+            _, version, payload = header.split("|", 2)
+            domain_id, sequence_range = payload.split("/", 1)
+        except ValueError as exc:
+            raise ValueError(f"Unexpected FASTA header in {path}: {header}") from exc
+        sequence = "".join(sequence_chunks)
+        start, end, segment_count = parse_range_summary(sequence_range)
+        records.append(
+            {
+                "domain_id": domain_id,
+                "cath_version": version.replace("_", "."),
+                "sequence": sequence,
+                "sequence_length": len(sequence),
+                "sequence_range": sequence_range,
+                "sequence_range_start": start,
+                "sequence_range_end": end,
+                "sequence_segment_count": segment_count,
+            }
+        )
+
+    with path.open("r", encoding="utf-8") as handle:
+        for line in handle:
+            line = line.strip()
+            if not line:
+                continue
+            if line.startswith(">"):
+                flush()
+                header = line[1:]
+                sequence_chunks = []
+            else:
+                sequence_chunks.append(line)
+    flush()
+    return pd.DataFrame.from_records(records)
+
+
+def subset_domain_ids(path: Path) -> set[str]:
+    return {line.split()[0] for line in iter_data_lines(path)}
+
+
+def stable_hash_int(value: str) -> int:
+    return int(hashlib.sha256(value.encode("utf-8")).hexdigest()[:16], 16)
+
+
+def add_cluster_aware_split(df: pd.DataFrame, test_size: float) -> pd.DataFrame:
+    cluster_counts = (
+        df.groupby("s35_cluster_key", sort=False)
+        .size()
+        .rename("row_count")
+        .reset_index()
+    )
+    cluster_counts["hash"] = cluster_counts["s35_cluster_key"].map(stable_hash_int)
+    cluster_counts = cluster_counts.sort_values(["hash", "s35_cluster_key"], kind="mergesort")
+
+    target_rows = round(len(df) * test_size)
+    test_keys: set[str] = set()
+    test_rows = 0
+    for row in cluster_counts.itertuples(index=False):
+        if test_rows >= target_rows:
+            break
+        test_keys.add(row.s35_cluster_key)
+        test_rows += int(row.row_count)
+
+    df = df.copy()
+    df["split"] = df["s35_cluster_key"].map(lambda key: "test" if key in test_keys else "train")
+    return df
+
+
+def build_dataset(raw_dir: Path, out_dir: Path, test_size: float) -> dict:
+    domains = parse_domain_list(raw_dir / "cath-domain-list.txt")
+    names = parse_names(raw_dir / "cath-names.txt")
+    names_by_code = names.set_index("cath_node_code")
+
+    for level, code_col in [
+        ("class", "class_code"),
+        ("architecture", "architecture_code"),
+        ("topology", "topology_code"),
+        ("homologous_superfamily", "homologous_superfamily_code"),
+    ]:
+        domains[f"{level}_name"] = domains[code_col].map(names_by_code["cath_node_name"])
+        domains[f"{level}_example_domain_id"] = domains[code_col].map(names_by_code["example_domain_id"])
+
+    sequences = parse_fasta(raw_dir / "cath-domain-seqs.fa")
+    df = domains.merge(sequences, on="domain_id", how="left", validate="one_to_one")
+
+    missing_sequences = int(df["sequence"].isna().sum())
+    if missing_sequences:
+        raise ValueError(f"{missing_sequences} domain-list rows did not have FASTA sequences")
+
+    for subset in ["S35", "S60", "S95", "S100"]:
+        ids = subset_domain_ids(raw_dir / f"cath-domain-list-{subset}.txt")
+        df[f"in_{subset.lower()}_nonredundant_subset"] = df["domain_id"].isin(ids)
+
+    df = add_cluster_aware_split(df, test_size)
+
+    ordered_columns = [
+        "domain_id",
+        "pdb_id",
+        "chain_id",
+        "pdb_chain_id",
+        "domain_suffix",
+        "domain_index",
+        "cath_version",
+        "cath_code",
+        "class_number",
+        "class_code",
+        "class_name",
+        "class_example_domain_id",
+        "architecture_number",
+        "architecture_code",
+        "architecture_name",
+        "architecture_example_domain_id",
+        "topology_number",
+        "topology_code",
+        "topology_name",
+        "topology_example_domain_id",
+        "homologous_superfamily_number",
+        "homologous_superfamily_code",
+        "homologous_superfamily_name",
+        "homologous_superfamily_example_domain_id",
+        "s35_cluster_id",
+        "s60_cluster_id",
+        "s95_cluster_id",
+        "s100_cluster_id",
+        "s100_sequence_count",
+        "s35_cluster_key",
+        "domain_length",
+        "raw_structure_resolution_angstrom",
+        "structure_resolution_angstrom",
+        "structure_resolution_is_unknown",
+        "sequence",
+        "sequence_length",
+        "sequence_range",
+        "sequence_range_start",
+        "sequence_range_end",
+        "sequence_segment_count",
+        "in_s35_nonredundant_subset",
+        "in_s60_nonredundant_subset",
+        "in_s95_nonredundant_subset",
+        "in_s100_nonredundant_subset",
+        "split",
+    ]
+    df = df[ordered_columns].sort_values(["split", "domain_id"], kind="mergesort")
+
+    data_dir = out_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    split_counts = {}
+    for split in ["train", "test"]:
+        split_df = df[df["split"].eq(split)].drop(columns=["split"])
+        split_counts[split] = len(split_df)
+        split_df.to_parquet(
+            data_dir / f"{split}-00000-of-00001.parquet",
+            index=False,
+            compression="zstd",
+        )
+
+    summary = {
+        "source": "LiteFold/CATH",
+        "cath_version": str(df["cath_version"].iloc[0]),
+        "total_rows": len(df),
+        "splits": split_counts,
+        "test_size_requested": test_size,
+        "split_strategy": "deterministic S35-cluster-aware split using sha256(s35_cluster_key)",
+        "unique_s35_clusters": int(df["s35_cluster_key"].nunique()),
+        "columns": [column for column in ordered_columns if column != "split"],
+        "subset_rows": {
+            "s35": int(df["in_s35_nonredundant_subset"].sum()),
+            "s60": int(df["in_s60_nonredundant_subset"].sum()),
+            "s95": int(df["in_s95_nonredundant_subset"].sum()),
+            "s100": int(df["in_s100_nonredundant_subset"].sum()),
+        },
+    }
+    (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_CATH_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_CATH_processed"))
+    parser.add_argument("--test-size", type=float, default=0.10)
+    args = parser.parse_args()
+
+    summary = build_dataset(args.raw_dir, args.out_dir, args.test_size)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()