#!/usr/bin/env python3 """Build PPI-L1 MCQ dataset for LLM benchmark. Generates 1,200 four-way MCQ records across 4 evidence classes: A) Direct experimental (300) — IntAct gold/silver (co-IP, pulldown, etc.) B) Systematic screen (300) — HuRI gold (Y2H screen) C) Computational inf. (300) — huMAP silver (co-fractionation ML) D) Database absence (300) — STRING bronze (zero combined score) Difficulty: easy(40%), medium(35%), hard(25%) Split: 240 fewshot (60/class) + 240 val (60/class) + 720 test (180/class) Output: exports/ppi_llm/ppi_l1_dataset.jsonl Usage: PYTHONPATH=src python scripts_ppi/build_ppi_l1_dataset.py """ from __future__ import annotations import argparse import logging 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" / "ppi_llm" N_PER_CLASS = 300 # Difficulty proportions FRAC_EASY = 0.40 FRAC_MEDIUM = 0.35 FRAC_HARD = 0.25 # Source → L1 gold answer mapping SOURCE_CATEGORY = { "intact": "A", # Direct experimental "huri": "B", # Systematic screen "humap": "C", # Computational inference "string": "D", # Database score absence } SOURCE_LABEL = { "A": "direct_experimental", "B": "systematic_screen", "C": "computational_inference", "D": "database_absence", } def format_l1_context(row: pd.Series, difficulty: str) -> str: """Generate PPI-L1 context with evidence description.""" from negbiodb_ppi.llm_dataset import construct_evidence_description gene1 = row.get("gene_symbol_1") or row.get("uniprot_1", "Protein_1") uniprot1 = row.get("uniprot_1", "") func1 = row.get("function_1", "") loc1 = row.get("location_1", "") gene2 = row.get("gene_symbol_2") or row.get("uniprot_2", "Protein_2") uniprot2 = row.get("uniprot_2", "") func2 = row.get("function_2", "") loc2 = row.get("location_2", "") lines = [ f"Protein 1: {gene1} ({uniprot1})", ] if func1: lines.append(f" Function: {func1[:200]}") if loc1: lines.append(f" Location: {loc1}") lines.append(f"\nProtein 2: {gene2} ({uniprot2})") if func2: lines.append(f" Function: {func2[:200]}") if loc2: lines.append(f" Location: {loc2}") evidence = construct_evidence_description(row, difficulty=difficulty) lines.append(f"\nEvidence: {evidence}") return "\n".join(lines) def sample_class(df: pd.DataFrame, n: int, rng: np.random.RandomState) -> pd.DataFrame: """Sample n records from df, with replacement if needed.""" if len(df) >= n: return df.sample(n=n, random_state=rng, replace=False).reset_index(drop=True) else: logger.warning("Class has %d records, need %d. Sampling with replacement.", len(df), n) return df.sample(n=n, random_state=rng, replace=True).reset_index(drop=True) def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Build PPI-L1 MCQ dataset.") parser.add_argument("--db", type=Path, default=PROJECT_ROOT / "data" / "negbiodb_ppi.db") parser.add_argument("--output", type=Path, default=OUTPUT_DIR / "ppi_l1_dataset.jsonl") parser.add_argument("--seed", type=int, default=42) args = parser.parse_args(argv) from negbiodb_ppi.llm_dataset import ( apply_max_per_protein, assign_splits, load_ppi_candidate_pool, write_dataset_metadata, write_jsonl, ) rng = np.random.RandomState(args.seed) # Load candidates per source (limit large sources to 5x needed at SQL level) all_records = [] for source, letter in SOURCE_CATEGORY.items(): sql_limit = None if source == "intact" else N_PER_CLASS * 5 df = load_ppi_candidate_pool( args.db, source_filter=f"= '{source}'", limit=sql_limit, ) df = apply_max_per_protein(df, max_per_protein=10, rng=rng) df = sample_class(df, N_PER_CLASS, rng) df["gold_answer"] = letter df["gold_category"] = SOURCE_LABEL[letter] all_records.append(df) combined = pd.concat(all_records, ignore_index=True) logger.info("Combined: %d records across %d classes", len(combined), len(SOURCE_CATEGORY)) # 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(SOURCE_CATEGORY.values()): class_df = combined[combined["gold_answer"] == letter].copy() class_df = assign_splits(class_df, fewshot_size=60, val_size=60, test_size=180, seed=args.seed) 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"PPIL1-{i:04d}", "task": "ppi-l1", "split": row["split"], "difficulty": difficulty, "context_text": context, "gold_answer": row["gold_answer"], "gold_category": row["gold_category"], "metadata": { "source_db": row.get("source_db"), "confidence_tier": row.get("confidence_tier"), "result_id": int(row["result_id"]) if pd.notna(row.get("result_id")) else None, "gene_symbol_1": row.get("gene_symbol_1"), "gene_symbol_2": row.get("gene_symbol_2"), "detection_method": row.get("detection_method"), }, } records.append(rec) write_jsonl(records, args.output) # Metadata stats = { "n_total": len(records), "n_per_class": {SOURCE_LABEL[k]: N_PER_CLASS for k in SOURCE_CATEGORY.values()}, "difficulty_distribution": dict(combined["difficulty"].value_counts()), "split_distribution": dict(combined["split"].value_counts()), "seed": args.seed, } write_dataset_metadata(args.output.parent, "ppi-l1", stats) logger.info("PPI-L1 dataset built: %d records", len(records)) return 0 if __name__ == "__main__": sys.exit(main())