| """ |
| Triadic (3-model) sweep for the divsim paper, with preemption support. |
| |
| Enumerates all C(5,3)=10 model triplets, samples 3 of the 6 possible orderings |
| per triplet (the 3 with maximum positional diversity), crossed with 3 seeds. |
| Total: 10 triplets × 3 orderings × 3 seeds = 90 configurations. |
| |
| Preemption support: run_v9.py catches SIGTERM and exits cleanly after the |
| current step commit. This script checks for partial DBs and resumes them via |
| --resume rather than restarting from scratch. |
| |
| Configuration is read from environment variables: |
| RUNS_DIR — output directory for .db files (required) |
| VENV_PATH — path to the Python venv with oasis installed |
| OASIS_RUNNER — path to run_v9.py (defaults to <this_dir>/../oasis/run_v9.py) |
| LOGS_DIR — directory for per-run log files |
| |
| Usage: |
| python sweep_triadic.py --dry-run # print all configs, no launch |
| python sweep_triadic.py --max-parallel 2 # limit concurrent runs |
| python sweep_triadic.py --triplets qwen,oss,mag # run a specific triplet only |
| """ |
|
|
| import argparse |
| import itertools |
| import os |
| import subprocess |
| import time |
| from pathlib import Path |
|
|
|
|
| RUNS_DIR = Path(os.environ.get("RUNS_DIR", "./runs")) |
| VENV = os.environ.get("VENV_PATH", str(Path(__file__).parent.parent / ".venv")) |
| RUNNER = Path(os.environ.get("OASIS_RUNNER", |
| str(Path(__file__).parent.parent / "oasis" / "run_v9.py"))) |
| LOGS_DIR = Path(os.environ.get("LOGS_DIR", "./logs/sweep")) |
|
|
| MODELS = { |
| "qwen": ("Qwen/Qwen3-32B", "http://localhost:8002/v1"), |
| "oss": ("openai/gpt-oss-20b", "http://localhost:8003/v1"), |
| "mag": ("mistralai/Magistral-Small-2509", "http://localhost:8004/v1"), |
| "glm": ("zai-org/GLM-4-32B-0414", "http://localhost:8007/v1"), |
| "gem": ("google/gemma-4-31B-it", "http://localhost:8009/v1"), |
| } |
|
|
| SEEDS = [42, 271, 999] |
| STEPS = 100 |
| N_AGENTS = 30 |
|
|
|
|
| def sampled_orderings(triplet: tuple) -> list: |
| """Return 3 of the 6 possible permutations, evenly spaced for positional diversity.""" |
| perms = list(itertools.permutations(triplet)) |
| return [perms[0], perms[2], perms[4]] |
|
|
|
|
| def run_id(perm: tuple, seed: int) -> str: |
| return f"sweep_tri_{'_'.join(m[:3] for m in perm)}_s{seed}" |
|
|
|
|
| def db_is_valid(db: Path) -> bool: |
| """Return True if the DB has enough active agents to be a complete triadic run.""" |
| if not db.exists(): |
| return False |
| try: |
| import sqlite3 |
| conn = sqlite3.connect(db) |
| nu = conn.execute("SELECT COUNT(DISTINCT user_id) FROM comment").fetchone()[0] |
| conn.close() |
| return nu >= 26 |
| except Exception: |
| return False |
|
|
|
|
| def launch(perm: tuple, seed: int, dry_run: bool) -> dict | None: |
| rid = run_id(perm, seed) |
| db = RUNS_DIR / f"{rid}.db" |
| log = LOGS_DIR / f"{rid}.log" |
|
|
| if db_is_valid(db): |
| print(f" [skip] {rid} (valid DB exists)") |
| return None |
|
|
| resume = db.exists() and db.stat().st_size > 50_000 |
|
|
| ma, mb, mc = MODELS[perm[0]], MODELS[perm[1]], MODELS[perm[2]] |
| env = { |
| **os.environ, |
| "VLLM_URL_A": ma[1], "MODEL_NAME_A": ma[0], |
| "VLLM_URL_B": mb[1], "MODEL_NAME_B": mb[0], |
| "VLLM_URL_C": mc[1], "MODEL_NAME_C": mc[0], |
| "OASIS_DB_PATH": str(db), |
| } |
| cmd = [ |
| f"{VENV}/bin/python3", str(RUNNER), |
| "--mode", "hetero3", |
| "--steps", str(STEPS), |
| "--agents", str(N_AGENTS), |
| "--seed-posts", str(N_AGENTS), |
| "--activate-prob", "0.3", |
| "--rng-seed", str(seed), |
| "--db", str(db), |
| ] |
| if resume: |
| cmd.append("--resume") |
|
|
| status = "[resume]" if resume else "[run] " |
| print(f" {status} {rid}") |
|
|
| if dry_run: |
| print(f" A={perm[0]} B={perm[1]} C={perm[2]} seed={seed}") |
| return None |
|
|
| LOGS_DIR.mkdir(parents=True, exist_ok=True) |
| RUNS_DIR.mkdir(parents=True, exist_ok=True) |
| with open(log, "a") as lf: |
| proc = subprocess.Popen(cmd, env=env, stdout=lf, stderr=lf) |
| return {"rid": rid, "proc": proc} |
|
|
|
|
| def all_triplets(): |
| return list(itertools.combinations(MODELS.keys(), 3)) |
|
|
|
|
| def main(): |
| parser = argparse.ArgumentParser(description=__doc__) |
| parser.add_argument("--dry-run", action="store_true", |
| help="Print configs without launching.") |
| parser.add_argument("--max-parallel", type=int, default=2, |
| help="Maximum concurrent runs.") |
| parser.add_argument("--triplets", nargs="*", |
| help="Restrict to specific triplets, e.g. qwen,oss,mag") |
| args = parser.parse_args() |
|
|
| triplets = all_triplets() |
| if args.triplets: |
| triplets = [tuple(t.split(",")) for t in args.triplets] |
|
|
| configs = [ |
| (perm, seed) |
| for triplet in triplets |
| for perm in sampled_orderings(triplet) |
| for seed in SEEDS |
| ] |
|
|
| print(f"Triadic sweep: {len(triplets)} triplets × 3 orderings × " |
| f"{len(SEEDS)} seeds = {len(configs)} configs") |
| print(f"Triplets: {['+'.join(t) for t in triplets]}") |
| print() |
|
|
| active = [] |
| for perm, seed in configs: |
| active = [r for r in active if r["proc"].poll() is None] |
| while len(active) >= args.max_parallel: |
| time.sleep(15) |
| active = [r for r in active if r["proc"].poll() is None] |
|
|
| r = launch(perm, seed, args.dry_run) |
| if r: |
| active.append(r) |
| if not args.dry_run: |
| time.sleep(2) |
|
|
| for r in active: |
| r["proc"].wait() |
| print("All triadic configs done.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
