Add stratified mcq_carbon_600 configuration

README.md

@@ -78,6 +78,28 @@ dataset_info:
     num_examples: 2600
   download_size: 11786125
   dataset_size: 15000459
+- 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: 3012902
+    num_examples: 600
+  download_size: 2377835
+  dataset_size: 3012902
 - config_name: eukaryote_cls
   features:
   - name: id
@@ -245,6 +267,10 @@ configs:
   data_files:
   - split: train
     path: mcq_carbon/train-*
+- config_name: mcq_carbon_600
+  data_files:
+  - split: train
+    path: mcq_carbon_600/train-*
 - config_name: eukaryote_cls
   data_files:
   - split: train
@@ -325,6 +351,7 @@ headline score is needed.
 | `binary` | 2,600 | Full benchmark in binary-choice format, with two ordered options per question. |
 | `mcq` | 2,600 | Full benchmark in four-option multiple-choice format. |
 | `mcq_carbon` | 2,600 | MCQ benchmark with the 500 `3_species_cls` rows replaced by 500 stratified `eukaryote_cls` rows. |
+| `mcq_carbon_600` | 600 | Stratified 100-row sample from each `mcq_carbon` subtask. |
 | `binary_600` | 600 | Lower-cost binary subset with 100 examples from each of the six subtasks. |
 | `mcq_600` | 600 | Lower-cost MCQ subset with 100 examples from each of the six subtasks. |
 | `binary_eukaryote` | 170 | Binary `3_species_cls` questions whose target organism is eukaryotic. |
@@ -338,6 +365,13 @@ original species-classification position. From source revision `ae30ecec16a7669f
 `basic_class`, 100 `reverse_search`, and 100 `odd_one_out` rows, sampling approximately half of each taxon label
 within each question type. See [`scripts/create_mcq_carbon.py`](scripts/create_mcq_carbon.py).
 
+The `mcq_carbon_600` configuration samples without replacement from `mcq_carbon` at revision
+`c0a7d5b8ccfe4c0d64bc3ff5dd171ff4365c16f6` using seed 42. 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).
+
 The `eukaryote_cls` configuration uses the `mcq` feature schema, including JSON-serialized `metadata`.
 
 The `binary_600` and `mcq_600` configurations were sampled without replacement using seed 42 from source revision
@@ -407,3 +441,13 @@ python scripts/create_mcq_carbon.py --source-revision ae30ecec16a7669f342f7d8743
 ```
 
 The script publishes the Parquet file, this card, and the builder script together.
+
+### 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 c0a7d5b8ccfe4c0d64bc3ff5dd171ff4365c16f6 --output-dataset HuggingFaceBio/genomeqa --seed 42 --publish
+```
+
+The script publishes the Parquet file, this card, and the builder script together.

mcq_carbon_600/train-00000-of-00001.parquet

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

scripts/create_mcq_carbon_600.py

@@ -0,0 +1,250 @@
+"""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()