| """ |
| Dyadic (2-model) combinatorial sweep for the divsim paper. |
| |
| Enumerates all ordered pairs from the 5 paper models, crossed with 5 persona seeds, |
| for a total of C(5,2)×2×5 = 100 configurations. Each configuration launches one |
| run of the OASIS simulator in hetero mode. |
| |
| 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_dyadic.py --dry-run # print all configs, no launch |
| python sweep_dyadic.py --mode 2model # all 2-model runs (default) |
| python sweep_dyadic.py --max-parallel 2 # limit concurrent runs |
| python sweep_dyadic.py --skip-existing # skip runs whose DB already exists |
| """ |
|
|
| 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"), |
| } |
|
|
| MODEL_KEYS = list(MODELS.keys()) |
| SEEDS = [42, 137, 271, 314, 999] |
| STEPS = 100 |
| N_AGENTS = 20 |
|
|
|
|
| def run_id(a: str, b: str, seed: int) -> str: |
| return f"sweep_{a[:3]}_{b[:3]}_s{seed}" |
|
|
|
|
| def db_is_valid(db: Path) -> bool: |
| """Return True if the DB has enough data to be considered a complete 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] |
| nc = conn.execute("SELECT COUNT(*) FROM comment").fetchone()[0] |
| conn.close() |
| return nu >= 18 and nc >= 200 |
| except Exception: |
| return False |
|
|
|
|
| def launch(a: str, b: str, seed: int, dry_run: bool) -> dict: |
| rid = run_id(a, b, seed) |
| db = RUNS_DIR / f"{rid}.db" |
| log = LOGS_DIR / f"{rid}.log" |
| ma, mb = MODELS[a], MODELS[b] |
|
|
| env = { |
| **os.environ, |
| "VLLM_URL_A": ma[1], "MODEL_NAME_A": ma[0], |
| "VLLM_URL_B": mb[1], "MODEL_NAME_B": mb[0], |
| "OASIS_DB_PATH": str(db), |
| } |
| cmd = [ |
| f"{VENV}/bin/python3", str(RUNNER), |
| "--mode", "hetero", |
| "--steps", str(STEPS), |
| "--agents", str(N_AGENTS), |
| "--seed-posts", str(N_AGENTS), |
| "--activate-prob", "0.3", |
| "--rng-seed", str(seed), |
| "--db", str(db), |
| ] |
|
|
| if dry_run: |
| print(f" [DRY] {rid} A={a}({ma[0]}) B={b}({mb[0]}) seed={seed}") |
| return {"rid": rid, "proc": None} |
|
|
| LOGS_DIR.mkdir(parents=True, exist_ok=True) |
| RUNS_DIR.mkdir(parents=True, exist_ok=True) |
| with open(log, "w") as lf: |
| proc = subprocess.Popen(cmd, env=env, stdout=lf, stderr=lf) |
| print(f" [{rid}] PID={proc.pid} A={a} B={b} seed={seed}") |
| return {"rid": rid, "proc": proc} |
|
|
|
|
| def all_configs(): |
| configs = [] |
| for pair in itertools.combinations(MODEL_KEYS, 2): |
| for perm in itertools.permutations(pair): |
| for seed in SEEDS: |
| configs.append((perm[0], perm[1], seed)) |
| return configs |
|
|
|
|
| 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("--skip-existing", action="store_true", default=True, |
| help="Skip runs whose DB already exists and is valid.") |
| args = parser.parse_args() |
|
|
| configs = all_configs() |
| print(f"Dyadic sweep: {len(configs)} configs " |
| f"(C(5,2)×2 ordered pairs × {len(SEEDS)} seeds)") |
| print(f"Seeds: {SEEDS} max_parallel: {args.max_parallel} " |
| f"dry_run: {args.dry_run}") |
|
|
| active = [] |
| for a, b, seed in configs: |
| active = [r for r in active if r["proc"] and r["proc"].poll() is None] |
| while len(active) >= args.max_parallel: |
| time.sleep(10) |
| active = [r for r in active if r["proc"] and r["proc"].poll() is None] |
|
|
| if args.skip_existing: |
| db = RUNS_DIR / f"{run_id(a, b, seed)}.db" |
| if db_is_valid(db): |
| print(f" [skip] {run_id(a, b, seed)} (valid DB exists)") |
| continue |
|
|
| r = launch(a, b, seed, args.dry_run) |
| if r["proc"]: |
| active.append(r) |
| time.sleep(2) |
|
|
| for r in active: |
| if r["proc"]: |
| r["proc"].wait() |
| print("All dyadic configs done.") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
