#!/usr/bin/env python3 """Build GE-L1 MCQ dataset for LLM benchmark. Generates 1,200 four-way MCQ records across 4 essentiality classes: A) Common essential (300) — Required for viability in nearly all cell types B) Selective essential (300) — Required specifically in this lineage/context C) Non-essential (300) — Knockout has no significant effect on viability D) Unknown/Untested (300) — Not tested in this cell line Difficulty: easy(40%), medium(35%), hard(25%) Split: 240 fewshot (60/class) + 240 val (60/class) + 720 test (180/class) Essential pairs (classes A and B) are sourced from the raw CRISPRGeneEffect.csv and CRISPRGeneDependency.csv files because the database only stores non-essential pairs. Output: exports/ge_llm/ge_l1_dataset.jsonl Usage: PYTHONPATH=src python scripts_depmap/build_ge_l1_dataset.py --data-dir data/depmap_raw """ from __future__ import annotations import argparse import logging import re import sys from pathlib import Path import numpy as np import pandas as pd logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") logger = logging.getLogger(__name__) PROJECT_ROOT = Path(__file__).resolve().parent.parent OUTPUT_DIR = PROJECT_ROOT / "exports" / "ge_llm" N_PER_CLASS = 300 FRAC_EASY = 0.40 FRAC_MEDIUM = 0.35 FRAC_HARD = 0.25 CLASS_LABELS = { "A": "common_essential", "B": "selective_essential", "C": "non_essential", "D": "unknown_untested", } _GENE_COL_RE = re.compile(r"^(.+?)\s*\((\d+)\)$") def _load_essential_from_raw( data_dir: Path, conn, n: int, rng: np.random.RandomState, *, common_essential_only: bool, ) -> pd.DataFrame: """Load essential gene-cell_line pairs from raw CSV files. The database only stores non-essential pairs, so essential pairs (dep_prob > 0.5 AND gene_effect < -1.0) must be sourced from the raw CRISPRGeneEffect.csv and CRISPRGeneDependency.csv files. """ effect_file = data_dir / "CRISPRGeneEffect.csv" dep_file = data_dir / "CRISPRGeneDependency.csv" if not effect_file.exists() or not dep_file.exists(): logger.error("Raw CSV files not found in %s", data_dir) return pd.DataFrame() # Load gene metadata from DB genes_df = pd.read_sql_query(""" SELECT gene_id, entrez_id, gene_symbol, description, is_common_essential, is_reference_nonessential FROM genes """, conn) entrez_to_gene = dict(zip(genes_df["entrez_id"], genes_df.index)) genes_by_entrez = genes_df.set_index("entrez_id") # Load cell line metadata from DB cl_df = pd.read_sql_query(""" SELECT cell_line_id, model_id, ccle_name, lineage, primary_disease FROM cell_lines """, conn) model_to_cl = dict(zip(cl_df["model_id"], cl_df.index)) cl_by_model = cl_df.set_index("model_id") # Filter genes by common_essential flag if common_essential_only: valid_entrez = set(genes_df[genes_df["is_common_essential"] == 1]["entrez_id"]) label = "common essential" else: valid_entrez = set(genes_df[genes_df["is_common_essential"] == 0]["entrez_id"]) label = "selective essential" logger.info("Scanning raw CSVs for %s pairs (%d candidate genes)...", label, len(valid_entrez)) # Read headers to get gene column mapping effect_header = pd.read_csv(effect_file, nrows=0) dep_header = pd.read_csv(dep_file, nrows=0) gene_cols_effect = [] col_to_entrez = {} for col in effect_header.columns[1:]: # skip first col (ModelID) m = _GENE_COL_RE.match(col.strip()) if m: entrez = int(m.group(2)) if entrez in valid_entrez: gene_cols_effect.append(col) col_to_entrez[col] = entrez # Find matching columns in dep file dep_cols = set(dep_header.columns) gene_cols_both = [c for c in gene_cols_effect if c in dep_cols] logger.info("Found %d candidate gene columns in both files", len(gene_cols_both)) if not gene_cols_both: return pd.DataFrame() # Read both files with subset of columns, indexed by ModelID. # NOTE: The two CSV files have DIFFERENT row orderings, so we must # join by ModelID — not zip rows together. usecols_effect = [effect_header.columns[0]] + gene_cols_both usecols_dep = [dep_header.columns[0]] + gene_cols_both logger.info("Reading effect file (%d columns)...", len(usecols_effect)) eff_df = pd.read_csv(effect_file, usecols=usecols_effect, index_col=0) logger.info("Reading dependency file (%d columns)...", len(usecols_dep)) dep_df = pd.read_csv(dep_file, usecols=usecols_dep, index_col=0) # Intersect cell lines present in both files and in DB common_models = set(eff_df.index) & set(dep_df.index) & set(cl_by_model.index) logger.info("Cell lines in both files and DB: %d", len(common_models)) essential_records = [] target_n = n * 3 # oversample to allow for filtering for model_id in common_models: if len(essential_records) >= target_n: break cl_row = cl_by_model.loc[model_id] eff_row = eff_df.loc[model_id] dep_row = dep_df.loc[model_id] for col in gene_cols_both: effect = eff_row[col] dep_prob = dep_row[col] if pd.isna(effect) or pd.isna(dep_prob): continue # Essential: dep_prob > 0.5 AND gene_effect < -1.0 if dep_prob > 0.5 and effect < -1.0: entrez = col_to_entrez[col] g_row = genes_by_entrez.loc[entrez] essential_records.append({ "gene_id": int(g_row["gene_id"]), "gene_symbol": g_row["gene_symbol"], "entrez_id": entrez, "description": g_row["description"], "is_common_essential": int(g_row["is_common_essential"]), "is_reference_nonessential": int(g_row["is_reference_nonessential"]), "cell_line_id": int(cl_row["cell_line_id"]), "model_id": model_id, "ccle_name": cl_row["ccle_name"], "lineage": cl_row["lineage"], "primary_disease": cl_row["primary_disease"], "gene_effect_score": float(effect), "dependency_probability": float(dep_prob), }) logger.info("Found %d %s pairs from raw CSVs", len(essential_records), label) if not essential_records: return pd.DataFrame() df = pd.DataFrame(essential_records) if len(df) >= n: return df.sample(n=n, random_state=rng).reset_index(drop=True) logger.warning("%s: only %d available, need %d", label.capitalize(), len(df), n) return df.reset_index(drop=True) def load_common_essential( conn, n: int, rng: np.random.RandomState, data_dir: Path, ) -> pd.DataFrame: """Load common essential gene-cell_line pairs (class A) from raw CSVs.""" return _load_essential_from_raw(data_dir, conn, n, rng, common_essential_only=True) def load_selective_essential( conn, n: int, rng: np.random.RandomState, data_dir: Path, ) -> pd.DataFrame: """Load selective essential gene-cell_line pairs (class B) from raw CSVs.""" return _load_essential_from_raw(data_dir, conn, n, rng, common_essential_only=False) def load_non_essential(conn, n: int, rng: np.random.RandomState) -> pd.DataFrame: """Load non-essential gene-cell_line pairs (class C).""" from negbiodb_depmap.llm_dataset import load_ge_candidate_pool df = load_ge_candidate_pool(conn, min_confidence="silver") df = df[df["dependency_probability"].fillna(1) < 0.3].copy() df = df[df["gene_effect_score"].fillna(-999) > -0.3].copy() if len(df) >= n: return df.sample(n=n, random_state=rng).reset_index(drop=True) logger.warning("Non-essential: only %d available, need %d", len(df), n) return df.reset_index(drop=True) def load_unknown_untested(conn, n: int, rng: np.random.RandomState) -> pd.DataFrame: """Generate unknown/untested gene-cell_line pairs (class D). Pairs genes and cell lines that are in the DB but NOT paired together. """ genes = pd.read_sql_query(""" SELECT gene_id, gene_symbol, entrez_id, description, is_common_essential, is_reference_nonessential FROM genes ORDER BY RANDOM() LIMIT 500 """, conn) cell_lines = pd.read_sql_query(""" SELECT cell_line_id, model_id, ccle_name, lineage, primary_disease FROM cell_lines ORDER BY RANDOM() LIMIT 100 """, conn) # Use gene_cell_pairs (aggregated) instead of scanning all 28M+ negative results tested = set() rows = conn.execute( "SELECT gene_id, cell_line_id FROM gene_cell_pairs" ).fetchall() for r in rows: tested.add((r[0], r[1])) records = [] for _ in range(n * 10): if len(records) >= n: break gi = rng.randint(len(genes)) ci = rng.randint(len(cell_lines)) gid = int(genes.iloc[gi]["gene_id"]) clid = int(cell_lines.iloc[ci]["cell_line_id"]) if (gid, clid) not in tested: rec = {**genes.iloc[gi].to_dict(), **cell_lines.iloc[ci].to_dict()} rec["gene_effect_score"] = None rec["dependency_probability"] = None records.append(rec) tested.add((gid, clid)) return pd.DataFrame(records[:n]) def format_l1_context(row: pd.Series, difficulty: str) -> str: """Format context for GE-L1 MCQ.""" gene = row.get("gene_symbol", "UNKNOWN") cell_line = row.get("ccle_name") or row.get("model_id", "UNKNOWN") lineage = row.get("lineage", "unknown lineage") disease = row.get("primary_disease", "") parts = [f"Gene: {gene}", f"Cell line: {cell_line} ({lineage})"] if difficulty == "easy": desc = row.get("description") if desc and isinstance(desc, str): parts.append(f"Gene function: {desc[:200]}") if disease: parts.append(f"Disease: {disease}") effect = row.get("gene_effect_score") dep = row.get("dependency_probability") if effect is not None and not pd.isna(effect): parts.append(f"Chronos gene effect: {effect:.3f}") if dep is not None and not pd.isna(dep): parts.append(f"Dependency probability: {dep:.3f}") elif difficulty == "medium": if disease: parts.append(f"Disease: {disease}") return "\n".join(parts) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Build GE-L1 MCQ dataset.") parser.add_argument("--db", type=Path, default=PROJECT_ROOT / "data" / "negbiodb_depmap.db") parser.add_argument("--data-dir", type=Path, default=PROJECT_ROOT / "data" / "depmap_raw", help="Directory with raw CRISPRGeneEffect.csv and CRISPRGeneDependency.csv") parser.add_argument("--output", type=Path, default=OUTPUT_DIR / "ge_l1_dataset.jsonl") parser.add_argument("--seed", type=int, default=42) args = parser.parse_args(argv) from negbiodb_depmap.depmap_db import get_connection from negbiodb_depmap.llm_dataset import ( apply_max_per_gene, assign_splits, write_dataset_metadata, write_jsonl, ) rng = np.random.RandomState(args.seed) conn = get_connection(args.db) try: # Load each class class_a = load_common_essential(conn, N_PER_CLASS, rng, args.data_dir) class_a["gold_answer"] = "A" class_a["gold_category"] = CLASS_LABELS["A"] class_b = load_selective_essential(conn, N_PER_CLASS, rng, args.data_dir) class_b["gold_answer"] = "B" class_b["gold_category"] = CLASS_LABELS["B"] class_c = load_non_essential(conn, N_PER_CLASS, rng) class_c["gold_answer"] = "C" class_c["gold_category"] = CLASS_LABELS["C"] class_d = load_unknown_untested(conn, N_PER_CLASS, rng) class_d["gold_answer"] = "D" class_d["gold_category"] = CLASS_LABELS["D"] finally: conn.close() combined = pd.concat([class_a, class_b, class_c, class_d], ignore_index=True) combined = apply_max_per_gene(combined, max_per_gene=10) logger.info("Combined: %d records", len(combined)) # Assign difficulty n_total = len(combined) difficulties = ( ["easy"] * int(n_total * FRAC_EASY) + ["medium"] * int(n_total * FRAC_MEDIUM) + ["hard"] * (n_total - int(n_total * FRAC_EASY) - int(n_total * FRAC_MEDIUM)) ) rng.shuffle(difficulties) combined["difficulty"] = difficulties[:len(combined)] # Assign splits (class-stratified) split_parts = [] for letter in sorted(CLASS_LABELS.keys()): class_df = combined[combined["gold_answer"] == letter].copy() class_df = assign_splits(class_df, ratios={"train": 0.2, "val": 0.2, "test": 0.6}) # Rename train to fewshot class_df["split"] = class_df["split"].replace({"train": "fewshot"}) split_parts.append(class_df) combined = pd.concat(split_parts, ignore_index=True) # Build JSONL records records = [] for i, (_, row) in enumerate(combined.iterrows()): difficulty = row["difficulty"] context = format_l1_context(row, difficulty) rec = { "question_id": f"GEL1-{i:04d}", "task": "ge-l1", "split": row["split"], "difficulty": difficulty, "context_text": context, "gold_answer": row["gold_answer"], "gold_category": row["gold_category"], "metadata": { "gene_symbol": row.get("gene_symbol"), "model_id": row.get("model_id"), "lineage": row.get("lineage"), "is_common_essential": int(row.get("is_common_essential", 0)) if pd.notna(row.get("is_common_essential")) else None, }, } records.append(rec) write_jsonl(records, args.output) stats = { "n_total": len(records), "n_per_class": {v: N_PER_CLASS for v in CLASS_LABELS.values()}, "difficulty_distribution": dict(combined["difficulty"].value_counts()), "split_distribution": dict(combined["split"].value_counts()), "seed": args.seed, } write_dataset_metadata(args.output.parent, "ge-l1", stats) logger.info("GE-L1 dataset built: %d records", len(records)) return 0 if __name__ == "__main__": sys.exit(main())