Datasets:
File size: 5,355 Bytes
676defa | 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 | #!/usr/bin/env python3
"""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()
# summary
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}")
|