| |
| """ |
| Generation side-by-sides on held-out val prompts: base google/gemma-4-31B vs each |
| character's dedicated LoRA (r=32) vs the all-speaker ensemble LoRA (r=64). |
| |
| One GPU, ONE base load. PEFT multi-adapter: PeftModel.from_pretrained with the |
| ensemble, then load_adapter() x10; set_adapter() swaps, disable_adapter() context |
| gives the raw base. Reuses the trainer's exact load_model/load_tokenizer chain |
| (train_ensemble_31b.py must sit next to this file's staged copy at /work/). |
| |
| For each of the 10 characters: first 4 val records whose prompt has >= 3 context |
| lines; sample (temperature 0.8, top_p 0.9, max_new_tokens 120, stop at first |
| newline), seed deterministic per (context, config). Results appended (flushed |
| per record) to /work/eval_results/samples.jsonl as |
| {char, ctx_tail, gold, base, dedicated, ensemble} |
| |
| Run inside nvcr.io/nvidia/pytorch:26.05-py3 with transformers==5.5.0 + peft: |
| python /work/gen_samples.py |
| """ |
| import json |
| import os |
| import sys |
| import zlib |
|
|
| sys.path.insert(0, "/work") |
| from train_ensemble_31b import load_model, load_tokenizer |
|
|
| MODEL = "google/gemma-4-31B" |
| SLUGS = ["spongebob", "patrick", "squidward", "mr_krabs", "plankton", |
| "sandy", "mrs_puff", "karen", "gary", "pearl"] |
| ENSEMBLE_DIR = "/work/adapters/_ensemble/final" |
| ADAPTER_DIR = "/work/adapters/{slug}/final" |
| DATA_DIR = "/work/dataset" |
| OUT_PATH = "/work/eval_results/samples.jsonl" |
| N_PER_CHAR = 4 |
| MIN_CTX_LINES = 3 |
|
|
| GEN_ARGS = dict(do_sample=True, temperature=0.8, top_p=0.9, max_new_tokens=120) |
|
|
|
|
| def pick_records(slug): |
| """First N val records whose prompt carries >= MIN_CTX_LINES context lines. |
| The prompt's last \n-piece is the bare '<Character>:' cue, not context.""" |
| out = [] |
| with open(f"{DATA_DIR}/{slug}/val.jsonl") as f: |
| for ln in f: |
| r = json.loads(ln) |
| if len(r["prompt"].split("\n")[:-1]) >= MIN_CTX_LINES: |
| out.append(r) |
| if len(out) == N_PER_CHAR: |
| break |
| return out |
|
|
|
|
| def seed_for(prompt, config): |
| """Deterministic per (context, config) so reruns reproduce exactly.""" |
| return zlib.crc32(f"{prompt}\x00{config}".encode()) & 0x7FFFFFFF |
|
|
|
|
| def main(): |
| import peft |
| import torch |
| from peft import PeftModel |
| from transformers import StoppingCriteria, StoppingCriteriaList |
|
|
| print(f"peft {peft.__version__}", flush=True) |
|
|
| tok = load_tokenizer(MODEL) |
| model = load_model(MODEL) |
| model.config.get_text_config().use_cache = True |
|
|
| model = PeftModel.from_pretrained(model, ENSEMBLE_DIR, adapter_name="_ensemble") |
| |
| for api in ("load_adapter", "set_adapter", "disable_adapter"): |
| assert hasattr(model, api), f"installed peft {peft.__version__} lacks PeftModel.{api}" |
| for slug in SLUGS: |
| model.load_adapter(ADAPTER_DIR.format(slug=slug), adapter_name=slug) |
| print(f"loaded adapter: {slug}", flush=True) |
| model.to("cuda").eval() |
|
|
| class StopOnNewline(StoppingCriteria): |
| """Stop as soon as the generated text (decoded, batch=1) contains \n. |
| Decoding the suffix each step is cheap at <=120 tokens and immune to the |
| many tokenizations a newline can hide in (e.g. merged punctuation+\n).""" |
|
|
| def __init__(self, prompt_len): |
| self.prompt_len = prompt_len |
|
|
| def __call__(self, input_ids, scores, **kw): |
| return "\n" in tok.decode(input_ids[0, self.prompt_len:], |
| skip_special_tokens=True) |
|
|
| |
| |
| def probe_mm_mode(): |
| enc = tok("Hello", return_tensors="pt").to("cuda") |
| for mode in ("plain", "mm_zeros"): |
| kw = dict(**enc, max_new_tokens=2, do_sample=False, |
| pad_token_id=tok.pad_token_id) |
| if mode == "mm_zeros": |
| kw["mm_token_type_ids"] = torch.zeros_like(enc["input_ids"]) |
| try: |
| with torch.inference_mode(): |
| model.generate(**kw) |
| print(f"generate() convention: {mode}", flush=True) |
| return mode |
| except Exception as e: |
| print(f"probe {mode} failed: {type(e).__name__}: {e}", flush=True) |
| raise RuntimeError("generate() works neither with nor without mm_token_type_ids") |
|
|
| mm_mode = probe_mm_mode() |
|
|
| def generate(prompt, config): |
| enc = tok(prompt, add_special_tokens=True, return_tensors="pt").to("cuda") |
| n = enc["input_ids"].shape[1] |
| kw = dict(**enc, **GEN_ARGS, |
| stopping_criteria=StoppingCriteriaList([StopOnNewline(n)]), |
| pad_token_id=tok.pad_token_id) |
| if mm_mode == "mm_zeros": |
| kw["mm_token_type_ids"] = torch.zeros_like(enc["input_ids"]) |
| seed = seed_for(prompt, config) |
| torch.manual_seed(seed) |
| torch.cuda.manual_seed_all(seed) |
| with torch.inference_mode(): |
| out = model.generate(**kw) |
| text = tok.decode(out[0, n:], skip_special_tokens=True) |
| return text.split("\n")[0].strip() |
|
|
| os.makedirs(os.path.dirname(OUT_PATH), exist_ok=True) |
| n_done = 0 |
| with open(OUT_PATH, "w") as out: |
| for slug in SLUGS: |
| recs = pick_records(slug) |
| print(f"\n=== {slug}: {len(recs)} prompts ===", flush=True) |
| for i, r in enumerate(recs): |
| prompt = r["prompt"] |
| row = { |
| "char": slug, |
| "ctx_tail": prompt.split("\n")[:-1][-2:], |
| "gold": r["completion"].strip(), |
| } |
| with model.disable_adapter(): |
| row["base"] = generate(prompt, "base") |
| model.set_adapter(slug) |
| row["dedicated"] = generate(prompt, "dedicated") |
| model.set_adapter("_ensemble") |
| row["ensemble"] = generate(prompt, "ensemble") |
| out.write(json.dumps(row, ensure_ascii=False) + "\n") |
| out.flush() |
| n_done += 1 |
| print(f" [{n_done}] {slug}#{i} gold={row['gold'][:50]!r}\n" |
| f" base={row['base'][:50]!r}\n" |
| f" dedicated={row['dedicated'][:50]!r}\n" |
| f" ensemble={row['ensemble'][:50]!r}", flush=True) |
|
|
| print(f"\nALL DONE: {n_done} records -> {OUT_PATH}", flush=True) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
