scripts_ct/build_ct_l1_dataset.py

#!/usr/bin/env python3
"""Build CT-L1 MCQ dataset for LLM benchmark.

Generates 1,500 five-way MCQ records across 5 classes:
  A) Safety    (300) — drug toxicity, adverse events, safety signals
  B) Efficacy  (300) — failed to demonstrate therapeutic benefit
  C) Enrollment(300) — failed to recruit sufficient participants
  D) Strategic (300) — business/strategic/portfolio discontinuation
  E) Other     (300) — design, regulatory, PK, or other reasons

Difficulty: gold=easy(40%), silver=medium(35%), bronze=hard(25%)
Split: 300 fewshot (60/class) + 300 val (60/class) + 900 test (180/class)

Output: exports/ct_llm/ct_l1_dataset.jsonl
"""

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" / "ct_llm"

# Class sizes
N_PER_CLASS = 300

# 8-way → 5-way MCQ mapping (from canonical source in llm_prompts)
from negbiodb_ct.llm_prompts import CATEGORY_TO_MCQ

MCQ_TO_LABEL = {
    "A": "safety",
    "B": "efficacy",
    "C": "enrollment",
    "D": "strategic",
    "E": "other",
}

# Difficulty by confidence tier
TIER_TO_DIFFICULTY = {
    "gold": "easy",
    "silver": "medium",
    "bronze": "hard",
}

# Difficulty proportions (target)
FRAC_EASY = 0.40
FRAC_MEDIUM = 0.35
FRAC_HARD = 0.25


def format_l1_context(row: pd.Series) -> str:
    """Generate CT-L1 MCQ context from a trial failure record.

    Gold/Silver: full quantitative context
    Bronze: text-only context (drug, condition, phase, why_stopped)
    """
    lines = [f"Drug: {row.get('intervention_name', 'Unknown')}"]

    # Add molecular type for biologics
    mol_type = row.get("molecular_type")
    if mol_type and mol_type != "small_molecule":
        lines.append(f"Drug type: {mol_type}")

    lines.append(f"Condition: {row.get('condition_name', 'Unknown')}")

    phase = row.get("trial_phase") or row.get("highest_phase_reached")
    if phase:
        lines.append(f"Phase: {phase}")

    tier = row.get("confidence_tier", "bronze")

    if tier in ("gold", "silver"):
        # Full quantitative context
        design = row.get("control_type")
        if design:
            lines.append(f"Design: {design}")
        blinding = row.get("blinding")
        if blinding and pd.notna(blinding):
            lines.append(f"Blinding: {blinding}")
        enrollment = row.get("enrollment_actual")
        if enrollment and pd.notna(enrollment):
            lines.append(f"Enrollment: {int(enrollment)}")

        endpoint_met = row.get("primary_endpoint_met")
        if endpoint_met and pd.notna(endpoint_met):
            lines.append(f"Primary endpoint met: {endpoint_met}")
        p_val = row.get("p_value_primary")
        if p_val and pd.notna(p_val):
            lines.append(f"p-value: {p_val}")
        effect = row.get("effect_size")
        if effect and pd.notna(effect):
            etype = row.get("effect_size_type", "")
            lines.append(f"Effect size ({etype}): {effect}" if etype else f"Effect size: {effect}")
        ci_lo, ci_hi = row.get("ci_lower"), row.get("ci_upper")
        if ci_lo and pd.notna(ci_lo) and ci_hi and pd.notna(ci_hi):
            lines.append(f"95% CI: [{ci_lo}, {ci_hi}]")

        saes = row.get("serious_adverse_events")
        if saes and pd.notna(saes):
            lines.append(f"Serious adverse events: {saes}")

        arm = row.get("arm_description")
        if arm and pd.notna(arm):
            lines.append(f"Arm: {arm}")

        interp = row.get("result_interpretation")
        if interp and pd.notna(interp):
            lines.append(f"Interpretation: {interp}")
    else:
        # Bronze: text-only context
        enrollment = row.get("enrollment_actual")
        if enrollment and pd.notna(enrollment):
            lines.append(f"Enrollment: {int(enrollment)}")
        why = row.get("why_stopped")
        if why and pd.notna(why):
            lines.append(f'Termination reason: "{why}"')
        detail = row.get("failure_detail")
        if detail and pd.notna(detail):
            lines.append(f"Detail: {detail}")

    return "\n".join(lines)


def build_l1_dataset(db_path: Path, seed: int) -> list[dict]:
    """Build CT-L1 dataset from DB."""
    from negbiodb_ct.llm_dataset import (
        apply_max_per_drug,
        infer_therapeutic_area,
        load_candidate_pool,
    )

    rng = np.random.RandomState(seed)

    # Load non-copper candidates
    pool = load_candidate_pool(db_path, tier_filter="!= 'copper'")
    pool["mcq_letter"] = pool["failure_category"].map(CATEGORY_TO_MCQ)
    pool = pool[pool["mcq_letter"].notna()].copy()
    logger.info("Pool after MCQ mapping: %d records", len(pool))

    # Apply max-per-drug cap
    pool = apply_max_per_drug(pool, rng=rng)

    # Assign difficulty by tier
    pool["difficulty"] = pool["confidence_tier"].map(TIER_TO_DIFFICULTY)
    pool.loc[pool["difficulty"].isna(), "difficulty"] = "hard"

    # Sample per class
    all_records = []
    for mcq_letter in "ABCDE":
        class_pool = pool[pool["mcq_letter"] == mcq_letter].copy()

        if len(class_pool) == 0:
            logger.warning("No records for class %s!", mcq_letter)
            continue

        # Stratify by difficulty
        n_target = min(N_PER_CLASS, len(class_pool))
        n_easy = int(n_target * FRAC_EASY)
        n_medium = int(n_target * FRAC_MEDIUM)
        n_hard = n_target - n_easy - n_medium

        sampled_parts = []
        for diff, count in [("easy", n_easy), ("medium", n_medium), ("hard", n_hard)]:
            diff_pool = class_pool[class_pool["difficulty"] == diff]
            actual = min(count, len(diff_pool))
            if actual > 0:
                sampled_parts.append(
                    diff_pool.sample(actual, random_state=rng.randint(0, 2**31))
                )
            shortfall = count - actual
            if shortfall > 0:
                logger.info(
                    "Class %s, diff %s: shortfall %d (available %d)",
                    mcq_letter, diff, shortfall, len(diff_pool),
                )

        if not sampled_parts:
            # Fallback: sample from entire class pool
            n_sample = min(n_target, len(class_pool))
            sampled = class_pool.sample(n_sample, random_state=rng.randint(0, 2**31))
        else:
            sampled = pd.concat(sampled_parts, ignore_index=True)
            # Fill shortfall from remaining pool
            remaining = n_target - len(sampled)
            if remaining > 0:
                used_ids = set(sampled["result_id"])
                leftover = class_pool[~class_pool["result_id"].isin(used_ids)]
                extra = leftover.sample(
                    min(remaining, len(leftover)),
                    random_state=rng.randint(0, 2**31),
                )
                sampled = pd.concat([sampled, extra], ignore_index=True)

        logger.info(
            "Class %s: sampled %d (target %d)",
            mcq_letter, len(sampled), N_PER_CLASS,
        )

        for _, row in sampled.iterrows():
            context_text = format_l1_context(row)
            therapeutic_area = infer_therapeutic_area(row.get("condition_name", ""))
            all_records.append({
                "question_id": None,  # Assigned after splitting
                "task": "CT-L1",
                "gold_answer": mcq_letter,
                "gold_category": row["failure_category"],
                "difficulty": row.get("difficulty", "medium"),
                "context_text": context_text,
                "metadata": {
                    "result_id": int(row["result_id"]),
                    "source_trial_id": row.get("source_trial_id"),
                    "intervention_name": row.get("intervention_name"),
                    "condition_name": row.get("condition_name"),
                    "confidence_tier": row.get("confidence_tier"),
                    "therapeutic_area": therapeutic_area,
                },
            })

    logger.info("Total records: %d", len(all_records))
    return all_records


def main(argv: list[str] | None = None) -> int:
    from negbiodb_ct.llm_dataset import (
        assign_splits,
        write_dataset_metadata,
        write_jsonl,
    )

    parser = argparse.ArgumentParser(description="Build CT-L1 MCQ dataset")
    parser.add_argument("--db-path", type=Path, default=PROJECT_ROOT / "data" / "negbiodb_ct.db")
    parser.add_argument("--output-dir", type=Path, default=OUTPUT_DIR)
    parser.add_argument("--seed", type=int, default=42)
    args = parser.parse_args(argv)

    if not args.db_path.exists():
        logger.error("CT database not found: %s", args.db_path)
        return 1

    records = build_l1_dataset(args.db_path, args.seed)
    if not records:
        logger.error("No records generated!")
        return 1

    # Convert to DataFrame for splitting
    df = pd.DataFrame(records)
    df["mcq_letter"] = df["gold_answer"]

    # Class-balanced split: 60/class fewshot, 60/class val, rest test
    split_records = []
    for letter in "ABCDE":
        class_df = df[df["mcq_letter"] == letter].copy()
        class_df = assign_splits(
            class_df,
            fewshot_size=60,
            val_size=60,
            test_size=len(class_df) - 120,
            seed=args.seed,
        )
        split_records.append(class_df)

    final_df = pd.concat(split_records, ignore_index=True)

    # Assign question IDs
    output_records = []
    for i, (_, row) in enumerate(final_df.iterrows()):
        rec = row.to_dict()
        rec["question_id"] = f"CTL1-{i:04d}"
        # Remove temporary column
        rec.pop("mcq_letter", None)
        output_records.append(rec)

    # Write
    output_path = args.output_dir / "ct_l1_dataset.jsonl"
    write_jsonl(output_records, output_path)

    # Stats
    from collections import Counter
    splits = Counter(r["split"] for r in output_records)
    classes = Counter(r["gold_answer"] for r in output_records)
    diffs = Counter(r["difficulty"] for r in output_records)

    logger.info("=== CT-L1 Dataset Summary ===")
    logger.info("Total: %d", len(output_records))
    logger.info("Classes: %s", dict(classes))
    logger.info("Difficulty: %s", dict(diffs))
    logger.info("Splits: %s", dict(splits))

    write_dataset_metadata(args.output_dir, "ct-l1", {
        "total": len(output_records),
        "classes": dict(classes),
        "difficulty": dict(diffs),
        "splits": dict(splits),
    })

    return 0


if __name__ == "__main__":
    sys.exit(main())