Add normalized Parquet train/test GO term table

README.md

@@ -0,0 +1,159 @@
+---
+pretty_name: Gene Ontology Terms
+license: cc-by-4.0
+tags:
+- biology
+- ontology
+- gene-ontology
+- go
+- obo
+- parquet
+configs:
+- config_name: default
+  data_files:
+  - split: train
+    path: data/train-*.parquet
+  - split: test
+    path: data/test-*.parquet
+---
+
+# Gene Ontology Terms
+
+This dataset contains a viewer-friendly Parquet table derived from the Gene Ontology OBO files in this repository. Each row is one `[Term]` stanza from `go.obo`, with repeated OBO fields stored as list columns.
+
+The original source files are preserved in the repository:
+
+- `go.obo`
+- `go-basic.obo`
+
+`in_go_basic` marks whether a term is also present in `go-basic.obo`. Relationship typedef metadata from `go.obo` is available as `metadata/typedefs.parquet`.
+
+## Splits
+
+The split is deterministic by GO identifier: `sha256(go_id) % 10`. Bucket `0` is `test`; buckets `1` through `9` are `train`.
+
+| Split | Rows |
+|---|---:|
+| train | 43,522 |
+| test | 4,769 |
+| total | 48,291 |
+
+## Dataset Statistics
+
+| Field | Value |
+|---|---:|
+| GO release | `releases/2026-03-25` |
+| Terms | 48,291 |
+| Typedefs | 11 |
+| Terms in `go-basic.obo` | 48,291 |
+| Active terms | 38,560 |
+| Obsolete terms | 9,731 |
+
+| Namespace | Rows |
+|---|---:|
+| biological_process | 30,857 |
+| molecular_function | 12,839 |
+| cellular_component | 4,595 |
+
+## Usage
+
+Install the Hugging Face Datasets library:
+
+```bash
+pip install datasets
+```
+
+Load all splits:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/GO")
+print(ds)
+
+row = ds["train"][0]
+print(row["go_id"], row["name"], row["namespace"])
+```
+
+Load one split:
+
+```python
+from datasets import load_dataset
+
+train = load_dataset("LiteFold/GO", split="train")
+test = load_dataset("LiteFold/GO", split="test")
+```
+
+Stream rows without downloading the full table first:
+
+```python
+from datasets import load_dataset
+
+stream = load_dataset("LiteFold/GO", split="train", streaming=True)
+for row in stream.take(5):
+    print(row["go_id"], row["name"])
+```
+
+Filter active biological process terms:
+
+```python
+from datasets import load_dataset
+
+ds = load_dataset("LiteFold/GO", split="train")
+active_bp = ds.filter(
+    lambda row: row["namespace"] == "biological_process" and not row["is_obsolete"]
+)
+print(active_bp[0])
+```
+
+Load typedef metadata directly:
+
+```python
+import pandas as pd
+from huggingface_hub import hf_hub_download
+
+path = hf_hub_download(
+    repo_id="LiteFold/GO",
+    repo_type="dataset",
+    filename="metadata/typedefs.parquet",
+)
+typedefs = pd.read_parquet(path)
+print(typedefs[["id", "name"]].head())
+```
+
+## Columns
+
+| Column | Description |
+|---|---|
+| `go_id` | GO identifier, such as `GO:0008150`. |
+| `go_numeric_id` | Numeric portion of `go_id`. |
+| `name` | Term name. |
+| `namespace` | GO namespace: `biological_process`, `molecular_function`, or `cellular_component`. |
+| `definition` | Parsed OBO definition text. |
+| `definition_xrefs` | Cross-references attached to the definition. |
+| `comment` | OBO comment text, when present. |
+| `synonyms` | Parsed synonym strings. |
+| `synonym_scopes` | Scope for each synonym, such as `EXACT`, `BROAD`, `NARROW`, or `RELATED`. |
+| `alt_ids` | Alternate GO identifiers. |
+| `subsets` | GO subsets or slims containing the term. |
+| `xrefs` | Term cross-references. |
+| `is_a_ids` | Direct `is_a` parent GO identifiers. |
+| `relationship_edges` | Raw relationship edges with comments removed. |
+| `relationship_types` | Relationship predicates, such as `part_of` or `regulates`. |
+| `relationship_target_ids` | GO identifiers targeted by relationship edges. |
+| `parent_ids` | Combined unique `is_a_ids` and `relationship_target_ids`. |
+| `intersection_of` | Parsed `intersection_of` entries. |
+| `union_of` | Parsed `union_of` entries. |
+| `disjoint_from` | Parsed `disjoint_from` entries. |
+| `replaced_by` | Replacement IDs for obsolete terms. |
+| `consider` | Suggested replacement IDs for obsolete terms. |
+| `property_values` | Raw OBO property values. |
+| `created_by` | Creator metadata, when present. |
+| `creation_date` | Creation date metadata, when present. |
+| `is_obsolete` | Whether the term is obsolete. |
+| `in_go_basic` | Whether the same GO ID appears in `go-basic.obo`. |
+| `split_bucket` | Deterministic split bucket from `sha256(go_id) % 10`. |
+
+## Preparation
+
+The normalization script used to create the Parquet files is included at `scripts/prepare_go_dataset.py`.

data/test-00000-of-00001.parquet

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

data/train-00000-of-00001.parquet

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

dataset_summary.json

@@ -0,0 +1,86 @@
+{
+  "source": "LiteFold/GO",
+  "data_version": "releases/2026-03-25",
+  "ontology": "go",
+  "license": "terms:license http://creativecommons.org/licenses/by/4.0/",
+  "term_rows": 48291,
+  "typedef_rows": 11,
+  "go_basic_term_rows": 48291,
+  "terms_in_go_basic": 48291,
+  "splits": {
+    "train": 43522,
+    "test": 4769
+  },
+  "split_strategy": "deterministic sha256(go_id) % 10; bucket 0 is test, buckets 1-9 are train",
+  "namespace_counts": {
+    "biological_process": 30857,
+    "molecular_function": 12839,
+    "cellular_component": 4595
+  },
+  "obsolete_counts": {
+    "False": 38560,
+    "True": 9731
+  },
+  "top_relationship_types": {
+    "part_of": 7094,
+    "regulates": 2975,
+    "negatively_regulates": 2656,
+    "positively_regulates": 2656,
+    "has_part": 807,
+    "occurs_in": 174,
+    "happens_during": 13,
+    "ends_during": 1
+  },
+  "top_subsets": {
+    "gocheck_obsoletion_candidate": 544,
+    "gocheck_do_not_annotate": 460,
+    "goslim_pir": 426,
+    "goslim_synapse": 335,
+    "goslim_chembl": 294,
+    "goslim_drosophila": 173,
+    "goslim_yeast": 155,
+    "goslim_generic": 140,
+    "goslim_metagenomics": 111,
+    "goslim_prokaryote": 97,
+    "goslim_plant": 97,
+    "goslim_candida": 86,
+    "goslim_pombe": 64,
+    "goslim_plant_ribbon": 62,
+    "goslim_euk_cellular_processes_ribbon": 61,
+    "goslim_agr": 53,
+    "goslim_prokaryote_ribbon": 49,
+    "goslim_mouse": 45,
+    "goslim_flybase_ribbon": 44,
+    "goslim_virus": 20
+  },
+  "columns": [
+    "go_id",
+    "go_numeric_id",
+    "name",
+    "namespace",
+    "definition",
+    "definition_xrefs",
+    "comment",
+    "synonyms",
+    "synonym_scopes",
+    "alt_ids",
+    "subsets",
+    "xrefs",
+    "is_a_ids",
+    "relationship_edges",
+    "relationship_types",
+    "relationship_target_ids",
+    "parent_ids",
+    "intersection_of",
+    "union_of",
+    "disjoint_from",
+    "replaced_by",
+    "consider",
+    "property_values",
+    "created_by",
+    "creation_date",
+    "is_obsolete",
+    "in_go_basic",
+    "split_bucket"
+  ]
+}

metadata/typedefs.parquet

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

scripts/prepare_go_dataset.py

@@ -0,0 +1,278 @@
+#!/usr/bin/env python3
+"""Build viewer-friendly Parquet splits for LiteFold/GO."""
+
+from __future__ import annotations
+
+import argparse
+import hashlib
+import json
+import re
+from collections import Counter, defaultdict
+from pathlib import Path
+
+import pandas as pd
+
+
+TERM_COLUMNS = [
+    "go_id",
+    "go_numeric_id",
+    "name",
+    "namespace",
+    "definition",
+    "definition_xrefs",
+    "comment",
+    "synonyms",
+    "synonym_scopes",
+    "alt_ids",
+    "subsets",
+    "xrefs",
+    "is_a_ids",
+    "relationship_edges",
+    "relationship_types",
+    "relationship_target_ids",
+    "parent_ids",
+    "intersection_of",
+    "union_of",
+    "disjoint_from",
+    "replaced_by",
+    "consider",
+    "property_values",
+    "created_by",
+    "creation_date",
+    "is_obsolete",
+    "in_go_basic",
+    "split_bucket",
+]
+
+
+def split_unquoted_comment(value: str) -> str:
+    in_quote = False
+    escaped = False
+    for index, char in enumerate(value):
+        if escaped:
+            escaped = False
+            continue
+        if char == "\\":
+            escaped = True
+            continue
+        if char == '"':
+            in_quote = not in_quote
+            continue
+        if char == "!" and not in_quote:
+            return value[:index].strip()
+    return value.strip()
+
+
+def parse_quoted_xrefs(value: str) -> tuple[str | None, list[str]]:
+    match = re.match(r'^"((?:[^"\\]|\\.)*)"\s*(?:\[(.*)\])?', value.strip())
+    if not match:
+        return value.strip() or None, []
+    text = bytes(match.group(1), "utf-8").decode("unicode_escape")
+    xrefs = []
+    if match.group(2):
+        xrefs = [part.strip() for part in match.group(2).split(",") if part.strip()]
+    return text, xrefs
+
+
+def parse_synonym(value: str) -> tuple[str | None, str | None]:
+    match = re.match(r'^"((?:[^"\\]|\\.)*)"\s+([A-Z]+)', value.strip())
+    if not match:
+        return value.strip() or None, None
+    text = bytes(match.group(1), "utf-8").decode("unicode_escape")
+    return text, match.group(2)
+
+
+def stable_bucket(value: str, buckets: int = 10) -> int:
+    digest = hashlib.sha256(value.encode("utf-8")).hexdigest()[:16]
+    return int(digest, 16) % buckets
+
+
+def parse_obo(path: Path) -> tuple[dict[str, list[str]], list[dict[str, list[str]]], list[dict[str, list[str]]]]:
+    header: dict[str, list[str]] = defaultdict(list)
+    terms: list[dict[str, list[str]]] = []
+    typedefs: list[dict[str, list[str]]] = []
+    current_type: str | None = None
+    current: dict[str, list[str]] | None = None
+
+    def flush() -> None:
+        nonlocal current, current_type
+        if current is None:
+            return
+        if current_type == "Term":
+            terms.append(current)
+        elif current_type == "Typedef":
+            typedefs.append(current)
+        current = None
+        current_type = None
+
+    with path.open("r", encoding="utf-8", errors="replace") as handle:
+        for raw_line in handle:
+            line = raw_line.rstrip("\n")
+            if not line or line.startswith("!"):
+                continue
+            if line.startswith("[") and line.endswith("]"):
+                flush()
+                current_type = line.strip("[]")
+                current = defaultdict(list)
+                continue
+            if ": " not in line:
+                continue
+            key, value = line.split(": ", 1)
+            target = header if current is None else current
+            target[key].append(value.strip())
+    flush()
+    return dict(header), terms, typedefs
+
+
+def first(stanza: dict[str, list[str]], key: str) -> str | None:
+    values = stanza.get(key) or []
+    return values[0] if values else None
+
+
+def list_values(stanza: dict[str, list[str]], key: str, strip_comment: bool = False) -> list[str]:
+    values = stanza.get(key) or []
+    if strip_comment:
+        return [split_unquoted_comment(value) for value in values]
+    return list(values)
+
+
+def term_to_row(stanza: dict[str, list[str]], basic_ids: set[str]) -> dict:
+    go_id = first(stanza, "id") or ""
+    definition, definition_xrefs = parse_quoted_xrefs(first(stanza, "def") or "")
+    synonyms = []
+    synonym_scopes = []
+    for value in stanza.get("synonym", []):
+        synonym, scope = parse_synonym(value)
+        if synonym:
+            synonyms.append(synonym)
+            synonym_scopes.append(scope or "")
+
+    relationship_edges = list_values(stanza, "relationship", strip_comment=True)
+    relationship_types = []
+    relationship_target_ids = []
+    for edge in relationship_edges:
+        parts = edge.split()
+        if len(parts) >= 2:
+            relationship_types.append(parts[0])
+            relationship_target_ids.append(parts[1])
+
+    is_a_ids = [value.split()[0] for value in list_values(stanza, "is_a", strip_comment=True)]
+    parent_ids = sorted(set(is_a_ids + relationship_target_ids))
+    split_bucket = stable_bucket(go_id)
+    numeric = None
+    match = re.match(r"GO:(\d+)$", go_id)
+    if match:
+        numeric = int(match.group(1))
+
+    return {
+        "go_id": go_id,
+        "go_numeric_id": numeric,
+        "name": first(stanza, "name"),
+        "namespace": first(stanza, "namespace"),
+        "definition": definition,
+        "definition_xrefs": definition_xrefs,
+        "comment": " ".join(stanza.get("comment", [])) or None,
+        "synonyms": synonyms,
+        "synonym_scopes": synonym_scopes,
+        "alt_ids": list_values(stanza, "alt_id"),
+        "subsets": list_values(stanza, "subset"),
+        "xrefs": list_values(stanza, "xref", strip_comment=True),
+        "is_a_ids": is_a_ids,
+        "relationship_edges": relationship_edges,
+        "relationship_types": relationship_types,
+        "relationship_target_ids": relationship_target_ids,
+        "parent_ids": parent_ids,
+        "intersection_of": list_values(stanza, "intersection_of", strip_comment=True),
+        "union_of": list_values(stanza, "union_of", strip_comment=True),
+        "disjoint_from": list_values(stanza, "disjoint_from", strip_comment=True),
+        "replaced_by": list_values(stanza, "replaced_by", strip_comment=True),
+        "consider": list_values(stanza, "consider", strip_comment=True),
+        "property_values": list_values(stanza, "property_value"),
+        "created_by": first(stanza, "created_by"),
+        "creation_date": first(stanza, "creation_date"),
+        "is_obsolete": (first(stanza, "is_obsolete") or "").lower() == "true",
+        "in_go_basic": go_id in basic_ids,
+        "split_bucket": split_bucket,
+    }
+
+
+def typedef_to_row(stanza: dict[str, list[str]]) -> dict:
+    definition, definition_xrefs = parse_quoted_xrefs(first(stanza, "def") or "")
+    return {
+        "id": first(stanza, "id"),
+        "name": first(stanza, "name"),
+        "namespace": first(stanza, "namespace"),
+        "definition": definition,
+        "definition_xrefs": definition_xrefs,
+        "is_transitive": first(stanza, "is_transitive"),
+        "is_metadata_tag": first(stanza, "is_metadata_tag"),
+        "is_class_level": first(stanza, "is_class_level"),
+        "domain": list_values(stanza, "domain", strip_comment=True),
+        "range": list_values(stanza, "range", strip_comment=True),
+        "holds_over_chain": list_values(stanza, "holds_over_chain", strip_comment=True),
+        "inverse_of": list_values(stanza, "inverse_of", strip_comment=True),
+        "transitive_over": list_values(stanza, "transitive_over", strip_comment=True),
+        "property_values": list_values(stanza, "property_value"),
+    }
+
+
+def build_dataset(raw_dir: Path, out_dir: Path) -> dict:
+    header, terms, typedefs = parse_obo(raw_dir / "go.obo")
+    _, basic_terms, _ = parse_obo(raw_dir / "go-basic.obo")
+    basic_ids = {first(term, "id") for term in basic_terms if first(term, "id")}
+
+    rows = [term_to_row(term, basic_ids) for term in terms]
+    df = pd.DataFrame.from_records(rows, columns=TERM_COLUMNS)
+    df = df.sort_values(["split_bucket", "go_id"], kind="mergesort")
+
+    data_dir = out_dir / "data"
+    data_dir.mkdir(parents=True, exist_ok=True)
+    train = df[df["split_bucket"].ne(0)].sort_values("go_id", kind="mergesort")
+    test = df[df["split_bucket"].eq(0)].sort_values("go_id", kind="mergesort")
+    train.to_parquet(data_dir / "train-00000-of-00001.parquet", index=False, compression="zstd")
+    test.to_parquet(data_dir / "test-00000-of-00001.parquet", index=False, compression="zstd")
+
+    metadata_dir = out_dir / "metadata"
+    metadata_dir.mkdir(parents=True, exist_ok=True)
+    typedef_df = pd.DataFrame.from_records([typedef_to_row(item) for item in typedefs])
+    typedef_df.to_parquet(metadata_dir / "typedefs.parquet", index=False, compression="zstd")
+
+    namespace_counts = df["namespace"].value_counts(dropna=False).to_dict()
+    obsolete_counts = df["is_obsolete"].value_counts(dropna=False).to_dict()
+    relation_counts = Counter(rel for rels in df["relationship_types"] for rel in rels)
+    subset_counts = Counter(subset for subsets in df["subsets"] for subset in subsets)
+    summary = {
+        "source": "LiteFold/GO",
+        "data_version": (header.get("data-version") or [None])[0],
+        "ontology": (header.get("ontology") or [None])[0],
+        "license": next((value for value in header.get("property_value", []) if "terms:license" in value), None),
+        "term_rows": int(len(df)),
+        "typedef_rows": int(len(typedef_df)),
+        "go_basic_term_rows": int(len(basic_ids)),
+        "terms_in_go_basic": int(df["in_go_basic"].sum()),
+        "splits": {
+            "train": int(len(train)),
+            "test": int(len(test)),
+        },
+        "split_strategy": "deterministic sha256(go_id) % 10; bucket 0 is test, buckets 1-9 are train",
+        "namespace_counts": {str(k): int(v) for k, v in namespace_counts.items()},
+        "obsolete_counts": {str(k): int(v) for k, v in obsolete_counts.items()},
+        "top_relationship_types": dict(relation_counts.most_common(20)),
+        "top_subsets": dict(subset_counts.most_common(20)),
+        "columns": TERM_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_GO_raw"))
+    parser.add_argument("--out-dir", type=Path, default=Path("LiteFold_GO_processed"))
+    args = parser.parse_args()
+    summary = build_dataset(args.raw_dir, args.out_dir)
+    print(json.dumps(summary, indent=2))
+
+
+if __name__ == "__main__":
+    main()