Add dataset creation script

create_dataset.py

@@ -0,0 +1,475 @@
+#!/usr/bin/env python
+"""Create and optionally push a preprocessed Malinois/Gosai MPRA dataset."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import math
+import shutil
+from pathlib import Path
+from typing import Any
+
+import numpy as np
+from datasets import Dataset, DatasetDict, Features, Value, load_dataset
+from huggingface_hub import HfApi
+
+SOURCE_URL = (
+    "https://static-content.springer.com/esm/"
+    "art%3A10.1038%2Fs41586-024-08070-z/"
+    "MediaObjects/41586_2024_8070_MOESM4_ESM.txt"
+)
+DEFAULT_LOCAL_SOURCE = (
+    Path(__file__).resolve().parents[3]
+    / "scratch/malinois_regression/data/41586_2024_8070_MOESM4_ESM.txt"
+)
+
+TARGET_COLUMNS = ("K562_log2FC", "HepG2_log2FC", "SKNSH_log2FC")
+SE_COLUMNS = ("K562_lfcSE", "HepG2_lfcSE", "SKNSH_lfcSE")
+VALIDATION_CHROMOSOMES = ("19", "21", "X")
+TEST_CHROMOSOMES = ("7", "13")
+SE_METRIC_THRESHOLD = 1.0
+HIGH_ACTIVITY_THRESHOLD = 0.5
+
+RAW_FEATURES = Features(
+    {
+        "IDs": Value("string"),
+        "chr": Value("string"),
+        "data_project": Value("string"),
+        "OL": Value("string"),
+        "class": Value("string"),
+        "K562_log2FC": Value("float64"),
+        "HepG2_log2FC": Value("float64"),
+        "SKNSH_log2FC": Value("float64"),
+        "K562_lfcSE": Value("float64"),
+        "HepG2_lfcSE": Value("float64"),
+        "SKNSH_lfcSE": Value("float64"),
+        "sequence": Value("string"),
+    }
+)
+
+OUTPUT_FEATURES = Features(
+    {
+        "id": Value("string"),
+        "split": Value("string"),
+        "chromosome": Value("string"),
+        "data_project": Value("string"),
+        "oligo": Value("string"),
+        "variant_class": Value("string"),
+        "sequence": Value("string"),
+        "sequence_length": Value("int32"),
+        "reverse_complement": Value("string"),
+        "forward_rc_concat": Value("string"),
+        "K562_log2FC": Value("float32"),
+        "HepG2_log2FC": Value("float32"),
+        "SKNSH_log2FC": Value("float32"),
+        "K562_lfcSE": Value("float32"),
+        "HepG2_lfcSE": Value("float32"),
+        "SKNSH_lfcSE": Value("float32"),
+        "K562_log2FC_train_zscore": Value("float32"),
+        "HepG2_log2FC_train_zscore": Value("float32"),
+        "SKNSH_log2FC_train_zscore": Value("float32"),
+        "all_se_le_1": Value("bool"),
+        "any_log2fc_gt_0_5": Value("bool"),
+    }
+)
+
+COMPLEMENT = str.maketrans("ACGTNacgtn", "TGCANtgcan")
+
+
+def parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument(
+        "--repo-id",
+        default="HuggingFaceBio/malinois-mpra-regression",
+        help="Dataset repository to push to.",
+    )
+    parser.add_argument(
+        "--source",
+        default=str(
+            DEFAULT_LOCAL_SOURCE if DEFAULT_LOCAL_SOURCE.exists() else SOURCE_URL
+        ),
+        help="Local source TSV path or public source URL.",
+    )
+    parser.add_argument(
+        "--output-dir",
+        type=Path,
+        default=Path(__file__).resolve().parent / "build",
+        help="Directory for generated card, metadata, and optional local save.",
+    )
+    parser.add_argument(
+        "--cache-dir",
+        type=Path,
+        default=Path(__file__).resolve().parent / "cache",
+        help="Hugging Face datasets cache directory.",
+    )
+    parser.add_argument("--num-proc", type=int, default=8)
+    parser.add_argument("--push", action="store_true", help="Push dataset/card/script.")
+    parser.add_argument(
+        "--private", action="store_true", help="Create/update as private."
+    )
+    parser.add_argument(
+        "--save-local",
+        action="store_true",
+        help="Also save the processed DatasetDict under output-dir/dataset.",
+    )
+    return parser.parse_args()
+
+
+def normalize_chromosome(value: Any) -> str:
+    chrom = str(value).strip()
+    if chrom.lower().startswith("chr"):
+        chrom = chrom[3:]
+    if chrom.endswith(".0") and chrom[:-2].isdigit():
+        chrom = chrom[:-2]
+    return chrom.upper() if chrom.upper() in {"X", "Y", "M", "MT"} else chrom
+
+
+def normalize_sequence(value: Any) -> str:
+    return str(value).strip().upper()
+
+
+def reverse_complement(sequence: str) -> str:
+    return sequence.translate(COMPLEMENT)[::-1].upper()
+
+
+def finite_batch(batch: dict[str, list[Any]]) -> list[bool]:
+    mask = np.ones(len(batch["sequence"]), dtype=bool)
+    for column in (*TARGET_COLUMNS, *SE_COLUMNS):
+        mask &= np.isfinite(np.asarray(batch[column], dtype=np.float64))
+    mask &= np.asarray([bool(normalize_sequence(seq)) for seq in batch["sequence"]])
+    return mask.tolist()
+
+
+def split_name_for_chromosome(chromosome: Any) -> str:
+    chrom = normalize_chromosome(chromosome)
+    if chrom in VALIDATION_CHROMOSOMES:
+        return "validation"
+    if chrom in TEST_CHROMOSOMES:
+        return "test"
+    return "train"
+
+
+def split_by_chromosome(dataset: Dataset) -> DatasetDict:
+    return DatasetDict(
+        {
+            split: dataset.filter(
+                lambda row, split=split: split_name_for_chromosome(row["chr"]) == split,
+                desc=f"Selecting {split} split",
+            )
+            for split in ("train", "validation", "test")
+        }
+    )
+
+
+def preprocess_split(dataset: Dataset, split: str, num_proc: int) -> Dataset:
+    def preprocess_batch(batch: dict[str, list[Any]]) -> dict[str, list[Any]]:
+        sequences = [normalize_sequence(seq) for seq in batch["sequence"]]
+        rc_sequences = [reverse_complement(seq) for seq in sequences]
+        output: dict[str, list[Any]] = {
+            "id": [str(value) for value in batch["IDs"]],
+            "split": [split] * len(sequences),
+            "chromosome": [normalize_chromosome(value) for value in batch["chr"]],
+            "data_project": [str(value) for value in batch["data_project"]],
+            "oligo": [str(value) for value in batch["OL"]],
+            "variant_class": [str(value) for value in batch["class"]],
+            "sequence": sequences,
+            "sequence_length": [len(seq) for seq in sequences],
+            "reverse_complement": rc_sequences,
+            "forward_rc_concat": [
+                f"<dna>{seq}</dna><dna>{rc_seq}</dna>"
+                for seq, rc_seq in zip(sequences, rc_sequences)
+            ],
+        }
+
+        target_arrays = [
+            np.asarray(batch[column], dtype=np.float64) for column in TARGET_COLUMNS
+        ]
+        se_arrays = [
+            np.asarray(batch[column], dtype=np.float64) for column in SE_COLUMNS
+        ]
+        for column, values in zip(TARGET_COLUMNS, target_arrays):
+            output[column] = values.astype(np.float32).tolist()
+        for column, values in zip(SE_COLUMNS, se_arrays):
+            output[column] = values.astype(np.float32).tolist()
+
+        all_se_le_1 = np.ones(len(se_arrays[0]), dtype=bool)
+        for values in se_arrays:
+            all_se_le_1 &= values <= SE_METRIC_THRESHOLD
+        high_activity = np.zeros(len(target_arrays[0]), dtype=bool)
+        for values in target_arrays:
+            high_activity |= values > HIGH_ACTIVITY_THRESHOLD
+        output["all_se_le_1"] = all_se_le_1.tolist()
+        output["any_log2fc_gt_0_5"] = high_activity.tolist()
+        return output
+
+    map_kwargs: dict[str, Any] = {
+        "batched": True,
+        "remove_columns": dataset.column_names,
+        "desc": f"Preprocessing {split} split",
+    }
+    if num_proc > 1:
+        map_kwargs["num_proc"] = num_proc
+    return dataset.map(preprocess_batch, **map_kwargs)
+
+
+def fit_train_zscore(train: Dataset) -> dict[str, dict[str, float]]:
+    stats: dict[str, dict[str, float]] = {}
+    for column in TARGET_COLUMNS:
+        values = np.asarray(train[column], dtype=np.float64)
+        mean = float(np.mean(values))
+        std = float(np.std(values))
+        if not math.isfinite(std) or std <= 0.0:
+            raise ValueError(f"Cannot z-score {column}: std={std}")
+        stats[column] = {"mean": mean, "std": std}
+    return stats
+
+
+def add_train_zscores(dataset: Dataset, stats: dict[str, dict[str, float]]) -> Dataset:
+    def add_batch(batch: dict[str, list[Any]]) -> dict[str, list[float]]:
+        output = {}
+        for column in TARGET_COLUMNS:
+            values = np.asarray(batch[column], dtype=np.float64)
+            spec = stats[column]
+            output[f"{column}_train_zscore"] = (
+                ((values - spec["mean"]) / spec["std"]).astype(np.float32).tolist()
+            )
+        return output
+
+    return dataset.map(
+        add_batch, batched=True, desc=f"Adding z-scores to {dataset[0]['split']}"
+    )
+
+
+def load_source_dataset(args: argparse.Namespace) -> Dataset:
+    dataset = load_dataset(
+        "csv",
+        data_files=args.source,
+        delimiter="\t",
+        split="train",
+        features=RAW_FEATURES,
+        cache_dir=str(args.cache_dir),
+    )
+    return dataset.filter(
+        finite_batch,
+        batched=True,
+        desc="Filtering finite labels, SEs, and nonempty sequences",
+    )
+
+
+def build_dataset(args: argparse.Namespace) -> tuple[DatasetDict, dict[str, Any]]:
+    raw = load_source_dataset(args)
+    raw_splits = split_by_chromosome(raw)
+    processed = DatasetDict(
+        {
+            split: preprocess_split(raw_splits[split], split, args.num_proc)
+            for split in ("train", "validation", "test")
+        }
+    )
+    zscore_stats = fit_train_zscore(processed["train"])
+    processed = DatasetDict(
+        {
+            split: add_train_zscores(processed[split], zscore_stats)
+            for split in ("train", "validation", "test")
+        }
+    )
+    processed = DatasetDict(
+        {
+            split: processed[split].cast(OUTPUT_FEATURES)
+            for split in ("train", "validation", "test")
+        }
+    )
+    metadata = collect_metadata(processed, zscore_stats, args)
+    return processed, metadata
+
+
+def collect_metadata(
+    dataset: DatasetDict,
+    zscore_stats: dict[str, dict[str, float]],
+    args: argparse.Namespace,
+) -> dict[str, Any]:
+    split_stats: dict[str, dict[str, Any]] = {}
+    for split, split_dataset in dataset.items():
+        lengths = np.asarray(split_dataset["sequence_length"], dtype=np.float64)
+        all_se = np.asarray(split_dataset["all_se_le_1"], dtype=bool)
+        high = np.asarray(split_dataset["any_log2fc_gt_0_5"], dtype=bool)
+        split_stats[split] = {
+            "num_rows": len(split_dataset),
+            "all_se_le_1_rows": int(all_se.sum()),
+            "any_log2fc_gt_0_5_rows": int(high.sum()),
+            "sequence_length_min": int(lengths.min()),
+            "sequence_length_mean": float(lengths.mean()),
+            "sequence_length_max": int(lengths.max()),
+        }
+
+    return {
+        "source": args.source,
+        "source_url": SOURCE_URL,
+        "repo_id": args.repo_id,
+        "target_columns": list(TARGET_COLUMNS),
+        "standard_error_columns": list(SE_COLUMNS),
+        "validation_chromosomes": list(VALIDATION_CHROMOSOMES),
+        "test_chromosomes": list(TEST_CHROMOSOMES),
+        "metric_se_threshold": SE_METRIC_THRESHOLD,
+        "high_activity_threshold": HIGH_ACTIVITY_THRESHOLD,
+        "train_zscore_stats": zscore_stats,
+        "splits": split_stats,
+    }
+
+
+def metric_rows(dataset: DatasetDict) -> dict[str, int]:
+    return {
+        split: int(np.asarray(split_dataset["all_se_le_1"], dtype=bool).sum())
+        for split, split_dataset in dataset.items()
+    }
+
+
+def render_card(metadata: dict[str, Any]) -> str:
+    train = metadata["splits"]["train"]
+    validation = metadata["splits"]["validation"]
+    test = metadata["splits"]["test"]
+    zstats = metadata["train_zscore_stats"]
+    total_rows = sum(split["num_rows"] for split in metadata["splits"].values())
+    return f"""---
+pretty_name: Malinois/Gosai MPRA Regression
+task_categories:
+- tabular-regression
+tags:
+- biology
+- genomics
+- dna
+- mpra
+- carbon
+size_categories:
+- 100K<n<1M
+---
+
+# Malinois/Gosai MPRA Regression
+
+This dataset preprocesses the Gosai et al. 2024 supplementary MPRA table used by the
+Malinois benchmark for supervised DNA-to-activity regression. Each row contains a DNA
+sequence and three cell-type-specific activity targets: `K562_log2FC`,
+`HepG2_log2FC`, and `SKNSH_log2FC`.
+
+No new license is asserted by this preprocessing. Users should follow the terms of
+the source publication and supplementary data.
+
+## Source
+
+- Publication: Gosai et al., *Machine-guided design of cell-type-targeting
+  cis-regulatory elements*, Nature 2024.
+- Source table: `41586_2024_8070_MOESM4_ESM.txt`.
+- Source URL: `{metadata["source_url"]}`.
+
+## Splits
+
+Chromosome splits match the Carbon fine-tuning experiments and the public Malinois
+setup we used:
+
+| Split | Chromosomes | Rows | Rows with all SE <= 1.0 |
+|---|---:|---:|---:|
+| train | all except validation/test chromosomes | {train["num_rows"]:,} | {train["all_se_le_1_rows"]:,} |
+| validation | 19, 21, X | {validation["num_rows"]:,} | {validation["all_se_le_1_rows"]:,} |
+| test | 7, 13 | {test["num_rows"]:,} | {test["all_se_le_1_rows"]:,} |
+
+Total rows after filtering finite targets/standard errors and nonempty sequences:
+{total_rows:,}.
+
+## Columns
+
+- `id`: original row identifier from the source table.
+- `split`: train, validation, or test.
+- `chromosome`: normalized chromosome label.
+- `data_project`, `oligo`, `variant_class`: source metadata.
+- `sequence`: uppercase DNA sequence.
+- `reverse_complement`: reverse complement of `sequence`.
+- `forward_rc_concat`: `<dna>sequence</dna><dna>reverse_complement</dna>`,
+  matching the best Carbon fine-tuning recipe.
+- `K562_log2FC`, `HepG2_log2FC`, `SKNSH_log2FC`: raw regression targets.
+- `K562_lfcSE`, `HepG2_lfcSE`, `SKNSH_lfcSE`: target standard errors.
+- `*_train_zscore`: target standardized using train-split mean/std.
+- `all_se_le_1`: true when all three SE columns are `<= 1.0`; this was the
+  main reported validation/test metric filter.
+- `any_log2fc_gt_0_5`: true when any target is greater than `0.5`; this was used
+  for optional high-activity training upsampling.
+
+Train z-score statistics:
+
+| Target | Mean | Std |
+|---|---:|---:|
+| K562_log2FC | {zstats["K562_log2FC"]["mean"]:.8f} | {zstats["K562_log2FC"]["std"]:.8f} |
+| HepG2_log2FC | {zstats["HepG2_log2FC"]["mean"]:.8f} | {zstats["HepG2_log2FC"]["std"]:.8f} |
+| SKNSH_log2FC | {zstats["SKNSH_log2FC"]["mean"]:.8f} | {zstats["SKNSH_log2FC"]["std"]:.8f} |
+
+## Usage
+
+```py
+from datasets import load_dataset
+
+ds = load_dataset("{metadata["repo_id"]}")
+train = ds["train"]
+validation_metric = ds["validation"].filter(lambda row: row["all_se_le_1"])
+
+example = train[0]
+sequence = example["forward_rc_concat"]
+labels = [
+    example["K562_log2FC_train_zscore"],
+    example["HepG2_log2FC_train_zscore"],
+    example["SKNSH_log2FC_train_zscore"],
+]
+```
+
+To recreate the dataset:
+
+```sh
+python create_dataset.py --repo-id {metadata["repo_id"]} --push
+```
+"""
+
+
+def write_artifacts(args: argparse.Namespace, metadata: dict[str, Any]) -> None:
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    (args.output_dir / "metadata.json").write_text(
+        json.dumps(metadata, indent=2, sort_keys=True) + "\n", encoding="utf-8"
+    )
+    (args.output_dir / "README.md").write_text(render_card(metadata), encoding="utf-8")
+    shutil.copy2(Path(__file__), args.output_dir / "create_dataset.py")
+
+
+def push_artifacts(args: argparse.Namespace, dataset: DatasetDict) -> None:
+    dataset.push_to_hub(args.repo_id, private=args.private)
+    api = HfApi()
+    api.upload_file(
+        path_or_fileobj=str(args.output_dir / "README.md"),
+        path_in_repo="README.md",
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        commit_message="Add Malinois MPRA dataset card",
+    )
+    api.upload_file(
+        path_or_fileobj=str(args.output_dir / "create_dataset.py"),
+        path_in_repo="create_dataset.py",
+        repo_id=args.repo_id,
+        repo_type="dataset",
+        commit_message="Add dataset creation script",
+    )
+
+
+def main() -> None:
+    args = parse_args()
+    dataset, metadata = build_dataset(args)
+    write_artifacts(args, metadata)
+
+    if args.save_local:
+        local_path = args.output_dir / "dataset"
+        if local_path.exists():
+            shutil.rmtree(local_path)
+        dataset.save_to_disk(local_path)
+
+    print(json.dumps(metadata, indent=2, sort_keys=True))
+    if args.push:
+        push_artifacts(args, dataset)
+
+
+if __name__ == "__main__":
+    main()