Datasets:
Download code/src_seqroute/client.py from divy123/sequential-router-v2: direct link, hf CLI and curl.
- Browser
- Download file 6.14 kB
-
https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/src_seqroute/client.py
- Command line
-
hf download hf://datasets/divy123/sequential-router-v2/code/src_seqroute/client.py
-
curl -L -o client.py https://huggingface.co/datasets/divy123/sequential-router-v2/resolve/main/code/src_seqroute/client.py
6.14 kB
| """Resumable, checkpointed async generation against N local vLLM replicas. A job is {id, prompt, max_tokens, seed}; finished jobs are appended to the jsonl | |
| as they complete and skipped on resume. Logprob statistics are computed here (no per-token arrays are stored).""" | |
| from __future__ import annotations | |
| import asyncio | |
| import json | |
| import math | |
| import random | |
| import re | |
| import time | |
| from pathlib import Path | |
| import httpx | |
| import numpy as np | |
| def read_ids(path: Path) -> set[str]: | |
| ids = set() | |
| if path.exists(): | |
| with open(path) as f: | |
| for line in f: | |
| try: | |
| ids.add(json.loads(line)["id"]) | |
| except Exception: | |
| pass | |
| return ids | |
| def lp_stats(choice: dict) -> dict: | |
| lp = ((choice.get("logprobs") or {}).get("content")) or [] | |
| v = np.array([t["logprob"] for t in lp if t.get("logprob") is not None], float) | |
| if v.size == 0: | |
| return {} | |
| out = dict(mean_lp=float(v.mean()), median_lp=float(np.median(v)), p05_lp=float(np.percentile(v, 5)), p25_lp=float(np.percentile(v, 25)), min_lp=float(v.min()), | |
| mean_lp_tail64=float(v[-64:].mean()), frac_lp_lt_2=float((v < -2).mean()), n_lp=int(v.size)) | |
| tops = [t.get("top_logprobs") for t in lp] | |
| if tops and tops[0]: | |
| ent = np.array([-sum(math.exp(c["logprob"]) * c["logprob"] for c in (t or [])) for t in tops]) | |
| out.update(mean_entropy_top5=float(ent.mean()), median_entropy_top5=float(np.median(ent)), p90_entropy_top5=float(np.percentile(ent, 90)), max_entropy_top5=float(ent.max())) | |
| return out | |
| async def _one(client, base, model, job, p): | |
| msgs = ([{"role": "system", "content": p["system"]}] if p.get("system") else []) + [{"role": "user", "content": job["prompt"]}] | |
| body = {"model": model, "messages": msgs, "max_tokens": int(job["max_tokens"]), "temperature": p.get("temperature", 0.0), | |
| "top_p": p.get("top_p", 1.0), "seed": int(job.get("seed", 0))} | |
| if p.get("logprobs", True): | |
| body.update(logprobs=True, top_logprobs=5) | |
| if p.get("chat_template_kwargs"): | |
| body["chat_template_kwargs"] = p["chat_template_kwargs"] | |
| for k in ("top_k", "repetition_penalty", "min_p"): | |
| if p.get(k) is not None: | |
| body[k] = p[k] | |
| t0 = time.time() | |
| r = await client.post(f"{base}/v1/chat/completions", json=body) | |
| lat = time.time() - t0 | |
| if r.status_code >= 400: | |
| raise RuntimeError(f"HTTP {r.status_code}: {r.text[:300]}") | |
| d = r.json() | |
| ch = d["choices"][0] | |
| msg = ch["message"] | |
| u = d["usage"] | |
| return {"id": job["id"], "budget": int(job["max_tokens"]), "text": msg.get("content") or "", "reasoning": msg.get("reasoning") or msg.get("reasoning_content"), "finish_reason": ch["finish_reason"], | |
| "prompt_tokens": u["prompt_tokens"], "completion_tokens": u["completion_tokens"], "latency_s": lat, "t_end": time.time(), "port": base.rsplit(":", 1)[1], **lp_stats(ch)} | |
| async def _run(jobs, out, model, ports, params, per_server, every, stats): | |
| q: asyncio.Queue = asyncio.Queue() | |
| for j in jobs: | |
| q.put_nowait(j) | |
| t0 = time.time() | |
| fout, ferr = open(out, "a"), open(str(out) + ".errors", "a") | |
| async def worker(port, client): | |
| base = f"http://127.0.0.1:{port}" | |
| while True: | |
| try: | |
| job = q.get_nowait() | |
| except asyncio.QueueEmpty: | |
| return | |
| res, err = None, None | |
| for attempt in range(8): | |
| try: | |
| res = await _one(client, base, model, job, params) | |
| break | |
| except Exception as e: | |
| err = repr(e)[:300] | |
| if "maximum context length" in str(e): # vLLM's "at least N input tokens" is just ctx - requested + 1, so shrink geometrically | |
| job = dict(job, max_tokens=max(int(job["max_tokens"] * 0.75), 64)) | |
| stats["ctx_shrunk"] = stats.get("ctx_shrunk", 0) + 1 | |
| continue | |
| if attempt >= 2: | |
| break | |
| await asyncio.sleep(2 * (attempt + 1)) | |
| if res is None: | |
| stats["failed"] += 1 | |
| ferr.write(json.dumps({"id": job["id"], "err": err, "port": port}) + "\n") | |
| ferr.flush() | |
| continue | |
| fout.write(json.dumps(res, ensure_ascii=False) + "\n") | |
| fout.flush() | |
| stats["done"] += 1 | |
| stats["completion_tokens"] += res["completion_tokens"] | |
| stats["prompt_tokens"] += res["prompt_tokens"] | |
| if stats["done"] % every == 0: | |
| el = time.time() - t0 | |
| print(f"[{model}] {stats['done']}/{len(jobs)} failed={stats['failed']} {stats['completion_tokens'] / el:.0f} gen tok/s elapsed={el:.0f}s", flush=True) | |
| limits = httpx.Limits(max_connections=per_server * len(ports) + 8) | |
| async with httpx.AsyncClient(timeout=httpx.Timeout(7200.0), limits=limits) as client: | |
| await asyncio.gather(*[worker(p, client) for p in ports for _ in range(per_server)]) | |
| fout.close() | |
| ferr.close() | |
| stats["wall_s"] = time.time() - t0 | |
| def run_jobs(jobs: list[dict], out: Path, model: str, ports: list[int], params: dict, per_server: int = 128, every: int = 1000, stats: dict | None = None) -> dict: | |
| out = Path(out) | |
| out.parent.mkdir(parents=True, exist_ok=True) | |
| done = read_ids(out) | |
| todo = [j for j in jobs if j["id"] not in done] | |
| random.Random(0).shuffle(todo) | |
| todo.sort(key=lambda j: -j.get("max_tokens", 0)) # longest budgets first (random within a budget class) so long reasoning traces do not form a tail | |
| stats = stats if stats is not None else {} | |
| stats.update({"done": 0, "failed": 0, "prompt_tokens": 0, "completion_tokens": 0, "wall_s": 0.0, "n_todo": len(todo), "n_cached": len(jobs) - len(todo), "t_start": time.time()}) | |
| print(f"[{model}] {len(jobs)} jobs, {stats['n_cached']} cached, {len(todo)} to run", flush=True) | |
| if todo: | |
| asyncio.run(_run(todo, out, model, ports, params, per_server, every, stats)) | |
| return stats | |