scripts/create_mcq_carbon_600.py

"""Create a 600-row, stratified subset of GenomeQA mcq_carbon."""

import argparse
import json
import random
import re
from collections import Counter, defaultdict
from pathlib import Path

from datasets import Dataset, load_dataset
from huggingface_hub import CommitOperationAdd, HfApi, hf_hub_download


DATASET_ID = "HuggingFaceBio/genomeqa"
PARQUET_PATH = "mcq_carbon_600/train-00000-of-00001.parquet"
QUOTAS = {
    "1_enhancer_vs_promoter": {"basic_class": 34, "selection": 33, "outlier": 33},
    "2_splice_sites": {"fine_grained_class": 34, "generalized_selection": 33, "find_shuffled_outlier": 33},
    "eukaryote_cls": {"basic_class": 60, "reverse_search": 20, "odd_one_out": 20},
    "4_histone_marks": {
        "seq_to_label": 25,
        "label_to_seq": 25,
        "odd_one_out": 25,
        "chromatin_classify": 14,
        "chromatin_select_seq": 11,
    },
    "5_tfbs": {"forward_classify": 34, "reverse_select": 33, "3d_structure_select": 33},
    "6_motif": {"seq_to_motif": 50, "motif_to_seq": 50},
}
MARK = re.compile(r"\b(?:H2AFZ|H3K\d+(?:me\d|ac)|H4K\d+me\d)\b")
ENHANCER_OUTLIER_PATTERNS = (
    r"Find the one containing a (enhancer|promoter)",
    r"specific sequence that contains a (enhancer|promoter)",
    r"sequence that includes a (enhancer|promoter)",
    r"one actually harbors a (enhancer|promoter)",
    r"sequence holds a (enhancer|promoter)",
)


def label_for_row(row: dict, metadata: dict) -> tuple[str, ...]:
    subtask, dimension = row["subtask"], metadata["dim"]
    if subtask == "1_enhancer_vs_promoter":
        if dimension == "basic_class":
            return (row["answer_text"].lower(),)
        if dimension == "selection":
            labels = set(re.findall(r"\b(?:enhancer|promoter)\b", row["question"].lower()))
            if len(labels) != 1:
                raise ValueError(f"Cannot identify enhancer selection target: {row['id']}")
            return (labels.pop(),)
        for pattern in ENHANCER_OUTLIER_PATTERNS:
            match = re.search(pattern, row["question"], flags=re.IGNORECASE)
            if match:
                return (match.group(1).lower(),)
        raise ValueError(f"Cannot identify enhancer outlier target: {row['id']}")
    if subtask == "2_splice_sites":
        if dimension == "fine_grained_class":
            return (metadata["true_type"],)
        if dimension == "generalized_selection":
            return (metadata["target"],)
        return ()
    if subtask == "eukaryote_cls":
        if dimension == "basic_class":
            return (metadata["true"],)
        if dimension == "reverse_search":
            return (metadata["target"],)
        return (metadata["minority"], metadata["majority"])
    if subtask == "4_histone_marks":
        if dimension == "seq_to_label":
            return (row["answer_text"],)
        if dimension in {"label_to_seq", "odd_one_out"}:
            marks = MARK.findall(row["question"])
            if not marks:
                raise ValueError(f"Cannot identify histone mark: {row['id']}")
            target = marks[1] if dimension == "odd_one_out" and "while one contains" in row["question"] else marks[0]
            return (target,)
        if dimension == "chromatin_classify":
            return (metadata["truth"].lower(),)
        return (metadata["target_state"].lower(),)
    if subtask == "5_tfbs":
        if dimension == "forward_classify":
            return (row["answer_text"],)
        if dimension == "reverse_select":
            return (metadata["target"],)
    return ()


def stratified_sample(
    indices: list[int], quota: int, labels: dict[int, tuple[str, ...]], rng: random.Random, depth: int = 0
) -> list[int]:
    if quota == len(indices):
        return indices.copy()
    groups = defaultdict(list)
    for index in indices:
        label = labels[index][depth] if depth < len(labels[index]) else None
        groups[label].append(index)
    if list(groups) == [None]:
        return rng.sample(indices, quota)

    total = len(indices)
    take = {label: quota * len(group) // total for label, group in groups.items()}
    order = sorted(groups)
    rng.shuffle(order)
    order.sort(key=lambda label: quota * len(groups[label]) % total, reverse=True)
    for label in order[: quota - sum(take.values())]:
        take[label] += 1

    selected = []
    for label in sorted(groups):
        if take[label]:
            selected.extend(stratified_sample(groups[label], take[label], labels, rng, depth + 1))
    return selected


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--source-revision", required=True)
    parser.add_argument("--output-dataset", default=DATASET_ID)
    parser.add_argument("--output-dir", type=Path, default=Path.cwd())
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--publish", action="store_true")
    args = parser.parse_args()

    source = load_dataset(DATASET_ID, "mcq_carbon", split="train", revision=args.source_revision)
    groups = defaultdict(list)
    labels = {}
    for index, row in enumerate(source):
        metadata = json.loads(row["metadata"])
        groups[(row["subtask"], metadata["dim"])].append(index)
        labels[index] = label_for_row(row, metadata) + (str(row["answer_index"]),)
    expected = {(subtask, dimension) for subtask, quotas in QUOTAS.items() for dimension in quotas}
    if set(groups) != expected:
        raise ValueError(f"Unexpected source subtasks or dimensions: {set(groups) ^ expected}")

    rng = random.Random(args.seed)
    selected = []
    for subtask, dimensions in QUOTAS.items():
        for dimension, quota in dimensions.items():
            candidates = groups[(subtask, dimension)]
            if len(candidates) < quota:
                raise ValueError(f"Only {len(candidates)} {subtask}/{dimension} rows for quota {quota}")
            selected.extend(stratified_sample(candidates, quota, labels, rng))
    rng.shuffle(selected)
    subset = source.select(selected)
    if len(selected) != 600 or len(set(selected)) != 600 or Counter(subset["subtask"]) != dict.fromkeys(QUOTAS, 100):
        raise RuntimeError("The subset must contain 100 distinct rows per subtask")

    parquet_path = args.output_dir / PARQUET_PATH
    parquet_path.parent.mkdir(parents=True, exist_ok=True)
    subset.to_parquet(parquet_path)
    materialized = Dataset.from_parquet(str(parquet_path))

    api = HfApi()
    head = api.repo_info(args.output_dataset, repo_type="dataset").sha
    card = Path(hf_hub_download(args.output_dataset, "README.md", repo_type="dataset", revision=head)).read_text()
    info = f"""- config_name: mcq_carbon_600
  features:
  - name: id
    dtype: int64
  - name: subtask
    dtype: string
  - name: question
    dtype: string
  - name: options
    list: string
  - name: answer_index
    dtype: int64
  - name: answer_text
    dtype: string
  - name: metadata
    dtype: string
  splits:
  - name: train
    num_bytes: {materialized.info.splits['train'].num_bytes}
    num_examples: {len(materialized)}
  download_size: {parquet_path.stat().st_size}
  dataset_size: {materialized.info.dataset_size}
"""
    marker = "- config_name: eukaryote_cls\n  features:"
    existing = "- config_name: mcq_carbon_600\n  features:"
    if existing in card:
        start = card.index(existing)
        end = card.index(marker, start)
        card = card[:start] + info + card[end:]
    else:
        if marker not in card:
            raise ValueError("Cannot find dataset_info insertion point in card")
        card = card.replace(marker, info + marker, 1)
        config = """- config_name: mcq_carbon_600
  data_files:
  - split: train
    path: mcq_carbon_600/train-*
"""
        card = card.replace(
            "- config_name: eukaryote_cls\n  data_files:", config + "- config_name: eukaryote_cls\n  data_files:", 1
        )
        row = (
            "| `mcq_carbon` | 2,600 | MCQ benchmark with the 500 `3_species_cls` rows replaced by 500 stratified "
            "`eukaryote_cls` rows. |\n"
        )
        new_row = "| `mcq_carbon_600` | 600 | Stratified 100-row sample from each `mcq_carbon` subtask. |\n"
        card = card.replace(row, row + new_row, 1)
        note = f"""The `mcq_carbon_600` configuration samples without replacement from `mcq_carbon` at revision
`{args.source_revision}` using seed {args.seed}. It retains 100 rows per subtask and preserves the mix of question
dimensions within each subtask. Within dimensions, it samples proportionally by target label where available; eukaryote odd-one-out
questions are also stratified by majority taxon, and answer position is the final stratum. The 100 motif rows are all
retained. See
[`scripts/create_mcq_carbon_600.py`](scripts/create_mcq_carbon_600.py).

"""
        card = card.replace(
            "The `eukaryote_cls` configuration uses", note + "The `eukaryote_cls` configuration uses", 1
        )

    if "### mcq_carbon_600" not in card:
        card += f"""
### mcq_carbon_600

To rebuild and publish `mcq_carbon_600` from the pinned source revision, run:

```bash
python scripts/create_mcq_carbon_600.py --source-revision {args.source_revision} --output-dataset {args.output_dataset} --seed {args.seed} --publish
```

The script publishes the Parquet file, this card, and the builder script together.
"""

    card_path = args.output_dir / "README.md"
    card_path.write_text(card)
    print(f"Prepared {len(subset)} rows at {parquet_path}")
    for subtask, dimensions in QUOTAS.items():
        counts = Counter(json.loads(row["metadata"])["dim"] for row in subset if row["subtask"] == subtask)
        positions = Counter(row["answer_index"] for row in subset if row["subtask"] == subtask)
        print(subtask, dict(counts), "answer positions", dict(positions))
    if args.publish:
        commit = api.create_commit(
            repo_id=args.output_dataset,
            repo_type="dataset",
            parent_commit=head,
            commit_message="Add stratified mcq_carbon_600 configuration",
            operations=[
                CommitOperationAdd(path_in_repo=PARQUET_PATH, path_or_fileobj=parquet_path),
                CommitOperationAdd(path_in_repo="README.md", path_or_fileobj=card_path),
                CommitOperationAdd(path_in_repo="scripts/create_mcq_carbon_600.py", path_or_fileobj=__file__),
            ],
        )
        print(f"Published {commit.commit_url}")


if __name__ == "__main__":
    main()