#!/usr/bin/env python3 """Evaluate a saved best.pt checkpoint on the test set. Use when a training job times out after saving best.pt but before test evaluation. Usage: python scripts/eval_checkpoint.py \ --model drugban \ --split random \ --negative uniform_random \ --data_dir exports/ \ --output_dir results/baselines/ """ from __future__ import annotations import argparse import json import logging import sys from pathlib import Path import numpy as np logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s", datefmt="%H:%M:%S", stream=sys.stderr, ) logger = logging.getLogger(__name__) ROOT = Path(__file__).parent.parent SCRIPT_DIR = Path(__file__).resolve().parent if str(SCRIPT_DIR) not in sys.path: sys.path.insert(0, str(SCRIPT_DIR)) import train_baseline as baseline def _resolve_run_directory(output_dir: Path, args) -> tuple[str, Path]: """Locate the checkpoint directory, supporting legacy pre-seed naming.""" canonical_run_name = baseline._build_run_name( args.model, args.dataset, args.split, args.negative, args.seed, ) canonical_dir = output_dir / canonical_run_name if canonical_dir.exists(): return canonical_run_name, canonical_dir legacy_names = [ f"{args.model}_{args.split}_{args.negative}", f"{args.model}_{args.split}_{args.negative}_seed{args.seed}", ] for legacy_name in legacy_names: legacy_dir = output_dir / legacy_name if legacy_dir.exists(): logger.warning( "Using legacy run directory %s for logical run %s", legacy_name, canonical_run_name, ) return legacy_name, legacy_dir return canonical_run_name, canonical_dir def main(argv: list[str] | None = None) -> int: parser = argparse.ArgumentParser(description="Evaluate saved checkpoint on test set.") parser.add_argument("--model", required=True, choices=["deepdta", "graphdta", "drugban"]) parser.add_argument("--split", required=True, choices=list(baseline._SPLIT_COL_MAP)) parser.add_argument("--negative", required=True, choices=["negbiodb", "uniform_random", "degree_matched"]) parser.add_argument("--dataset", default="balanced", choices=["balanced", "realistic"]) parser.add_argument("--batch_size", type=int, default=256) parser.add_argument("--seed", type=int, default=42) parser.add_argument("--data_dir", type=Path, default=ROOT / "exports") parser.add_argument("--output_dir", type=Path, default=ROOT / "results" / "baselines") args = parser.parse_args(argv) if args.split == "ddb" and args.dataset != "balanced": logger.error("DDB split is only supported for dataset=balanced.") return 1 filename = baseline._resolve_dataset_file(args.dataset, args.split, args.negative) if filename is None: logger.error( "Dataset combination not supported: dataset=%s, split=%s, negative=%s.", args.dataset, args.split, args.negative, ) return 1 parquet_path = args.data_dir / filename if not parquet_path.exists(): logger.error("Dataset file not found: %s", parquet_path) return 1 split_col = baseline._SPLIT_COL_MAP[args.split] # Run name and output dir (must match train_baseline.py naming) run_name, out_dir = _resolve_run_directory(args.output_dir, args) checkpoint = out_dir / "best.pt" if not checkpoint.exists(): logger.error("No checkpoint found at %s", checkpoint) return 1 results_path = out_dir / "results.json" if results_path.exists(): logger.info("results.json already exists at %s — skipping.", results_path) return 0 logger.info("Evaluating %s on test set from %s", run_name, parquet_path.name) # Device try: import torch if torch.cuda.is_available(): device = torch.device("cuda") elif hasattr(torch.backends, "mps") and torch.backends.mps.is_available(): device = torch.device("mps") else: device = torch.device("cpu") except ImportError: logger.error("torch not found.") return 1 logger.info("Device: %s", device) # Graph cache graph_cache = None if args.model in ("graphdta", "drugban"): cache_path = args.data_dir / "graph_cache.pt" graph_cache = baseline._prepare_graph_cache(parquet_path, cache_path) # Only need test split for eval test_ds = baseline.DTIDataset(parquet_path, split_col, "test", args.model, graph_cache) train_ds = baseline.DTIDataset(parquet_path, split_col, "train", args.model, graph_cache) val_ds = baseline.DTIDataset(parquet_path, split_col, "val", args.model, graph_cache) if len(test_ds) == 0: logger.error("Empty test split. Check split_col=%s", split_col) return 1 logger.info("Test set: %d samples", len(test_ds)) batch_size = args.batch_size if args.model == "drugban" and batch_size > 128: batch_size = 128 test_loader = baseline.make_dataloader(test_ds, batch_size, shuffle=False, device=device) # Build model and evaluate model = baseline.build_model(args.model).to(device) test_metrics = baseline.evaluate(model, test_loader, checkpoint, device) # Load best_val_log_auc from training log if available training_log = out_dir / "training_log.csv" best_val = float("nan") if training_log.exists(): import csv with open(training_log) as f: rows = list(csv.DictReader(f)) if rows: best_val = max(float(r["val_log_auc"]) for r in rows if r["val_log_auc"]) results = { "run_name": run_name, "model": args.model, "split": args.split, "negative": args.negative, "dataset": args.dataset, "seed": args.seed, "best_val_log_auc": best_val, "test_metrics": test_metrics, "n_train": len(train_ds), "n_val": len(val_ds), "n_test": len(test_ds), } baseline.write_results_json(results_path, results) logger.info("Test metrics:") for k, v in test_metrics.items(): logger.info(" %-15s = %.4f", k, v) logger.info("Results saved → %s", results_path) return 0 if __name__ == "__main__": sys.exit(main())