#!/usr/bin/env python3 """Portable release of the six-policy offline MolAS acquisition runner. Historical source is preserved separately; see README.md for provenance and release-only I/O, validation, metadata, and resume-log changes. """ from __future__ import annotations import argparse import hashlib import json import math import os import tempfile import time import uuid from datetime import datetime, timezone from dataclasses import dataclass from pathlib import Path import numpy as np import pandas as pd from sklearn.metrics import mean_absolute_error, mean_squared_error from sklearn.neural_network import MLPRegressor from sklearn.pipeline import make_pipeline from sklearn.preprocessing import StandardScaler from release_support import (add_path_arguments, environment_versions, fingerprint, invocation_arguments, previous_checkpoint_size, verify_existing_run) HERE = Path(__file__).resolve().parent ROOT = HERE.parents[1] DATA = ROOT / "data/raw" FEATURE_CACHE = ROOT / "data/features/complex_features_ligand_protein_d256_seed0.npy" FEATURE_IDS = ROOT / "data/features/complex_feature_ids.csv" OUTPUT = ROOT / "outputs/acquisition" DESCRIPTORS = ROOT / "data/descriptors/moad_physical_descriptors_filtered.csv" FOLD_SPLIT = ROOT / "data/splits/moad_5fold_split_seed42.csv" def configure_paths(args: argparse.Namespace) -> None: global DATA, FEATURE_CACHE, FEATURE_IDS, OUTPUT, DESCRIPTORS, FOLD_SPLIT DATA = args.data_dir.expanduser().resolve() FEATURE_CACHE = args.features.expanduser().resolve() FEATURE_IDS = args.feature_ids.expanduser().resolve() OUTPUT = args.output_dir.expanduser().resolve() DESCRIPTORS = args.descriptors.expanduser().resolve() FOLD_SPLIT = args.fold_split.expanduser().resolve() ALGORITHMS = [ "surfdock", "unimol", "diffdock", "diffdock_l", "gnina", "autodock", "smina", ] SVD_RANKS = (1, 2, 3, 5) LAMBDA = 3.0 METHODS = ( "plain_mean_ucb", "direct_cost_uc", "runtime_uncertainty", "cost_tiers_5", "relaxed_cost_power_05", "log_cost", ) COST_METHODS = set(METHODS) - {"plain_mean_ucb"} ENSEMBLE_COST_METHODS = {"runtime_uncertainty"} def atomic_json(path: Path, value: object) -> None: path.parent.mkdir(parents=True, exist_ok=True) with tempfile.NamedTemporaryFile("w", dir=path.parent, delete=False) as handle: json.dump(value, handle, indent=2, allow_nan=True) tmp = Path(handle.name) os.replace(tmp, path) def atomic_csv(path: Path, frame: pd.DataFrame, *, index: bool = True) -> None: path.parent.mkdir(parents=True, exist_ok=True) with tempfile.NamedTemporaryFile("w", dir=path.parent, delete=False) as handle: frame.to_csv(handle, index=index, float_format="%.8g") tmp = Path(handle.name) os.replace(tmp, path) def sha256(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as handle: for block in iter(lambda: handle.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def read_matrix(name: str) -> tuple[pd.Index, np.ndarray]: frame = pd.read_csv(DATA / name, index_col=0) if "rmsd" in name: suffix = "_rmsd" elif "pb_ratio" in name: suffix = "_pb_ratio" elif "runtime" in name: suffix = "_runtime" else: raise ValueError(f"Unknown matrix schema: {name}") source_columns = [f"{algorithm}{suffix}" for algorithm in ALGORITHMS] missing = [column for column in source_columns if column not in frame.columns] if missing: raise ValueError(f"{name} is missing algorithm columns: {missing}") return frame.index, frame.loc[:, source_columns].to_numpy(dtype=np.float64) def _identifier_column(frame: pd.DataFrame, expected: pd.Index, source: Path) -> str: expected_values = set(expected.astype(str)) matches = [] for column in frame.columns: values = frame[column].astype(str) if values.is_unique and set(values) == expected_values: matches.append(column) if len(matches) != 1: raise ValueError( f"{source.name}: expected exactly one identifier column matching all matrix rows; " f"found {matches}" ) return matches[0] def aligned_auxiliary_frame(path: Path, expected: pd.Index) -> pd.DataFrame: if not path.exists(): raise FileNotFoundError( f"Missing input: {path}. See {HERE / 'README.md'}" ) frame = pd.read_csv(path) identifier = _identifier_column(frame, expected, path) frame[identifier] = frame[identifier].astype(str) aligned = frame.set_index(identifier).loc[expected.astype(str)] if aligned.index.duplicated().any(): raise ValueError(f"{path.name}: duplicate complex identifiers") return aligned def load_descriptors(expected: pd.Index) -> np.ndarray: frame = aligned_auxiliary_frame(DESCRIPTORS, expected) numeric = frame.select_dtypes(include=[np.number]) if numeric.shape[1] != 4: raise ValueError( f"{DESCRIPTORS.name}: expected exactly four numeric physical descriptors, " f"found {list(numeric.columns)}" ) if not np.isfinite(numeric.to_numpy(dtype=float)).all(): raise ValueError(f"{DESCRIPTORS.name}: physical descriptors contain missing/non-finite values") return numeric.to_numpy(dtype=np.float32) def load_folds(expected: pd.Index) -> np.ndarray: frame = aligned_auxiliary_frame(FOLD_SPLIT, expected) candidate_columns = [ column for column in frame.columns if "fold" in column.lower() and pd.api.types.is_numeric_dtype(frame[column]) ] if len(candidate_columns) != 1: raise ValueError( f"{FOLD_SPLIT.name}: expected one numeric fold column, found {candidate_columns}" ) values = frame[candidate_columns[0]].to_numpy(dtype=np.float64) if not np.isfinite(values).all() or not np.equal(values, np.floor(values)).all(): raise ValueError(f"{FOLD_SPLIT.name}: fold labels must be finite integers") folds = values.astype(np.int64) unique = sorted(np.unique(folds).tolist()) if unique == [1, 2, 3, 4, 5]: folds = folds - 1 unique = sorted(np.unique(folds).tolist()) if unique != [0, 1, 2, 3, 4]: raise ValueError(f"{FOLD_SPLIT.name}: expected five folds encoded 0-4 or 1-5; found {unique}") return folds def strict_score(rmsd: np.ndarray, pb_ratio: np.ndarray) -> np.ndarray: """Established MolAS strict-score definition used by Design 2.""" with np.errstate(over="ignore", invalid="ignore"): rmsd_score = (1.0 + np.exp(-2.0 * LAMBDA)) / ( 1.0 + np.exp(LAMBDA * (rmsd - 2.0)) ) return np.clip(np.nan_to_num(rmsd_score) * (pb_ratio == 1.0), 0.0, 1.0) def svd_complete( truth: np.ndarray, observed: np.ndarray, rank: int, iterations: int = 6, ) -> np.ndarray: if observed.all(): return truth.copy() if not observed.any(): raise ValueError("SVD completion requires an observed warm start") global_mean = float(truth[observed].mean()) filled = np.empty_like(truth) for column in range(observed.shape[1]): mask = observed[:, column] filled[:, column] = float(truth[mask, column].mean()) if mask.any() else global_mean filled[observed] = truth[observed] for _ in range(iterations): column_mean = filled.mean(axis=0, keepdims=True) u, s, vt = np.linalg.svd(filled - column_mean, full_matrices=False) use_rank = min(rank, len(s)) filled = (u[:, :use_rank] * s[:use_rank]) @ vt[:use_rank] + column_mean filled = np.clip(filled, 0.0, 1.0) filled[observed] = truth[observed] return filled def score_ensemble(truth: np.ndarray, observed: np.ndarray) -> tuple[np.ndarray, np.ndarray]: stack = np.stack([svd_complete(truth, observed, rank, iterations=4) for rank in SVD_RANKS]) return stack.mean(axis=0), stack.std(axis=0) def warm_start(shape: tuple[int, int], seed: int, fraction: float = 0.01) -> np.ndarray: """Runtime-blind warm start with nearly equal representation by algorithm.""" rows, columns = shape count = math.ceil(rows * columns * fraction) rng = np.random.default_rng(731_000 + seed) chosen: list[int] = [] per_algorithm = count // columns remainder = count % columns for column in range(columns): number = per_algorithm + int(column < remainder) selected_rows = rng.choice(rows, size=number, replace=False) chosen.extend((selected_rows * columns + column).tolist()) rng.shuffle(chosen) return np.asarray(chosen, dtype=np.int64) def percentile_rank(values: np.ndarray) -> np.ndarray: return pd.Series(values).rank(method="average", pct=True).to_numpy(dtype=np.float64) def quantiles(values: np.ndarray) -> dict[str, float]: if values.size == 0: return {key: math.nan for key in ("min", "q05", "q25", "median", "q75", "q95", "max")} qs = np.quantile(values, [0, 0.05, 0.25, 0.5, 0.75, 0.95, 1]) return dict(zip(("min", "q05", "q25", "median", "q75", "q95", "max"), map(float, qs))) @dataclass class RuntimePrediction: mean: np.ndarray sd: np.ndarray conservative: np.ndarray lower: float upper: float class RuntimeSurrogate: """Observed-only runtime predictor with positive, round-local bounds.""" def __init__(self, features: np.ndarray, algorithms: int = 7): one_hot = np.eye(algorithms, dtype=np.float32) expanded = np.repeat(features, algorithms, axis=0) algorithm_features = np.tile(one_hot, (features.shape[0], 1)) self.x = np.concatenate([expanded, algorithm_features], axis=1) def predict( self, observed_flat: np.ndarray, observed_runtime: np.ndarray, candidates: np.ndarray, seed: int, ensemble_size: int, legacy: bool = False, ) -> RuntimePrediction: y = np.log1p(observed_runtime) q05, q95 = np.quantile(observed_runtime, [0.05, 0.95]) lower = max(float(q05), np.finfo(float).eps) upper = max(float(q95), lower * (1.0 + 1e-6)) predictions = [] for member in range(ensemble_size): member_seed = seed * 1009 + member * 97 model = make_pipeline( StandardScaler(), MLPRegressor( hidden_layer_sizes=(32, 16), activation="relu", solver="adam", alpha=1e-4, batch_size=min(128, len(observed_flat)), learning_rate_init=1e-3, max_iter=10, early_stopping=len(observed_flat) >= 80, validation_fraction=0.15, n_iter_no_change=5, random_state=member_seed, ), ) model.fit(self.x[observed_flat], y) predicted_log = model.predict(self.x[candidates]) raw = np.expm1(predicted_log) if legacy: raw = np.clip(raw, 1e-6, float(np.median(observed_runtime) * 100.0)) else: raw = np.clip(raw, lower, upper) predictions.append(raw) stack = np.stack(predictions) mean = stack.mean(axis=0) sd = stack.std(axis=0) conservative = mean + sd if not legacy: conservative = np.clip(conservative, lower, upper) return RuntimePrediction(mean, sd, conservative, lower, upper) class HiddenOracle: """The only object permitted to hold unrevealed scores and runtimes.""" def __init__(self, score: np.ndarray, runtime: np.ndarray): self._score = score self._runtime = runtime self.shape = score.shape self.access_log: list[dict[str, int]] = [] def reveal(self, flat: np.ndarray, round_id: int) -> tuple[np.ndarray, np.ndarray]: rows, columns = np.unravel_index(flat, self.shape) self.access_log.extend( {"flat_index": int(index), "round": int(round_id)} for index in flat ) return self._score[rows, columns], self._runtime[rows, columns] def evaluate(self, prediction: np.ndarray, observed: np.ndarray) -> dict[str, float]: """Evaluate without exposing truth back to the acquisition pipeline.""" truth = self._score missing = ~observed result = { "full_mae": float(mean_absolute_error(truth.ravel(), prediction.ravel())), "full_rmse": float(mean_squared_error(truth.ravel(), prediction.ravel()) ** 0.5), } if missing.any(): result["unqueried_mae"] = float(mean_absolute_error(truth[missing], prediction[missing])) result["unqueried_rmse"] = float(mean_squared_error(truth[missing], prediction[missing]) ** 0.5) else: result["unqueried_mae"] = 0.0 result["unqueried_rmse"] = 0.0 true_top = truth.argmax(axis=1) pred_top = prediction.argmax(axis=1) result["top1_agreement"] = float(np.mean(true_top == pred_top)) true_top3 = np.argsort(-truth, axis=1)[:, :3] pred_top3 = np.argsort(-prediction, axis=1)[:, :3] result["top3_overlap"] = float( np.mean([len(set(a).intersection(b)) / 3.0 for a, b in zip(true_top3, pred_top3)]) ) discounts = 1.0 / np.log2(np.arange(2, 5)) ndcgs = [] for row in range(truth.shape[0]): gain = truth[row, pred_top3[row]] ideal = truth[row, true_top3[row]] denominator = float(np.sum(ideal * discounts)) ndcgs.append(float(np.sum(gain * discounts) / denominator) if denominator else 1.0) result["ndcg_at_3"] = float(np.mean(ndcgs)) pair_correct: list[np.ndarray] = [] for left in range(truth.shape[1]): for right in range(left + 1, truth.shape[1]): true_sign = np.sign(truth[:, left] - truth[:, right]) pred_sign = np.sign(prediction[:, left] - prediction[:, right]) non_tie = true_sign != 0 if non_tie.any(): pair_correct.append((true_sign[non_tie] == pred_sign[non_tie]).astype(float)) result["pairwise_ranking_accuracy"] = float(np.concatenate(pair_correct).mean()) result["vbs_regret"] = float(np.mean(truth.max(axis=1) - truth[np.arange(truth.shape[0]), pred_top])) return result def continuous_cost_scale(cost: np.ndarray) -> np.ndarray: if np.allclose(cost.min(), cost.max()): return np.ones_like(cost) return 1.0 + 4.0 * (cost - cost.min()) / (cost.max() - cost.min()) def cost_tiers(cost: np.ndarray, number: int) -> np.ndarray: edges = np.quantile(cost, np.arange(1, number) / number) return np.digitize(cost, edges, right=True).astype(float) + 1.0 def acquisition_values( method: str, utility_mean: np.ndarray, utility_sd: np.ndarray, runtime: RuntimePrediction | None, candidate_algorithms: np.ndarray, cumulative_algorithm_counts: np.ndarray, rng: np.random.Generator, ) -> tuple[np.ndarray, np.ndarray, np.ndarray]: utility = utility_mean + utility_sd if method == "plain_mean_ucb": return utility, utility.copy(), np.full(utility.size, np.nan) assert runtime is not None if method == "direct_cost_uc": return utility, utility / (runtime.mean + 1e-6), runtime.mean normalized_utility = np.maximum(percentile_rank(utility), 1e-3) selected_cost = runtime.conservative if method in ENSEMBLE_COST_METHODS else runtime.mean scaled_cost = continuous_cost_scale(selected_cost) if method == "relaxed_cost_power_05": acquisition = normalized_utility / np.sqrt(scaled_cost) elif method == "cost_tiers_5": acquisition = normalized_utility / cost_tiers(selected_cost, 5) elif method == "runtime_uncertainty": acquisition = normalized_utility / np.sqrt(scaled_cost) elif method == "log_cost": acquisition = normalized_utility / np.log1p(scaled_cost) else: raise ValueError(f"Unknown method: {method}") return utility, acquisition, selected_cost def choose_batch( candidates: np.ndarray, acquisition: np.ndarray, batch_size: int, columns: int, hard_cap: bool, ) -> np.ndarray: order = np.argsort(-acquisition, kind="stable") if not hard_cap: return candidates[order[:batch_size]] cap = max(1, math.floor(0.35 * batch_size)) counts = np.zeros(columns, dtype=int) selected: list[int] = [] deferred: list[int] = [] for position in order: flat = int(candidates[position]) algorithm = flat % columns if counts[algorithm] < cap: selected.append(flat) counts[algorithm] += 1 if len(selected) == batch_size: break else: deferred.append(flat) if len(selected) < batch_size: selected.extend(deferred[: batch_size - len(selected)]) return np.asarray(selected, dtype=np.int64) def audit_summary( utility: np.ndarray, acquisition: np.ndarray, runtime: RuntimePrediction | None, selected_positions: np.ndarray, ) -> dict[str, object]: finite = np.isfinite(acquisition) safe_acquisition = acquisition[finite] overlap_count = min(50, utility.size) utility_top = set(np.argsort(-utility)[:overlap_count].tolist()) acquisition_top = set(np.argsort(-acquisition)[:overlap_count].tolist()) summary: dict[str, object] = { "utility_quantiles": quantiles(utility), "acquisition_quantiles": quantiles(safe_acquisition), "utility_acquisition_spearman": float(pd.Series(utility[finite]).corr(pd.Series(acquisition[finite]), method="spearman")), "top50_overlap": len(utility_top.intersection(acquisition_top)) / overlap_count, "selected_utility_mean": float(utility[selected_positions].mean()), "selected_acquisition_mean": float(acquisition[selected_positions].mean()), } if runtime is not None: summary.update( runtime_mean_quantiles=quantiles(runtime.mean), runtime_sd_quantiles=quantiles(runtime.sd), selected_predicted_runtime_mean=float(runtime.mean[selected_positions].mean()), runtime_lower_bound=runtime.lower, runtime_upper_bound=runtime.upper, predictions_at_lower_bound=int(np.isclose(runtime.mean, runtime.lower).sum()), predictions_at_upper_bound=int(np.isclose(runtime.mean, runtime.upper).sum()), ) return summary def checkpoint_paths(run_dir: Path, percentage: int) -> dict[str, Path]: label = f"{percentage:03d}pct" return { "matrix": run_dir / "strict_score_matrices" / f"strict_score_{label}.csv", "cumulative": run_dir / "queried_cells" / "cumulative" / f"queried_{label}.csv", "new": run_dir / "queried_cells" / "newly_queried" / f"queried_{label}.csv", "candidate": run_dir / "candidate_acquisition_audits" / f"audit_{label}.json", "distribution": run_dir / "algorithm_query_distributions" / f"distribution_{label}.csv", "reconstruction": run_dir / "reconstruction_metrics" / f"metrics_{label}.json", "runtime": run_dir / "runtime_prediction_metrics" / f"metrics_{label}.json", } def query_frame(records: list[dict[str, object]], indices: list[int], columns: int) -> pd.DataFrame: selected = [records[index] for index in indices] return pd.DataFrame(selected) def export_checkpoint( run_dir: Path, percentage: int, prediction: np.ndarray, row_index: pd.Index, records: list[dict[str, object]], previous_count: int, oracle: HiddenOracle, observed: np.ndarray, ) -> dict[str, float]: paths = checkpoint_paths(run_dir, percentage) atomic_csv(paths["matrix"], pd.DataFrame(prediction, index=row_index, columns=ALGORITHMS)) cumulative_indices = list(range(len(records))) new_indices = list(range(previous_count, len(records))) atomic_csv(paths["cumulative"], query_frame(records, cumulative_indices, len(ALGORITHMS)), index=False) atomic_csv(paths["new"], query_frame(records, new_indices, len(ALGORITHMS)), index=False) counts = pd.Series([record["algorithm"] for record in records]).value_counts().reindex(ALGORITHMS, fill_value=0) distribution = pd.DataFrame({"algorithm": ALGORITHMS, "cumulative_count": counts.to_numpy()}) distribution["cumulative_share"] = distribution["cumulative_count"] / len(records) atomic_csv(paths["distribution"], distribution, index=False) metrics = oracle.evaluate(prediction, observed) metrics.update(percentage=percentage, queried_cells=len(records)) atomic_json(paths["reconstruction"], metrics) return metrics def load_inputs() -> tuple[pd.Index, np.ndarray, np.ndarray, np.ndarray, np.ndarray]: rmsd_index, rmsd = read_matrix("moad_rmsd_trimmed.csv") pb_index, pb = read_matrix("moad_pb_ratio_trimmed.csv") runtime_index, runtime = read_matrix("moad_runtime_trimmed.csv") if not rmsd_index.equals(pb_index) or not rmsd_index.equals(runtime_index): raise ValueError("Input matrix row labels are not aligned") if not np.isfinite(runtime).all() or (runtime < 0).any(): raise ValueError("Runtime matrix must contain finite, nonnegative seconds") if not rmsd_index.is_unique or rmsd_index.hasnans: raise ValueError("Raw matrices require unique, non-missing complex identifiers") features = np.load(FEATURE_CACHE, allow_pickle=False).astype(np.float32) if features.ndim != 2 or features.shape != (len(rmsd_index), 256): raise ValueError("Expected a finite molecular feature matrix with one row per complex and 256 columns") if not np.isfinite(features).all(): raise ValueError("Molecular features contain non-finite values") if not FEATURE_IDS.is_file(): raise FileNotFoundError( f"Missing producer-verified feature-row identifiers: {FEATURE_IDS}. " "Shape alone cannot establish cache alignment; do not create this file by guessing raw-matrix order." ) feature_ids = pd.read_csv(FEATURE_IDS, dtype=str, keep_default_na=False) if feature_ids.shape[1] != 1 or feature_ids.iloc[:, 0].tolist() != rmsd_index.astype(str).tolist(): raise ValueError("Feature-row identifier CSV must have one column matching matrix identifiers in exactly the same order") descriptors = load_descriptors(rmsd_index) folds = load_folds(rmsd_index) combined_features = np.concatenate([features, descriptors], axis=1) return rmsd_index, strict_score(rmsd, pb), runtime, combined_features, folds def run_one( method: str, seed: int, fold: int, *, smoke_test: bool = False, resume: bool = True, context: dict[str, object] | None = None, prepared_inputs: tuple | None = None, ) -> None: if method not in METHODS: raise ValueError(method) row_index, score_truth, runtime_truth, features, fold_labels = ( load_inputs() if prepared_inputs is None else prepared_inputs ) training = fold_labels != fold row_index = row_index[training] score_truth = score_truth[training] runtime_truth = runtime_truth[training] features = features[training] if smoke_test: score_truth = score_truth[:120] runtime_truth = runtime_truth[:120] features = features[:120] row_index = row_index[:120] rows, columns = score_truth.shape total = rows * columns run_root = ( OUTPUT / ("smoke" if smoke_test else "runs") / method / f"fold{fold}" / f"seed{seed}" ) state_path = run_root / "run_state" / "state.json" log_path = run_root / "run_state" / "events.jsonl" specification = { "method": method, "fold": fold, "seed": seed, "smoke_test": smoke_test, "context": context if context is not None else build_run_context(), } configuration_fingerprint = fingerprint(specification) if verify_existing_run(run_root, configuration_fingerprint, resume=resume): print(f"Already complete with matching provenance: {run_root}", flush=True) return atomic_json(run_root / "run_state/run_manifest.json", { "schema_version": 1, "configuration_fingerprint": configuration_fingerprint, "run": specification, }) oracle = HiddenOracle(score_truth, runtime_truth) runtime_model = RuntimeSurrogate(features, columns) if resume and state_path.exists(): state = json.loads(state_path.read_text()) records = state["records"] last_checkpoint = int(state["last_checkpoint"]) round_id = int(state["round_id"]) pending_round_audits = state.get("pending_round_audits", []) if (state.get("method"), state.get("fold"), state.get("seed")) != (method, fold, seed): raise RuntimeError("Resume-state job identity does not match the requested run") observed_flat = np.asarray([record["flat_index"] for record in records], dtype=np.int64) revealed_score, revealed_runtime = oracle.reveal(observed_flat, -1) for record, score, runtime in zip(records, revealed_score, revealed_runtime): if not np.isclose(float(record["score"]), score) or not np.isclose(float(record["runtime"]), runtime): raise RuntimeError("Resume-state oracle values do not match current inputs") else: observed_flat = warm_start(score_truth.shape, seed) revealed_score, revealed_runtime = oracle.reveal(observed_flat, 0) records = [] for flat, score, runtime in zip(observed_flat, revealed_score, revealed_runtime): row, column = divmod(int(flat), columns) records.append( { "query_order": len(records) + 1, "round": 0, "flat_index": int(flat), "row_index": row, "row_label": str(row_index[row]), "algorithm_index": column, "algorithm": ALGORITHMS[column], "utility": math.nan, "acquisition": math.nan, "predicted_runtime_mean": math.nan, "predicted_runtime_sd": math.nan, "score": float(score), "runtime": float(runtime), } ) last_checkpoint = 0 round_id = 0 pending_round_audits = [] observed = np.zeros(total, dtype=bool) observed[observed_flat] = True checkpoint_targets = {percentage: math.ceil(total * percentage / 100.0) for percentage in range(1, 101)} checkpoint_targets[100] = total previous_checkpoint_count = previous_checkpoint_size(last_checkpoint, checkpoint_targets) rng = np.random.default_rng(seed * 100_003 + METHODS.index(method) * 997) started = time.time() for percentage in range(max(1, last_checkpoint + 1), 101): target = checkpoint_targets[percentage] round_audits: list[dict[str, object]] = list(pending_round_audits) pending_round_audits = [] while observed.sum() < target: round_id += 1 score_mean, score_sd = score_ensemble(score_truth, observed.reshape(score_truth.shape)) candidates = np.flatnonzero(~observed) candidate_rows, candidate_algorithms = np.unravel_index(candidates, score_truth.shape) utility_mean = score_mean[candidate_rows, candidate_algorithms] utility_sd = score_sd[candidate_rows, candidate_algorithms] prediction = None if method in COST_METHODS: queried = np.flatnonzero(observed) runtime_ledger = { int(record["flat_index"]): float(record["runtime"]) for record in records } observed_runtime = np.asarray( [runtime_ledger[int(index)] for index in queried], dtype=np.float64, ) prediction = runtime_model.predict( queried, observed_runtime, candidates, seed + round_id * 31, 3 if method in ENSEMBLE_COST_METHODS else 1, legacy=method == "legacy_direct_cost_mean_ucb", ) cumulative_counts = np.bincount(np.flatnonzero(observed) % columns, minlength=columns) utility, acquisition, selected_cost = acquisition_values( method, utility_mean, utility_sd, prediction, candidate_algorithms, cumulative_counts, rng, ) batch_size = min(50, target - int(observed.sum())) selected_flat = choose_batch( candidates, acquisition, batch_size, columns, hard_cap=method == "hard_cap_35", ) candidate_lookup = {int(flat): position for position, flat in enumerate(candidates)} positions = np.asarray([candidate_lookup[int(flat)] for flat in selected_flat], dtype=int) round_audit = audit_summary(utility, acquisition, prediction, positions) round_audit.update(round=round_id, selected_cells=batch_size) round_audits.append(round_audit) revealed_score, revealed_runtime = oracle.reveal(selected_flat, round_id) for flat, score, runtime, position in zip(selected_flat, revealed_score, revealed_runtime, positions): row, column = divmod(int(flat), columns) records.append( { "query_order": len(records) + 1, "round": round_id, "flat_index": int(flat), "row_index": row, "row_label": str(row_index[row]), "algorithm_index": column, "algorithm": ALGORITHMS[column], "utility": float(utility[position]), "acquisition": float(acquisition[position]), "predicted_runtime_mean": float(prediction.mean[position]) if prediction is not None else math.nan, "predicted_runtime_sd": float(prediction.sd[position]) if prediction is not None else math.nan, "score": float(score), "runtime": float(runtime), } ) observed[selected_flat] = True state = { "version": 1, "method": method, "fold": fold, "seed": seed, "round_id": round_id, "last_checkpoint": percentage - 1, "records": records, "pending_round_audits": round_audits, } atomic_json(state_path, state) with log_path.open("a") as handle: handle.write(json.dumps({"event": "microbatch", "method": method, "fold": fold, "seed": seed, "round": round_id, "observed": int(observed.sum()), "target_percentage": percentage}) + "\n") final_prediction = svd_complete(score_truth, observed.reshape(score_truth.shape), rank=3) metrics = export_checkpoint( run_root, percentage, final_prediction, row_index, records, previous_checkpoint_count, oracle, observed.reshape(score_truth.shape), ) paths = checkpoint_paths(run_root, percentage) atomic_json(paths["candidate"], {"percentage": percentage, "rounds": round_audits}) queried_runtime = np.asarray([record["runtime"] for record in records], dtype=float) runtime_metrics = { "percentage": percentage, "queried_cells": len(records), "cumulative_true_runtime": float(queried_runtime.sum()), "mean_true_runtime": float(queried_runtime.mean()), } predicted = np.asarray([record["predicted_runtime_mean"] for record in records], dtype=float) valid = np.isfinite(predicted) if valid.any(): runtime_metrics.update( prediction_mae=float(mean_absolute_error(queried_runtime[valid], predicted[valid])), prediction_rmse=float(mean_squared_error(queried_runtime[valid], predicted[valid]) ** 0.5), prediction_spearman=float(pd.Series(queried_runtime[valid]).corr(pd.Series(predicted[valid]), method="spearman")), ) atomic_json(paths["runtime"], runtime_metrics) previous_checkpoint_count = target state = { "version": 1, "method": method, "fold": fold, "seed": seed, "round_id": round_id, "last_checkpoint": percentage, "records": records, "pending_round_audits": [], "last_metrics": metrics, } atomic_json(state_path, state) with log_path.open("a") as handle: handle.write(json.dumps({"event": "checkpoint", "method": method, "fold": fold, "seed": seed, "percentage": percentage, "observed": len(records), "elapsed_seconds": time.time() - started}) + "\n") atomic_json( run_root / "run_state" / "complete.json", { "method": method, "fold": fold, "seed": seed, "checkpoints": 100, "configuration_fingerprint": configuration_fingerprint, "queried_cells": len(records), "oracle_accesses": len(oracle.access_log), "elapsed_seconds": time.time() - started, }, ) def input_files() -> dict[str, Path]: return { "rmsd": DATA / "moad_rmsd_trimmed.csv", "pb_ratio": DATA / "moad_pb_ratio_trimmed.csv", "runtime": DATA / "moad_runtime_trimmed.csv", "features": FEATURE_CACHE, "feature_ids": FEATURE_IDS, "descriptors": DESCRIPTORS, "fold_split": FOLD_SPLIT, } def build_run_context() -> dict[str, object]: return { "implementation": "publication release; historical source snapshot is separate", "input_files": {role: {"filename": path.name, "bytes": path.stat().st_size, "sha256": sha256(path)} for role, path in input_files().items()}, "code_sha256": {name: sha256(HERE / name) for name in ("run_experiment.py", "release_support.py")}, "environment": environment_versions(), "configuration": { "algorithms": ALGORITHMS, "score_lambda": LAMBDA, "acquisition_svd_ranks": list(SVD_RANKS), "acquisition_svd_iterations": 4, "export_svd_rank": 3, "export_svd_iterations": 6, "beta": 1.0, "microbatch_maximum": 50, "checkpoints": list(range(1, 101)), "warm_start_fraction": 0.01, "runtime_surrogate": {"family": "MLPRegressor", "hidden_layers": [32, 16], "max_iterations_per_refit": 10, "target": "log1p(runtime)", "observed_runtime_clip_quantiles": [0.05, 0.95]}, "feature_order": "producer-verified ID file required; exact ordered-ID match validated", }, } def write_manifest(args: argparse.Namespace) -> dict[str, object]: context = build_run_context() invocation_id = uuid.uuid4().hex atomic_json(OUTPUT / "invocations" / f"{invocation_id}.json", { "schema_version": 1, "invocation_id": invocation_id, "created_utc": datetime.now(timezone.utc).isoformat(), "invocation": invocation_arguments(args), "context": context, }) return context def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--methods", nargs="+", choices=METHODS, default=list(METHODS)) parser.add_argument("--seeds", nargs="+", type=int, default=[0, 1, 2]) parser.add_argument("--folds", nargs="+", type=int, choices=range(5), default=[0, 1, 2, 3, 4]) parser.add_argument("--smoke-test", action="store_true") parser.add_argument("--no-resume", action="store_true", help="Start fresh; refuses an existing run directory.") parser.add_argument("--validate-only", action="store_true", help="Validate inputs without fitting models or acquiring cells.") add_path_arguments(parser) args = parser.parse_args() configure_paths(args) prepared_inputs = load_inputs() if args.validate_only: print(json.dumps({"status": "pass", "complexes": len(prepared_inputs[0]), "algorithms": len(ALGORITHMS)})) return context = write_manifest(args) for fold in args.folds: for seed in args.seeds: for method in args.methods: run_one( method, seed, fold, smoke_test=args.smoke_test, resume=not args.no_resume, context=context, prepared_inputs=prepared_inputs, ) if __name__ == "__main__": main()