| """Step-format check on real samples: does a backbone follow the step protocol, and does |
| tdprm.data.segment recover its steps exactly at the token level? |
| |
| Uses the training prompts, chat template (CHAT_KWARGS) and sampling (T=1.0, no top-p/top-k, the |
| generated ids including the stop token, as vLLM returns them to TRL), and greedy decoding on the |
| evaluation set. Runs on Apple Silicon with MLX (no vLLM needed) or on the training node with vLLM. |
| |
| python -m tdprm.sampling.format_check --backbone qwen1.5b --domain math |
| python -m tdprm.sampling.format_check --backbone llama3b --domain hotpotqa --weights unsloth/Llama-3.2-3B-Instruct |
| |
| --weights only swaps the weights (e.g. an identical ungated mirror); the tokenizer and chat template |
| always come from the backbone. Writes $TDPRM_HOME/format_check/<backbone>_<domain>.json (summary) |
| and .jsonl.gz (every response with its segments). |
| """ |
|
|
| import argparse |
| import importlib |
| import json |
| import re |
| import sys |
|
|
| import numpy as np |
|
|
| from .. import paths |
| from ..data.prepare import hotpot_records, math500_records, math_train_records, stratified |
| from ..data.segment import _BYTE_DECODER, FINAL_RE, STEP_RE, response_segments, token_char_offsets |
| from ..data.verify import last_boxed, verify |
| from ..rl.launch import DOMAINS |
| from .base_rollouts import model_path |
| from .generate import render_prompt_ids, write_jsonl_gz |
|
|
| LOOSE_STEP_RE = re.compile(r"(?im)^[^\w\n]{0,8}step[ \t]*(\d+)\b") |
|
|
|
|
| def inspect_response(tokenizer, ids): |
| """Format and alignment diagnostics for one generated response (token ids incl. the stop token).""" |
| text, offsets = token_char_offsets(tokenizer, ids) |
| seg, spans = response_segments(tokenizer, ids) |
| finals = list(FINAL_RE.finditer(text)) |
| stop = finals[-1].start() if finals else len(text) |
| markers = [int(m.group(1)) for m in STEP_RE.finditer(text[:stop])] |
| special = set(tokenizer.all_special_ids) |
| pieces = tokenizer.convert_ids_to_tokens(list(ids)) |
| try: |
| exact_offsets = sum(0 if t in special else len(bytes(_BYTE_DECODER[c] for c in p)) |
| for t, p in zip(ids, pieces)) == len(text.encode("utf-8")) |
| except KeyError: |
| exact_offsets = False |
| cuts = [a for a, _ in seg.bounds()[1:]] |
| offset_set = set(offsets) |
| trailing = "" |
| if finals: |
| rest = text[finals[-1].end():].strip("\n") |
| trailing = rest.split("\n", 1)[1].strip() if "\n" in rest else "" |
| tiles = bool(spans) and spans[0][0] == 0 and spans[-1][1] == len(ids) and \ |
| all(spans[i][1] == spans[i + 1][0] for i in range(len(spans) - 1)) |
| return { |
| "text": text, "n_tokens": len(ids), "n_steps": seg.num_steps, "marker_found": seg.marker_found, |
| "markers": markers, "sequential": markers == list(range(1, len(markers) + 1)), |
| "missed_markers": len(LOOSE_STEP_RE.findall(text[:stop])) - len(markers), |
| "has_final": bool(finals), "multiple_final": len(finals) > 1, "trailing_after_final": len(trailing), |
| "preamble_chars": seg.content_start, "boxed": last_boxed(text) is not None, |
| "exact_offsets": exact_offsets, "tiles": tiles, |
| "boundaries_on_token_edges": sum(c in offset_set for c in cuts) / len(cuts) if cuts else 1.0, |
| "empty_step_spans": sum(b <= a for a, b in spans[:-1]), |
| "step_tokens": [b - a for a, b in spans[:-1]], "terminal_tokens": spans[-1][1] - spans[-1][0] if spans else 0, |
| "bounds": seg.bounds(), "spans": spans, "content_token": seg.content_token, |
| } |
|
|
|
|
| def summarize(rows): |
| def rate(key): |
| return float(np.mean([bool(r[key]) for r in rows])) |
| steps = np.array([r["n_steps"] for r in rows]) |
| step_tok = np.concatenate([r["step_tokens"] for r in rows if r["step_tokens"]] or [np.zeros(1)]) |
| marked = [r for r in rows if r["marker_found"]] |
| return { |
| "responses": len(rows), "accuracy": float(np.mean([r["R"] for r in rows])), |
| "truncated": float(np.mean([r["finish"] == "length" for r in rows])), |
| "marker_found": rate("marker_found"), "has_final": rate("has_final"), |
| "sequential_markers": float(np.mean([r["sequential"] for r in marked])) if marked else 0.0, |
| "missed_marker_variants": float(np.mean([r["missed_markers"] > 0 for r in rows])), |
| "multiple_final": rate("multiple_final"), "trailing_after_final": rate("trailing_after_final"), |
| "preamble": float(np.mean([r["preamble_chars"] > 0 for r in rows])), |
| "boxed": rate("boxed"), "has_answer": float(np.mean([r["has_answer"] for r in rows])), |
| "exact_offsets": rate("exact_offsets"), "spans_tile_response": rate("tiles"), |
| "boundaries_on_token_edges": float(np.mean([r["boundaries_on_token_edges"] for r in rows])), |
| "empty_step_spans": int(sum(r["empty_step_spans"] for r in rows)), |
| "zero_steps": float(np.mean(steps == 0)), |
| "steps": {"mean": float(steps.mean()), "p10": float(np.percentile(steps, 10)), |
| "median": float(np.median(steps)), "p90": float(np.percentile(steps, 90)), "max": int(steps.max())}, |
| "step_tokens": {"mean": float(step_tok.mean()), "median": float(np.median(step_tok)), |
| "p90": float(np.percentile(step_tok, 90)), "max": int(step_tok.max())}, |
| "response_tokens": {"mean": float(np.mean([r["n_tokens"] for r in rows])), |
| "max": int(max(r["n_tokens"] for r in rows))}, |
| } |
|
|
|
|
| def show(row, width=1600): |
| """Response text with a ⟦t⟧ mark at the start of every segment (T = terminal segment).""" |
| text, cuts = row["text"], row["bounds"] |
| out, prev = [], 0 |
| for t, (a, _) in enumerate(cuts): |
| out.append(text[prev:a]) |
| out.append(f"⟦{'T' if t == len(cuts) - 1 else t + 1}⟧") |
| prev = a |
| out.append(text[prev:]) |
| s = "".join(out) |
| return s if len(s) <= width else s[:width // 2] + "\n [...]\n" + s[-width // 2:] |
|
|
|
|
| def generate_mlx(weights, prompt_ids, n, temperature, max_tokens, seed, stop_ids, batch_size): |
| import mlx.core as mx |
| from mlx_lm import load |
| from mlx_lm.sample_utils import make_sampler |
| BatchGenerator = importlib.import_module("mlx_lm.generate").BatchGenerator |
| model, _ = load(weights) |
| mx.random.seed(seed) |
| gen = BatchGenerator(model, max_tokens=max_tokens, stop_tokens=set(stop_ids), sampler=make_sampler(temp=temperature), |
| completion_batch_size=batch_size, prefill_batch_size=8) |
| uids = gen.insert([p for p in prompt_ids for _ in range(n)], max_tokens) |
| tokens, finish = {u: [] for u in uids}, {} |
| while responses := gen.next(): |
| for r in responses: |
| tokens[r.uid].append(int(r.token)) |
| if r.finish_reason is not None: |
| finish[r.uid] = r.finish_reason |
| gen.close() |
| flat = [(tokens[u], finish.get(u, "length")) for u in uids] |
| return [flat[i * n:(i + 1) * n] for i in range(len(prompt_ids))] |
|
|
|
|
| def generate_vllm(weights, prompt_ids, n, temperature, max_tokens, seed, max_model_len): |
| from .generate import generate, load_llm |
| llm = load_llm(weights, max_model_len, seed=seed) |
| outs = generate(llm, prompt_ids, n, temperature, 1.0, max_tokens, seed) |
| return [[(ids, finish) for ids, _, finish in samples] for samples in outs] |
|
|
|
|
| def stop_token_ids(tokenizer, path): |
| from transformers import GenerationConfig |
| try: |
| eos = GenerationConfig.from_pretrained(path).eos_token_id |
| except OSError: |
| eos = None |
| eos = eos if isinstance(eos, list) else [eos] if eos is not None else [] |
| return sorted(set(eos) | {tokenizer.eos_token_id}) |
|
|
|
|
| def prompt_lengths(tokenizer, records, max_prompt): |
| lengths = np.array([len(render_prompt_ids(tokenizer, r)) for r in records]) |
| return {"n": len(lengths), "mean": float(lengths.mean()), "p99": float(np.percentile(lengths, 99)), |
| "max": int(lengths.max()), "over_max_prompt": int((lengths > max_prompt).sum())} |
|
|
|
|
| def main(): |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--backbone", required=True, choices=list(paths.BACKBONES)) |
| ap.add_argument("--domain", required=True, choices=list(DOMAINS)) |
| ap.add_argument("--weights", default=None, help="weights to sample from (default: the backbone)") |
| ap.add_argument("--backend", default="mlx" if sys.platform == "darwin" else "vllm", choices=["mlx", "vllm"]) |
| ap.add_argument("--prompts", type=int, default=64, help="prompts per condition") |
| ap.add_argument("--samples", type=int, default=4, help="T=1.0 samples per training prompt") |
| ap.add_argument("--batch-size", type=int, default=32) |
| ap.add_argument("--seed", type=int, default=20261009) |
| ap.add_argument("--examples", type=int, default=2) |
| args = ap.parse_args() |
|
|
| from transformers import AutoTokenizer |
| tok_path = model_path(args.backbone) |
| tok = AutoTokenizer.from_pretrained(tok_path) |
| dom = DOMAINS[args.domain] |
| if args.domain == "math": |
| pool, evals = math_train_records(), math500_records() |
| key = lambda r: (r["meta"].get("type") or r["meta"].get("subject"), r["meta"].get("level")) |
| else: |
| pool, evals = hotpot_records("train", 8000, args.seed), hotpot_records("validation", 1000, args.seed + 1) |
| key = lambda r: (r["meta"]["type"], r["meta"]["level"]) |
| lengths = {"train_pool": prompt_lengths(tok, pool, dom["max_prompt"]), |
| "eval": prompt_lengths(tok, evals, dom["max_prompt"])} |
| conditions = {"train@T1.0": (stratified(pool, args.prompts, args.seed, key), args.samples, 1.0), |
| "eval@greedy": (stratified(evals, args.prompts, args.seed + 1, key), 1, 0.0)} |
| weights = args.weights or tok_path |
| stops = stop_token_ids(tok, tok_path) |
| report = {"backbone": args.backbone, "domain": args.domain, "weights": weights, "tokenizer": tok_path, |
| "backend": args.backend, "stop_ids": stops, "max_response": dom["max_response"], |
| "max_prompt": dom["max_prompt"], "prompt_lengths": lengths, "conditions": {}} |
| all_rows = [] |
| for cname, (records, n, temp) in conditions.items(): |
| prompt_ids = [render_prompt_ids(tok, r) for r in records] |
| if args.backend == "mlx": |
| outs = generate_mlx(weights, prompt_ids, n, temp, dom["max_response"], args.seed, stops, args.batch_size) |
| else: |
| outs = generate_vllm(weights, prompt_ids, n, temp, dom["max_response"], args.seed, |
| dom["max_prompt"] + dom["max_response"]) |
| rows = [] |
| for rec, samples in zip(records, outs): |
| for j, (ids, finish) in enumerate(samples): |
| row = inspect_response(tok, ids) |
| v = verify(rec["data_source"], row["text"], rec["answer"]) |
| row.update(id=rec["id"], sample=j, condition=cname, finish=finish, R=v["score"], |
| has_answer=v["has_answer"], gold=str(rec["answer"])) |
| rows.append(row) |
| report["conditions"][cname] = summarize(rows) |
| all_rows += rows |
| print(f"\n=== {args.backbone} / {args.domain} / {cname} ===") |
| print(json.dumps(report["conditions"][cname], indent=1)) |
| bad = [r for r in rows if not r["marker_found"] or r["missed_markers"] > 0 or not r["has_final"] |
| or not r["sequential"]] |
| for r in rows[:args.examples] + bad[:args.examples]: |
| tag = "PROBLEM" if r in bad else "example" |
| print(f"\n--- {tag}: {r['id']} #{r['sample']} R={r['R']} finish={r['finish']} steps={r['n_steps']} " |
| f"markers={r['markers']} final={r['has_final']} missed={r['missed_markers']}\n{show(r)}") |
| out_dir = paths.HOME / "format_check" |
| out_dir.mkdir(parents=True, exist_ok=True) |
| stem = f"{args.backbone}_{args.domain}" |
| (out_dir / f"{stem}.json").write_text(json.dumps(report, indent=2)) |
| write_jsonl_gz(out_dir / f"{stem}.jsonl.gz", all_rows) |
| print(f"\nprompt lengths: {json.dumps(lengths)}\nwrote {out_dir / stem}.json / .jsonl.gz") |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
