"""Export ML benchmark datasets from NegBioDB. Orchestrates the full export pipeline: 1. Generate DB-level splits (random, cold_compound, cold_target, etc.) 2. Export negative dataset (Parquet + splits CSV) 3. Extract ChEMBL positives + merge M1 balanced/realistic 4. Generate random negative controls for Exp 1 5. Generate leakage report Usage: uv run python scripts/export_ml_dataset.py uv run python scripts/export_ml_dataset.py --splits-only uv run python scripts/export_ml_dataset.py --random-negatives uv run python scripts/export_ml_dataset.py --skip-positives Prerequisites: - Database populated: all ETL scripts run - ChEMBL SQLite: data/chembl/chembl_36.db """ import argparse import logging import time from pathlib import Path from negbiodb.db import DEFAULT_DB_PATH, connect from negbiodb.export import ( export_negative_dataset, extract_chembl_positives, generate_cold_compound_split, generate_cold_target_split, generate_degree_balanced_split, generate_degree_matched_negatives, generate_leakage_report, generate_random_split, generate_scaffold_split, generate_temporal_split, generate_uniform_random_negatives, merge_positive_negative, ) logger = logging.getLogger(__name__) def _generate_all_splits(db_path: Path, seed: int) -> None: """Generate all 6 DB-level split strategies.""" seeded_fns = [ ("random_v1", generate_random_split), ("cold_compound_v1", generate_cold_compound_split), ("cold_target_v1", generate_cold_target_split), ("scaffold_v1", generate_scaffold_split), ("degree_balanced_v1", generate_degree_balanced_split), ] with connect(db_path) as conn: for name, fn in seeded_fns: t0 = time.time() logger.info("Generating split: %s", name) fn(conn, seed=seed) logger.info(" %s done (%.1f min)", name, (time.time() - t0) / 60) # temporal split has no seed (deterministic cutoff-based) t0 = time.time() logger.info("Generating split: temporal_v1") generate_temporal_split(conn) logger.info(" temporal_v1 done (%.1f min)", (time.time() - t0) / 60) def main(): parser = argparse.ArgumentParser( description="Export NegBioDB ML benchmark datasets" ) parser.add_argument( "--db-path", type=Path, default=DEFAULT_DB_PATH, help="Path to NegBioDB SQLite database", ) parser.add_argument( "--chembl-db", type=Path, default=Path("data/chembl/chembl_36.db"), help="Path to ChEMBL SQLite database", ) parser.add_argument( "--output-dir", type=Path, default=Path("exports"), help="Output directory for exported files", ) parser.add_argument( "--seed", type=int, default=42, help="Random seed for splits and sampling", ) parser.add_argument( "--splits-only", action="store_true", help="Only generate DB-level splits, skip export", ) parser.add_argument( "--skip-positives", action="store_true", help="Skip ChEMBL positive extraction and M1 merge", ) parser.add_argument( "--random-negatives", action="store_true", help="Generate random negative controls for Exp 1", ) args = parser.parse_args() if args.random_negatives and args.skip_positives: parser.error( "--random-negatives requires positives " "(incompatible with --skip-positives)" ) logging.basicConfig( level=logging.INFO, format="%(asctime)s %(levelname)s %(name)s: %(message)s", datefmt="%H:%M:%S", ) t_total = time.time() # Step 1: Generate splits logger.info("=== Step 1: Generating DB-level splits ===") _generate_all_splits(args.db_path, args.seed) if args.splits_only: logger.info("Done (splits-only mode).") return # Step 2: Export negative dataset logger.info("=== Step 2: Exporting negative dataset ===") t0 = time.time() export_result = export_negative_dataset(args.db_path, args.output_dir) logger.info( "Exported %d pairs (%.1f min)", export_result["total_rows"], (time.time() - t0) / 60, ) # Step 3: M1 merge (positives + negatives) if not args.skip_positives: logger.info("=== Step 3: Extracting ChEMBL positives + M1 merge ===") # 3a: Extract positives t0 = time.time() positives = extract_chembl_positives(args.chembl_db, args.db_path) logger.info( "Extracted %d positives (%.1f min)", len(positives), (time.time() - t0) / 60, ) # 3b: Merge t0 = time.time() m1_result = merge_positive_negative( positives, args.db_path, args.output_dir, seed=args.seed, ) for variant in ("balanced", "realistic"): info = m1_result[variant] logger.info( "M1 %s: %d pos + %d neg = %d total → %s", variant, info["n_pos"], info["n_neg"], info["total"], Path(info["path"]).name, ) logger.info("M1 merge done (%.1f min)", (time.time() - t0) / 60) # Step 4: Random negatives for Exp 1 if args.random_negatives: logger.info("=== Step 4: Random negative controls (Exp 1) ===") t0 = time.time() n_neg = m1_result["balanced"]["n_neg"] logger.info("Target: %d random negatives (matching M1 balanced)", n_neg) uniform_result = generate_uniform_random_negatives( args.db_path, positives, n_samples=n_neg, output_dir=args.output_dir, seed=args.seed, ) logger.info( "Uniform random: %d total → %s (%.1f min)", uniform_result["total"], Path(uniform_result["path"]).name, (time.time() - t0) / 60, ) t0 = time.time() degree_result = generate_degree_matched_negatives( args.db_path, positives, n_samples=n_neg, output_dir=args.output_dir, seed=args.seed, ) logger.info( "Degree-matched: %d total → %s (%.1f min)", degree_result["total"], Path(degree_result["path"]).name, (time.time() - t0) / 60, ) # Step 5: Leakage report logger.info("=== Step 5: Generating leakage report ===") report_path = args.output_dir / "leakage_report.json" report = generate_leakage_report(args.db_path, report_path) logger.info( "Report: %d compounds, %d targets, %d pairs → %s", report["db_summary"]["compounds"], report["db_summary"]["targets"], report["db_summary"]["pairs"], report_path.name, ) logger.info( "=== All done (%.1f min total) ===", (time.time() - t_total) / 60, ) if __name__ == "__main__": main()