| |
| """Stage-1 routing evaluation: base Qwen + stage-1 LoRA adapter, bf16. |
| Prompt is byte-identical to the stage1 branch of train_qwen_verilog.py. |
| Writes {question_hash, gold_tool, pred_tool, raw} per record.""" |
| import argparse, json, os, re, time, torch |
| from transformers import AutoModelForCausalLM, AutoTokenizer |
| from peft import PeftModel |
|
|
| 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()[:3000] |
| BASE = "Qwen/Qwen2.5-Coder-7B-Instruct" |
| SYS = """You are an expert Verilog design analyzer. Given a question about Verilog code, determine which EDA tool to use and what parameters to pass. |
| |
| Available tools: |
| - synthesis_tool: For PPA metrics (area, delay, power, gate count) |
| - simulation_tool: For functional behavior, toggle rates, timing |
| - graph_extractor: For structural analysis (CDFG, AIG, DFG extraction) |
| - static_analyzer: For code quality, complexity, style analysis |
| - optimization_advisor: For synthesis optimization recommendations |
| - cross_stage_mapper: For RTL-to-netlist alignment analysis |
| |
| Output format: JSON with tool_name, parameters, and reasoning.""" |
| TOOLS = ["synthesis_tool","simulation_tool","graph_extractor","static_analyzer", |
| "optimization_advisor","cross_stage_mapper"] |
| def parse(txt): |
| try: |
| j = json.loads(txt[txt.index("{"):txt.rindex("}")+1]) |
| t = j.get("tool") or j.get("tool_name") |
| if t in TOOLS: return t |
| except Exception: pass |
| for t in TOOLS: |
| if t in txt: return t |
| return "UNPARSED" |
| ap = argparse.ArgumentParser() |
| ap.add_argument("--ref", required=True); ap.add_argument("--adapter", required=True) |
| ap.add_argument("--out", required=True); ap.add_argument("--batch", type=int, default=8) |
| ap.add_argument("--max-new", type=int, default=64); ap.add_argument("--gpu-gib", type=float, default=19) |
| ap.add_argument("--limit", type=int) |
| a = ap.parse_args() |
| 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: done.add(json.loads(l)["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 recs: |
| tok = AutoTokenizer.from_pretrained(a.adapter) |
| if tok.pad_token is None: tok.pad_token = tok.eos_token |
| tok.padding_side = "left"; tok.truncation_side = "left" |
| total = torch.cuda.get_device_properties(0).total_memory / (1024**3) |
| torch.cuda.set_per_process_memory_fraction(min(0.95, a.gpu_gib/total), 0) |
| wb = max(2.0, a.gpu_gib - 6.0) |
| model = AutoModelForCausalLM.from_pretrained(BASE, dtype=torch.bfloat16, device_map="auto", |
| max_memory={0: f"{wb:.0f}GiB", "cpu": "80GiB"}) |
| model = PeftModel.from_pretrained(model, a.adapter); 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 = [tok.apply_chat_template( |
| [{"role":"system","content":SYS}, |
| {"role":"user","content":f"Verilog Code:\n```verilog\n{design_source(r)[:2000]}\n```\n\nQuestion: {r['question']}"}], |
| tokenize=False, add_generation_prompt=True) for r in chunk] |
| enc = tok(prompts, return_tensors="pt", padding=True, truncation=True, max_length=2048) |
| 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"], "category": r.get("category"), |
| "gold_tool": r.get("tool_name"), "pred_tool": parse(txt), |
| "raw": txt[:300]}) + "\n") |
| fh.flush() |
| d = i+len(chunk); el = time.time()-t0 |
| if d % 80 == 0 or d == len(recs): |
| print(f" {d}/{len(recs)} {el:.0f}s eta {(len(recs)-d)*el/max(1,d)/60:.0f}min", flush=True) |
| fh.close() |
| |
| rows = [json.loads(l) for l in open(a.out)] |
| import collections |
| by = collections.defaultdict(lambda: [0,0]); ok = 0 |
| for r in rows: |
| by[r["gold_tool"]][1] += 1 |
| if r["pred_tool"] == r["gold_tool"]: by[r["gold_tool"]][0] += 1; ok += 1 |
| print(f"ROUTING overall {ok}/{len(rows)} = {100*ok/len(rows):.1f}%") |
| for t in TOOLS: |
| k, n = by[t]; print(f" {t:22s} {k:5d}/{n:5d} = {100*k/max(1,n):5.1f}%") |
| conf = collections.Counter((r["gold_tool"], r["pred_tool"]) for r in rows if r["pred_tool"] != r["gold_tool"]) |
| for (g, p), c in conf.most_common(8): print(f" confuse {g} -> {p}: {c}") |
|
|
