#!/usr/bin/env python3 """CircuitQA inference: base Qwen + LoRA adapter, fp/bf16, no quantization. Three conditions: A question + Verilog (identical to the baselines) B + the record's own tool_result (identical to the baselines) C-oracle gold category and gold tool name in the system prompt, plus the tool output (oracle routing; the router is not used) """ import argparse, json, os, time, torch from transformers import AutoModelForCausalLM, AutoTokenizer from peft import PeftModel BASE = "Qwen/Qwen2.5-Coder-7B-Instruct" TOOL_CAP = 8000 # chars; structural_analysis JSON reaches 52k otherwise SYS_A = "You are an expert Verilog design analyzer." SYS_B = ("You are an expert Verilog design analyzer. Use the provided tool analysis " "results to answer accurately. Always use the EXACT values from the tool " "output - do not estimate or approximate.") def design_source(rec): """Released records reference the design (`source`) instead of carrying it: read the file fetched by scripts/fetch_sources.py from $CIRCUITQA_SOURCES (default ./sources).""" if rec.get("verilog_code"): return rec["verilog_code"] path = os.path.join(os.environ.get("CIRCUITQA_SOURCES", "sources"), rec["source"]["sha256"] + ".v") if not os.path.exists(path): raise SystemExit(f"design source {path} not found: run scripts/fetch_sources.py first") return open(path, encoding="utf-8").read()[:rec.get("prompt_code_chars", 3000)] def build(rec, cond, vcap): v = design_source(rec)[:vcap] q = rec.get("question", "") tr = rec.get("tool_result", "") if not isinstance(tr, str): tr = json.dumps(tr, indent=2) if len(tr) > TOOL_CAP: # The summary block (node_count, edge_count, avg_degree, gate counts) # is emitted at the END of the tool JSON -- for graph_extractor it sits # past char 62000 of 62800. A head-only cap removes exactly the fields # the gold answers quote, so keep both ends. head = TOOL_CAP // 3 tail = TOOL_CAP - head tr = (tr[:head] + "\n...[" + str(len(tr) - TOOL_CAP) + " chars elided]...\n" + tr[-tail:]) if cond == "A": return SYS_A, f"Verilog Code:\n```verilog\n{v}\n```\n\nQuestion: {q}" if cond == "B": return SYS_B, (f"Verilog Code:\n```verilog\n{v}\n```\n\n" f"Tool Analysis:\n{tr}\n\nQuestion: {q}") # C-oracle: reproduces training/comprehensive_inference_test.py verbatim cat = (rec.get("category") or "").replace("_", " ") tool = rec.get("tool_name", "") sys_p = (f"You are an expert Verilog design analyzer specializing in {cat}. " f"Use the provided tool analysis results to answer accurately. " f"Always use the EXACT values from the tool output - do not estimate " f"or approximate.") return sys_p, (f"Verilog Code:\n```verilog\n{v}\n```\n\n" f"Tool Analysis ({tool}):\n{tr}\n\nQuestion: {q}") def main(): ap = argparse.ArgumentParser() ap.add_argument("--ref", required=True) ap.add_argument("--adapter", default="adapter") ap.add_argument("--condition", required=True, choices=["A", "B", "C-oracle"]) ap.add_argument("--out", required=True) ap.add_argument("--limit", type=int) ap.add_argument("--batch", type=int, default=8) ap.add_argument("--threads", type=int, default=48) ap.add_argument("--max-new", type=int, default=256) ap.add_argument("--verilog-cap", type=int, default=2000) ap.add_argument("--max-len", type=int, default=6144, help="prompt window; structural_analysis tool_result alone " "reaches ~15k tokens") ap.add_argument("--gpu-gib", type=float, default=0, help="cap GPU use at N GiB and offload the rest to CPU; " "0 = pure CPU. A hard cap means THIS process OOMs " "before it can starve anything else on the card.") ap.add_argument("--base-only", action="store_true", help="skip the LoRA adapter: the untuned base-model row") a = ap.parse_args() torch.set_num_threads(a.threads) recs = [json.loads(l) for l in open(a.ref) if l.strip()] if a.limit: recs = recs[:a.limit] done = set() if os.path.exists(a.out): for l in open(a.out): try: r = json.loads(l) if (r.get("prediction") or "").strip(): done.add(r["question_hash"]) except Exception: pass recs = [r for r in recs if r["question_hash"] not in done] print(f"{len(done)} already done, {len(recs)} to run", flush=True) if not recs: return dtype = torch.bfloat16 # training dtype; not quantization print(f"loading {BASE} dtype={dtype} threads={a.threads}", flush=True) tok = AutoTokenizer.from_pretrained(a.adapter if not a.base_only else BASE) if tok.pad_token is None: tok.pad_token = tok.eos_token tok.padding_side = "left" tok.truncation_side = "left" # keep the question, drop the oldest context if a.gpu_gib > 0 and torch.cuda.is_available(): total = torch.cuda.get_device_properties(0).total_memory / (1024**3) frac = min(0.95, a.gpu_gib / total) torch.cuda.set_per_process_memory_fraction(frac, 0) print(f"GPU cap {a.gpu_gib:.1f} GiB of {total:.1f} GiB " f"(fraction {frac:.3f}); surplus layers go to CPU", flush=True) # Weights must leave room for activations and the KV cache inside the # same cap, or the first forward pass OOMs against our own limit. wbudget = max(2.0, a.gpu_gib - 6.0) print(f" weights<={wbudget:.0f}GiB on GPU, rest on CPU, " f"{a.gpu_gib-wbudget:.0f}GiB reserved for activations", flush=True) model = AutoModelForCausalLM.from_pretrained( BASE, dtype=dtype, device_map="auto", max_memory={0: f"{wbudget:.0f}GiB", "cpu": "80GiB"}) else: model = AutoModelForCausalLM.from_pretrained(BASE, dtype=dtype, device_map="cpu") if not a.base_only: model = PeftModel.from_pretrained(model, a.adapter) print("LoRA adapter attached", flush=True) model.eval() fh = open(a.out, "a") t0 = time.time() for i in range(0, len(recs), a.batch): chunk = recs[i:i + a.batch] prompts = [] for r in chunk: s, u = build(r, a.condition, a.verilog_cap) prompts.append(tok.apply_chat_template( [{"role": "system", "content": s}, {"role": "user", "content": u}], tokenize=False, add_generation_prompt=True)) enc = tok(prompts, return_tensors="pt", padding=True, truncation=True, max_length=a.max_len) enc = {k: v.to(model.device) for k, v in enc.items()} with torch.no_grad(): out = model.generate(**enc, max_new_tokens=a.max_new, do_sample=False, temperature=None, top_p=None, pad_token_id=tok.pad_token_id) for r, o, n in zip(chunk, out.cpu(), enc["input_ids"].cpu()): txt = tok.decode(o[len(n):], skip_special_tokens=True).strip() fh.write(json.dumps({"question_hash": r["question_hash"], "prediction": txt, "category": r.get("category")}) + "\n") fh.flush() d = i + len(chunk) el = time.time() - t0 print(f" {d}/{len(recs)} {el:.0f}s {el/max(1,d):.1f}s/sample " f"eta {(len(recs)-d)*el/max(1,d)/60:.0f}min", flush=True) fh.close() if __name__ == "__main__": main()