Datasets:

drawais
/

circuitqa

#!/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()

	#!/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()