create_dataset.py

#!/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()