Datasets:
Download code/scripts_seqroute/generate.py from divy123/sequential-router-v2: direct link, hf CLI and curl.
- Browser
- Download file 7.05 kB
-
https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/scripts_seqroute/generate.py
- Command line
-
hf download hf://datasets/divy123/sequential-router-v2/code/scripts_seqroute/generate.py
-
curl -L -o generate.py https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/scripts_seqroute/generate.py
7.05 kB
| """Generation orchestrator: for each model (one at a time, all 8 GPUs), answer every query of a wave independently; resumable, checkpointed, bounded retries. | |
| Usage: python generate.py --wave smoke|w1|w2|w3 [--models id,id,...] [--queries queries_20k.parquet] | |
| Outputs /mnt/localssd/seqroute1m/responses/<model>.jsonl (append-only, one file per model across waves), responses/<model>.<wave>.stats.json, progress.json | |
| """ | |
| import argparse | |
| import json | |
| import shutil | |
| import subprocess | |
| import sys | |
| import threading | |
| import time | |
| from pathlib import Path | |
| import pandas as pd | |
| sys.path.insert(0, "src") | |
| from llmroute.seqroute import serve as S | |
| from llmroute.seqroute.client import read_ids, run_jobs | |
| ROOT = Path("/mnt/localssd/seqroute1m") | |
| RESP = ROOT / "responses" | |
| PROG = ROOT / "progress.json" | |
| def gpu_status(): | |
| try: | |
| o = subprocess.run(["nvidia-smi", "--query-gpu=utilization.gpu,memory.used", "--format=csv,noheader,nounits"], capture_output=True, text=True, timeout=10).stdout | |
| rows = [tuple(int(x) for x in l.split(",")) for l in o.strip().splitlines()] | |
| return dict(util_mean=sum(r[0] for r in rows) / len(rows), mem_used_gb_mean=sum(r[1] for r in rows) / len(rows) / 1024, n=len(rows)) | |
| except Exception as e: | |
| return dict(error=str(e)) | |
| def make_waves(q: pd.DataFrame): | |
| import hashlib | |
| M = ROOT / "manifests" | |
| q = q.copy() | |
| q["_r"] = 0.0 | |
| for _, g in q.groupby(["task_family", "source_dataset"]): | |
| idx = sorted(g.index, key=lambda i: hashlib.sha1(f"wave|{q.at[i, 'query_id']}".encode()).hexdigest()) | |
| for rank, i in enumerate(idx): | |
| q.at[i, "_r"] = (rank + 0.5) / len(idx) | |
| q = q.sort_values(["_r", "query_id"]).reset_index(drop=True) | |
| ids = list(q.query_id) | |
| sm = [] | |
| for fam, g in q.groupby("task_family"): | |
| sm += list(g.query_id[:5]) | |
| sset = set(sm) | |
| w1 = sm + [i for i in ids if i not in sset][:4000 - len(sm)] | |
| w1s = set(w1) | |
| rest = [i for i in ids if i not in w1s] | |
| waves = {"smoke": sm, "w1": w1, "w2": rest[:8000], "w3": rest[8000:]} | |
| for k, v in waves.items(): | |
| json.dump(v, open(M / f"wave_{k}.json", "w")) | |
| print(k, len(v)) | |
| def main(): | |
| ap = argparse.ArgumentParser() | |
| ap.add_argument("--wave", required=True) | |
| ap.add_argument("--models", default="") | |
| ap.add_argument("--queries", default=str(ROOT / "queries/queries_20k.parquet")) | |
| ap.add_argument("--make-waves", action="store_true") | |
| ap.add_argument("--max-num-seqs", type=int, default=256) | |
| a = ap.parse_args() | |
| q = pd.read_parquet(a.queries) | |
| if a.make_waves: | |
| make_waves(q) | |
| return | |
| wave_ids = json.load(open(ROOT / "manifests" / f"wave_{a.wave}.json")) | |
| qw = q.set_index("query_id").loc[wave_ids] | |
| specs = json.load(open(ROOT / "manifests/models.json")) | |
| if a.models: | |
| want = a.models.split(",") | |
| specs = [s for s in specs if s["id"] in want] | |
| RESP.mkdir(exist_ok=True) | |
| state = dict(wave=a.wave, n_queries=len(wave_ids), models_total=len(specs), models_done=0, current=None, per_model={}, started=time.time()) | |
| done_sec, done_resp = 0.0, 0 | |
| stats: dict = {} | |
| stop = threading.Event() | |
| def reporter(): | |
| while not stop.is_set(): | |
| cur = state["current"] | |
| n_left_models = state["models_total"] - state["models_done"] | |
| rate = (done_sec / done_resp) if done_resp else None | |
| eta_h = None | |
| if rate: | |
| remaining = n_left_models * len(wave_ids) - (stats.get("done", 0) + stats.get("n_cached", 0) if cur else 0) | |
| eta_h = max(remaining, 0) * rate / 3600 | |
| du = shutil.disk_usage("/mnt/localssd") | |
| PROG.write_text(json.dumps(dict(state, ts=time.strftime("%F %T"), elapsed_h=(time.time() - state["started"]) / 3600, current_stats={k: v for k, v in stats.items() if k != "t_start"}, | |
| current_tok_per_s=(stats.get("completion_tokens", 0) / max(time.time() - stats.get("t_start", time.time()), 1)) if stats else None, | |
| gpu=gpu_status(), disk_free_tb=du.free / 1e12, sec_per_response_8gpu=rate, eta_wave_hours=eta_h), indent=1, default=str)) | |
| stop.wait(30) | |
| th = threading.Thread(target=reporter, daemon=True) | |
| th.start() | |
| for spec in specs: | |
| mid = spec["id"] | |
| out = RESP / f"{mid}.jsonl" | |
| have = read_ids(out) | |
| jobs = [dict(id=qid, prompt=r.prompt, max_tokens=int(r.max_tokens_reasoning if spec["reasoning"] else r.max_tokens_nonreasoning), seed=int(abs(hash((qid, mid))) % (2 ** 31))) | |
| for qid, r in qw.iterrows()] | |
| jobs = [j for j in jobs if j["id"] not in have] | |
| for j in jobs: # deterministic seed independent of PYTHONHASHSEED | |
| import hashlib | |
| j["seed"] = int(hashlib.sha1(f"{j['id']}|{mid}".encode()).hexdigest()[:8], 16) % (2 ** 31) | |
| state["current"] = mid | |
| if not jobs: | |
| state["models_done"] += 1 | |
| state["per_model"][mid] = "cached" | |
| continue | |
| print(f"=== {mid}: {len(jobs)} to generate", flush=True) | |
| t0 = time.time() | |
| S.stop_servers() | |
| ports = S.start_servers(spec, max_num_seqs=a.max_num_seqs) | |
| S.wait_ready(ports) | |
| t_ready = time.time() | |
| params = dict(temperature=spec["temperature"], top_p=spec["top_p"], chat_template_kwargs=spec["chat_template_kwargs"], system=spec.get("system")) | |
| stats.clear() | |
| for attempt in range(3): # bounded retries of failed requests (client already retries each request 3x) | |
| run_jobs(jobs, out, mid, ports, params, per_server=a.max_num_seqs, every=2000, stats=stats) | |
| ef = Path(str(out) + ".errors") | |
| have = read_ids(out) | |
| jobs = [j for j in jobs if j["id"] not in have] | |
| if not jobs: | |
| break | |
| print(f"[{mid}] {len(jobs)} failed, retry round {attempt + 1}", flush=True) | |
| if ef.exists(): | |
| ef.rename(str(ef) + f".round{attempt}") | |
| wall = time.time() - t_ready | |
| S.stop_servers() | |
| n = stats["n_todo"] | |
| sj = dict(model=mid, wave=a.wave, n_generated=n, n_failed_final=len(jobs), gen_wall_s=wall, startup_s=t_ready - t0, n_gpus=8, gpu_seconds=wall * 8, completion_tokens=stats["completion_tokens"], | |
| prompt_tokens=stats["prompt_tokens"], ctx_shrunk=stats.get("ctx_shrunk", 0), ts=time.strftime("%F %T")) | |
| json.dump(sj, open(RESP / f"{mid}.{a.wave}.stats.json", "w"), indent=1) | |
| done_sec += wall + (t_ready - t0) | |
| done_resp += n | |
| state["models_done"] += 1 | |
| state["per_model"][mid] = dict(n=n, failed=len(jobs), wall_s=round(wall), tok_per_s=round(stats["completion_tokens"] / max(wall, 1))) | |
| state["current"] = None | |
| stop.set() | |
| time.sleep(1) | |
| PROG.write_text(json.dumps(dict(state, ts=time.strftime("%F %T"), finished=True), indent=1, default=str)) | |
| print("wave done", a.wave) | |
| if __name__ == "__main__": | |
| main() | |