scripts_depmap/train_ge_baseline.py

#!/usr/bin/env python
"""Train GE baseline models (XGBoost + MLP)."""

import argparse
import json
import logging
import sys
from pathlib import Path

import numpy as np
import pandas as pd

_PROJECT_ROOT = Path(__file__).resolve().parent.parent
logging.basicConfig(level=logging.INFO, format="%(levelname)s: %(message)s")
logger = logging.getLogger(__name__)


def main():
    parser = argparse.ArgumentParser(description="Train GE baseline models")
    parser.add_argument("--db-path", type=str, default=None)
    parser.add_argument("--task", type=str, default="m1", choices=["m1", "m2"])
    parser.add_argument("--split", type=str, default="random")
    parser.add_argument("--neg-source", type=str, default="negbiodb",
                        choices=["negbiodb", "uniform_random", "degree_matched"])
    parser.add_argument("--model", type=str, default="xgboost", choices=["xgboost", "mlp"])
    parser.add_argument("--balanced", action="store_true")
    parser.add_argument("--seed", type=int, default=42)
    parser.add_argument("--output-dir", type=str, default=str(_PROJECT_ROOT / "results" / "ge"))
    # Data files for positives
    parser.add_argument("--gene-effect-file", type=str, default=None)
    parser.add_argument("--dependency-file", type=str, default=None)
    args = parser.parse_args()

    from negbiodb_depmap.depmap_db import get_connection
    from negbiodb_depmap.export import (
        apply_split_to_dataset,
        build_ge_m1,
        build_ge_m2,
        export_ge_negatives,
        generate_degree_matched_negatives,
        generate_uniform_random_negatives,
        load_essential_positives,
    )
    from negbiodb_depmap.ge_features import build_feature_matrix

    db_path = Path(args.db_path) if args.db_path else _PROJECT_ROOT / "data" / "negbiodb_depmap.db"
    output_dir = Path(args.output_dir)
    output_dir.mkdir(parents=True, exist_ok=True)

    conn = get_connection(db_path)

    try:
        # Load negatives based on source type
        if args.neg_source == "negbiodb":
            neg_query = """
            SELECT p.gene_id, p.cell_line_id, g.entrez_id, g.gene_symbol,
                   c.model_id, p.gene_degree, p.cell_line_degree,
                   p.mean_gene_effect, p.best_confidence
            FROM gene_cell_pairs p
            JOIN genes g ON p.gene_id = g.gene_id
            JOIN cell_lines c ON p.cell_line_id = c.cell_line_id
            """
            neg_df = pd.read_sql_query(neg_query, conn)
        elif args.neg_source == "uniform_random":
            # Load DB negatives first to determine sample size
            n_db_neg = conn.execute("SELECT COUNT(*) FROM gene_cell_pairs").fetchone()[0]
            neg_df = generate_uniform_random_negatives(conn, n_samples=n_db_neg, seed=args.seed)
            logger.info("Generated %d uniform random control negatives", len(neg_df))
        elif args.neg_source == "degree_matched":
            # Load DB negatives to match their degree distribution
            neg_query = """
            SELECT p.gene_id, p.cell_line_id, g.entrez_id, g.gene_symbol,
                   c.model_id, p.gene_degree, p.cell_line_degree,
                   p.mean_gene_effect, p.best_confidence
            FROM gene_cell_pairs p
            JOIN genes g ON p.gene_id = g.gene_id
            JOIN cell_lines c ON p.cell_line_id = c.cell_line_id
            """
            db_neg_df = pd.read_sql_query(neg_query, conn)
            neg_df = generate_degree_matched_negatives(conn, db_neg_df, seed=args.seed)
            logger.info("Generated %d degree-matched control negatives", len(neg_df))

        # Load positives
        if args.gene_effect_file and args.dependency_file:
            pos_df = load_essential_positives(
                conn,
                Path(args.gene_effect_file),
                Path(args.dependency_file),
            )
        else:
            logger.warning("No gene-effect/dependency files provided. Using synthetic positives.")
            pos_df = pd.DataFrame(columns=neg_df.columns)

        if len(pos_df) == 0:
            logger.error("No positives loaded. Provide --gene-effect-file and --dependency-file.")
            sys.exit(1)

        # Build dataset
        if args.task == "m1":
            dataset = build_ge_m1(
                conn, pos_df, neg_df,
                balanced=args.balanced, seed=args.seed,
            )
        else:
            dataset = build_ge_m2(conn, pos_df, neg_df, seed=args.seed)

        # Build features
        X = build_feature_matrix(conn, dataset)
        y = dataset["label"].values

        # Split
        dataset = apply_split_to_dataset(dataset, args.split, seed=args.seed)
        split_col = "split"

        train_mask = dataset[split_col] == "train"
        val_mask = dataset[split_col] == "val"
        test_mask = dataset[split_col] == "test"

        X_train, y_train = X[train_mask], y[train_mask]
        X_val, y_val = X[val_mask], y[val_mask]
        X_test, y_test = X[test_mask], y[test_mask]

        logger.info("Train: %d, Val: %d, Test: %d", len(y_train), len(y_val), len(y_test))

        # Train
        if args.model == "xgboost":
            from negbiodb_depmap.models.xgboost_ge import train_xgboost_ge, predict_xgboost_ge
            task_type = "binary" if args.task == "m1" else "multiclass"
            model = train_xgboost_ge(X_train, y_train, X_val, y_val, task=task_type, seed=args.seed)
            y_pred, y_prob = predict_xgboost_ge(model, X_test, task=task_type)
        else:
            from negbiodb_depmap.models.mlp_features import train_mlp_ge
            n_classes = 2 if args.task == "m1" else 3
            model, history = train_mlp_ge(X_train, y_train, X_val, y_val, n_classes=n_classes)
            import torch
            with torch.no_grad():
                logits = model(torch.tensor(X_test, dtype=torch.float32))
                y_prob = torch.softmax(logits, dim=1).numpy()
                y_pred = np.argmax(y_prob, axis=1)

        # Evaluate
        from sklearn.metrics import accuracy_score, f1_score, matthews_corrcoef
        results = {
            "task": args.task,
            "model": args.model,
            "split": args.split,
            "neg_source": args.neg_source,
            "seed": args.seed,
            "n_train": int(len(y_train)),
            "n_val": int(len(y_val)),
            "n_test": int(len(y_test)),
            "accuracy": float(accuracy_score(y_test, y_pred)),
            "macro_f1": float(f1_score(y_test, y_pred, average="macro", zero_division=0)),
            "mcc": float(matthews_corrcoef(y_test, y_pred)),
        }

        if args.task == "m1" and len(y_prob.shape) > 1:
            from sklearn.metrics import roc_auc_score
            try:
                results["auroc"] = float(roc_auc_score(y_test, y_prob[:, 1]))
            except ValueError:
                results["auroc"] = None

        # Save
        run_name = f"{args.task}_{args.model}_{args.split}_{args.neg_source}_s{args.seed}"
        result_path = output_dir / f"{run_name}.json"
        with open(result_path, "w") as f:
            json.dump(results, f, indent=2)

        logger.info("Results: %s", json.dumps(results, indent=2))
        logger.info("Saved to %s", result_path)

    finally:
        conn.close()


if __name__ == "__main__":
    main()