File size: 3,771 Bytes
8ad880b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
"""Second-chance pass for reasoning models whose answer was cut off by the per-family token cap (finish_reason == 'length').
The capped records are archived to responses_truncated/<model>.jsonl and removed from the main response file; the same queries are then re-generated
with a 14,336-token budget (shrunk automatically when prompt + budget would exceed the 16,384 context).  This is equivalent to having used the larger
budget from the start (same seeds), so the final dataset carries ONE response per (query, model); archived records document the capped attempt.
Run only when no other generation is running.  Usage: python extend_truncated.py [--models a,b]
"""
import argparse, hashlib, json, sys, 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 run_jobs, read_ids

ROOT = Path("/mnt/localssd/seqroute1m")
EXT_BUDGET = 14336
# 14k-token sequences exhaust the KV cache of data-parallel replicas of the larger models (preemption thrash): use TP2 and cap concurrency there
EXT_TP = {"magistral_small_24b": 2, "r1_distill_qwen_14b": 2}
EXT_SEQS = {1: 40, 2: 64}
ap = argparse.ArgumentParser(); ap.add_argument("--models", default=""); a = ap.parse_args()
specs = [m for m in json.load(open(ROOT / "manifests/models.json")) if m["reasoning"]]
if a.models: specs = [m for m in specs if m["id"] in a.models.split(",")]
q = pd.read_parquet(ROOT / "queries/queries_20k.parquet", columns=["query_id", "prompt"]).set_index("query_id").prompt
(ROOT / "responses_truncated").mkdir(exist_ok=True)
for spec in specs:
    mid = spec["id"]; f = ROOT / "responses" / f"{mid}.jsonl"
    arch = ROOT / "responses_truncated" / f"{mid}.jsonl"
    keep, cut = [], []
    for l in open(f):
        r = json.loads(l)
        (cut if r["finish_reason"] == "length" and r["id"] in q.index and r.get("budget", 0) < EXT_BUDGET else keep).append(l)
    done_arch = read_ids(arch)
    with open(arch, "a") as g:
        for l in cut:
            if json.loads(l)["id"] not in done_arch: g.write(l)
    if cut:
        tmp = f.with_suffix(".tmp"); tmp.write_text("".join(keep)); tmp.replace(f)
    ids = [json.loads(l)["id"] for l in open(arch)]
    have_ids = read_ids(f)
    todo_ids = [i for i in dict.fromkeys(ids) if i not in have_ids]
    print(f"{mid}: {len(cut)} newly archived, {len(todo_ids)} to regenerate at budget {EXT_BUDGET}", flush=True)
    if not todo_ids: continue
    jobs = [dict(id=i, prompt=q[i], max_tokens=EXT_BUDGET, seed=int(hashlib.sha1(f"{i}|{mid}".encode()).hexdigest()[:8], 16) % (2 ** 31)) for i in todo_ids]
    sspec = dict(spec, tp=EXT_TP.get(mid, spec["tp"]))
    t0 = time.time(); S.stop_servers(); ports = S.start_servers(sspec, max_num_seqs=EXT_SEQS[sspec["tp"]]); S.wait_ready(ports); t1 = time.time()
    params = dict(temperature=spec["temperature"], top_p=spec["top_p"], chat_template_kwargs=spec["chat_template_kwargs"], system=spec.get("system"))
    st = {}
    for att in range(3):
        run_jobs(jobs, f, mid, ports, params, per_server=EXT_SEQS[sspec["tp"]] * 2, every=1000, stats=st)
        have = read_ids(f); jobs = [j for j in jobs if j["id"] not in have]
        if not jobs: break
        Path(str(f) + ".errors").rename(str(f) + f".ext_round{att}")
    wall = time.time() - t1; S.stop_servers()
    json.dump(dict(model=mid, wave="ext", n_generated=len(todo_ids), n_failed_final=len(jobs), gen_wall_s=wall, startup_s=t1 - t0, n_gpus=8, gpu_seconds=wall * 8,
                   completion_tokens=st.get("completion_tokens", 0), prompt_tokens=st.get("prompt_tokens", 0), ctx_shrunk=st.get("ctx_shrunk", 0), ts=time.strftime("%F %T")),
              open(ROOT / "responses" / f"{mid}.ext.stats.json", "w"), indent=1)
print("ext done")