File size: 10,862 Bytes
ed9153b
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
import json, os, subprocess, sys, hashlib, random, time, gc, collections
from pathlib import Path

CFG = json.loads(Path(sys.argv[1]).read_text("utf-8"))
ROOT = Path(CFG["OUT_ROOT"]); SHARD, NSH = CFG["SHARD_ID"], CFG["N_SHARDS"]
MODE, SEED, TIER = CFG["MODE"], CFG["SEED"], CFG["TIER"]
MODEL_ID = "deepseek-ai/DeepSeek-R1-Distill-Llama-8B"
LU_SHA = "a98961956072224eaf244eb289d6c01700b63795"
N_PANEL, N_PROMPTS, RESERVE, MINWORK = 80, 5, 4.0, 20.0
os.environ["TOKENIZERS_PARALLELISM"] = "false"
os.environ["HF_HUB_ENABLE_HF_TRANSFER"] = "1"

q = subprocess.run(["nvidia-smi",
    "--query-gpu=index,name,memory.total,memory.free,utilization.gpu",
    "--format=csv,noheader,nounits"], capture_output=True, text=True, check=True).stdout
gpus = []
for line in q.strip().splitlines():
    i, n, tot, free, u = [x.strip() for x in line.split(",")]
    gpus.append({"index": int(i), "name": n, "total": int(tot)/1024,
                 "free": int(free)/1024, "util": int(u)})
print("devices: " + "  ".join(f"[{g['index']}] {g['free']:.0f}/{g['total']:.0f}G {g['util']}%"
                              for g in gpus))
d = (max(gpus, key=lambda g: g["free"]) if CFG["DEVICE_ID"] is None
     else next(g for g in gpus if g["index"] == CFG["DEVICE_ID"]))
os.environ["CUDA_VISIBLE_DEVICES"] = str(d["index"])
usable = d["free"] - RESERVE
if usable < MINWORK:
    sys.exit(f"device {d['index']}: {usable:.1f} GiB usable, need {MINWORK}")
UTIL = round(max(0.0, min(0.92, usable / d["total"])), 3)
MAXLEN = 4096 if usable >= 26 else 2560
MAX_TOK = min(CFG["MAX_TOK"], MAXLEN - 640)

import torch
cap = torch.cuda.get_device_capability(0)
DTYPE = "bfloat16" if cap[0] >= 8 else "float16"
print(f"{MODE} shard {SHARD}/{NSH} device {d['index']} | usable {usable:.1f} GiB "
      f"-> util={UTIL} maxlen={MAXLEN} max_tokens={MAX_TOK}")

vend = ROOT / "vendor" / "assistant-axis"
head = subprocess.run(["git", "-C", str(vend), "rev-parse", "HEAD"],
                      capture_output=True, text=True, check=True).stdout.strip()
assert head == LU_SHA, f"vendor at {head}, expected {LU_SHA}"
D = vend / "data"
role_list = json.loads((D/"roles"/"role_list.json").read_text("utf-8"))
questions = [json.loads(l) for l in
             (D/"extraction_questions.jsonl").read_text("utf-8").splitlines() if l.strip()]
assert len(role_list) == 275 and len(questions) == 240
QT = {x["id"]: x["question"] for x in questions}
_ro = {}
def role_obj(n):
    if n not in _ro:
        _ro[n] = json.loads((D/"roles"/"instructions"/f"{n}.json").read_text("utf-8"))
    return _ro[n]

pf = ROOT / "design" / "panel.json"
panel = json.loads(pf.read_text("utf-8")); PANEL = panel["question_ids"]
FP = hashlib.sha256(json.dumps([PANEL, panel["half_a_ids"],
                                panel["half_b_ids"]]).encode()).hexdigest()[:16]
if CFG["EXPECT_PANEL_FP"] and FP != CFG["EXPECT_PANEL_FP"]:
    sys.exit(f"PANEL MISMATCH {FP} != {CFG['EXPECT_PANEL_FP']}")
print(f"panel {FP} ok")

roles = (sorted(role_list) if TIER == "A"
         else sorted(random.Random(SEED).sample(sorted(role_list), 150)))

WRAP = ("Stay in character for your entire reply. Answer in the first person. "
        "Never mention being an AI, a language model, or an assistant.")
def build(role, pi, qid, cond):
    ins = role_obj(role)["instruction"][pi]["pos"]
    qq = QT[qid]
    if role == "default":
        # NEVER wrap the default. Lu's five default conditions are identity
        # statements ("You are an AI assistant.", "Respond as yourself.", and one
        # empty), not characters. Appending a role-adoption instruction here would
        # contradict the condition and corrupt mean(default), which is one half of
        # the Axis.
        ins = ins.replace("{model_name}", "DeepSeek-R1")
        return f"{ins}\n\n{qq}" if ins else qq
    if not ins: return qq
    return f"{ins}\n\n{qq}" if cond == "USER_TRANSLATED_LU" else f"{ins}\n\n{WRAP}\n\n{qq}"

from transformers import AutoTokenizer
tok = AutoTokenizer.from_pretrained(MODEL_ID)
def render(u):
    # add_special_tokens=False: the template emits BOS and add_bos_token is True.
    return tok.apply_chat_template([{"role": "user", "content": u}],
                                   tokenize=False, add_generation_prompt=True)

def uid(*p): return hashlib.sha256("|".join(map(str, p)).encode()).hexdigest()[:16]
conds = (["USER_TRANSLATED_LU", "USER_EXPLICIT"]
         if CFG["CONDITION"] == "BOTH" else [CFG["CONDITION"]])
if MODE == "DEFAULT" and len(conds) > 1:
    # The wrapper never applies to default, so both conditions render IDENTICAL
    # prompts. uid includes the condition, so running both would silently
    # double-weight the default vector. Collapse to one.
    conds = conds[:1]
    print("DEFAULT: conditions render identically here; using one to avoid "
          "double-weighting mean(default)")

units = []
if MODE == "EXTRACTION":
    for r in roles:
        for i, qid in enumerate(PANEL):
            if i % NSH != SHARD: continue           # split by QUESTION index
            for c in conds:
                units.append((uid(r, i % N_PROMPTS, qid, c), r, i % N_PROMPTS, qid, c))
elif MODE == "DEFAULT":
    for pi in range(N_PROMPTS):                     # 5 default conditions
        for i, qid in enumerate(PANEL):             # x 80 questions = 400
            if i % NSH != SHARD: continue
            for c in conds:
                units.append((uid("default", pi, qid, c), "default", pi, qid, c))
else:
    sys.exit(f"queue handles EXTRACTION/DEFAULT, not {MODE}")

pc = collections.Counter(u[2] for u in units)
print(f"{len(units)} units | {len({u[1] for u in units})} roles | "
      f"prompt balance {dict(sorted(pc.items()))}")

od = ROOT / MODE.lower(); od.mkdir(parents=True, exist_ok=True)
sf = od / f"rollouts_shard{SHARD}.jsonl"
done = set()
if sf.exists():
    for line in sf.read_text("utf-8").splitlines():
        try: done.add(json.loads(line)["uid"])
        except Exception: pass
todo = [u for u in units if u[0] not in done]
print(f"resume: {len(done)} done, {len(todo)} to go")
if todo:
    print(f"  ~{len(todo)/7000:.2f}-{len(todo)/5500:.2f} h at 5,500-7,000/h")

if todo:
    from vllm import LLM, SamplingParams
    llm = LLM(model=MODEL_ID, dtype=DTYPE, gpu_memory_utilization=UTIL,
              max_model_len=MAXLEN, seed=SEED)
    sp = SamplingParams(temperature=CFG["TEMP"], top_p=CFG["TOP_P"],
                        max_tokens=MAX_TOK, seed=SEED)
    t0 = time.time()
    for s in range(0, len(todo), CFG["CKPT_EVERY"]):
        chunk = todo[s:s+CFG["CKPT_EVERY"]]
        prompts = [render(build(r, pi, qid, c)) for _, r, pi, qid, c in chunk]
        outs = llm.generate(prompts, sp)
        nc = nt = 0
        with sf.open("a", encoding="utf-8") as fh:
            for (u, r, pi, qid, c), rp, o in zip(chunk, prompts, outs):
                t = o.outputs[0].text
                nc += "</think>" in t; nt += o.outputs[0].finish_reason == "length"
                fh.write(json.dumps({
                    "uid": u, "shard": SHARD, "role": r, "prompt_idx": pi,
                    "question_id": qid, "condition": c, "rendered_prompt": rp,
                    "completion": t, "n_out_tokens": len(o.outputs[0].token_ids),
                    "finish_reason": o.outputs[0].finish_reason,
                    "closed_think": "</think>" in t,
                    "gen_max_tokens": MAX_TOK, "gen_temperature": CFG["TEMP"],
                    "gen_top_p": CFG["TOP_P"], "gen_seed": SEED,
                }, ensure_ascii=False) + "\n")
        n, el = min(s+len(chunk), len(todo)), time.time()-t0
        print(f"  {n}/{len(todo)}  {n/max(el,1)*3600:.0f}/h  "
              f"eta {(len(todo)-n)/max(n,1)*el/3600:.2f}h  "
              f"[closed {nc/len(chunk):.1%} trunc {nt/len(chunk):.1%}]", flush=True)
        if CFG["HF_PUSH"]:
            try:
                from huggingface_hub import HfApi
                HfApi().upload_file(path_or_fileobj=str(sf), repo_id=CFG["HF_REPO"],
                    repo_type="dataset",
                    path_in_repo=f"{CFG['RUN_ID']}/{MODE.lower()}/{sf.name}")
            except Exception as e:
                print(f"    (checkpoint push failed: {type(e).__name__}; disk ok)")
    del llm; gc.collect(); torch.cuda.empty_cache()

rows = [json.loads(l) for l in sf.read_text("utf-8").splitlines() if l.strip()]
N = max(len(rows), 1)
cfgs = collections.Counter((r.get("gen_max_tokens"), r.get("gen_temperature")) for r in rows)
per_role = collections.Counter(r["role"] for r in rows)
rep = {"mode": MODE, "shard": SHARD, "n_shards": NSH, "tier": TIER,
       "condition": CFG["CONDITION"], "conditions_used": conds,
       "n_outputs": len(rows), "n_expected": len(units),
       "complete": len(rows) >= len(units), "panel_fingerprint": FP,
       "lu_commit": LU_SHA, "model": MODEL_ID, "device_index": d["index"],
       "dtype": DTYPE, "max_model_len": MAXLEN, "gpu_memory_utilization": UTIL,
       "generation_configs_in_data": {str(k): v for k, v in cfgs.items()},
       "config_homogeneous": len(cfgs) == 1,
       "closed_think_rate": round(sum(r["closed_think"] for r in rows)/N, 4),
       "truncated_rate": round(sum(r["finish_reason"] == "length" for r in rows)/N, 4),
       "mean_out_tokens": round(sum(r["n_out_tokens"] for r in rows)/N, 1),
       "roles_present": len(per_role),
       "min_outputs_per_role": min(per_role.values()) if per_role else 0,
       "default_wrapper_applied": False if MODE == "DEFAULT" else None}
rf = od / f"run_report_shard{SHARD}.json"
rf.write_text(json.dumps(rep, indent=2), "utf-8")
print("\n" + json.dumps(rep, indent=2))

if CFG["HF_PUSH"]:
    try:
        from huggingface_hub import HfApi
        api = HfApi(); R, base = CFG["HF_REPO"], CFG["RUN_ID"]
        for local, dest in ((sf, f"{MODE.lower()}/{sf.name}"),
                            (rf, f"{MODE.lower()}/{rf.name}"),
                            (pf, "design/panel.json")):
            api.upload_file(path_or_fileobj=str(local), path_in_repo=f"{base}/{dest}",
                            repo_id=R, repo_type="dataset")
            print(f"  pushed {dest}")
        api.upload_file(path_or_fileobj=Path(sys.argv[0]).read_text("utf-8").encode(),
                        path_in_repo=f"{base}/code/worker_{MODE.lower()}_shard{SHARD}.py",
                        repo_id=R, repo_type="dataset")
        api.upload_file(path_or_fileobj=json.dumps(CFG, indent=2).encode(),
                        path_in_repo=f"{base}/code/config_{MODE.lower()}_shard{SHARD}.json",
                        repo_id=R, repo_type="dataset")
        print("  pushed code + config")
    except Exception as e:
        print(f"WARNING HF push failed: {type(e).__name__}: {e}")
        print(f"Outputs safe on disk at {sf}")

print(f"JOBDONE {MODE} shard {SHARD}: {rep['n_outputs']}/{rep['n_expected']} "
      f"complete={rep['complete']}")