fix: minimal gr.Interface tabs (TabbedInterface, not Blocks)

app.py

@@ -1,173 +1,110 @@
-"""surrogate1 ZeroGPU — Qwen2.5-Coder-32B AWQ synth+judge worker.
+"""surrogate1 ZeroGPU synth+judge — minimal gr.Interface tabs via Blocks.
 
-Higher-quality synth pairs + better judge calibration with 32B vs 7B.
-AWQ pre-quantized = no bitsandbytes runtime quant = no startup error.
+Same gradio-compat pattern as ashirato (gr.Interface only, no ChatInterface).
+3 endpoints exposed via separate Interfaces, mounted on TabbedInterface.
 """
-import os, json, re
-import gradio as gr
-import spaces
-import torch
+import os, json, re, gradio as gr, spaces, torch
 
-BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-Coder-14B-Instruct")
+BASE_MODEL = os.environ.get("BASE_MODEL", "Qwen/Qwen2.5-Coder-7B-Instruct")
 HF_TOKEN   = os.environ.get("HF_TOKEN", "")
 
-DOMAIN_SEEDS = {
-    "code-python": "a Python coding task",
-    "code-typescript": "a TypeScript / Node.js coding task",
-    "code-rust": "a Rust coding task",
-    "code-go": "a Go coding task",
-    "devops-tf": "a Terraform / IaC task",
-    "devops-k8s": "a Kubernetes manifest or operator task",
-    "devops-cdk": "an AWS CDK construct task",
-    "ci-github": "a GitHub Actions workflow task",
-    "sec-iam": "an IAM least-privilege policy task",
-    "sec-cve": "a CVE remediation task",
-    "sre-runbook": "an incident runbook task",
-    "sre-slo": "an SLI/SLO/error-budget definition task",
-    "data-sql": "a parameterized SQL query task",
-    "ai-eng": "a RAG / vector / LoRA / vLLM task",
-    "api-rest": "a REST API design task",
-    "test-pytest": "a pytest test-writing task",
-}
-
-JUDGE_PRINCIPLES = (
-    "Score the response 0-10 on: correctness, security (no leaked secrets, "
-    "IAM least-priv, input validated), idiomatic, completeness, citation "
-    "(real APIs only). Return ONLY JSON: "
-    "{\"score\": float, \"axes\": {...}, \"why\": \"...\"}"
-)
-
-_model = None
-_tok = None
-
-
-def _load_lazy():
-    global _model, _tok
-    if _model is not None:
-        return _model, _tok
-    from transformers import AutoModelForCausalLM, AutoTokenizer
-    _tok = AutoTokenizer.from_pretrained(
-        BASE_MODEL, token=HF_TOKEN or None, trust_remote_code=True)
-    if _tok.pad_token_id is None:
-        _tok.pad_token_id = _tok.eos_token_id
-    from transformers import BitsAndBytesConfig
-    bnb = BitsAndBytesConfig(
-        load_in_4bit=True,
-        bnb_4bit_compute_dtype=torch.bfloat16,
-        bnb_4bit_quant_type="nf4",
-        bnb_4bit_use_double_quant=True,
-    )
-    _model = AutoModelForCausalLM.from_pretrained(
+DOMAINS = ["code-python", "code-typescript", "code-rust", "code-go",
+           "devops-tf", "devops-k8s", "devops-cdk", "ci-github",
+           "sec-iam", "sec-cve", "sre-runbook", "sre-slo",
+           "data-sql", "ai-eng", "api-rest", "test-pytest"]
+SEED_TPL = "a {} task"
+
+JUDGE_RULES = ("Score 0-10: correctness, security, idiomatic, completeness, "
+               "real-API citation. Return ONLY JSON: "
+               '{"score":float,"why":str}')
+
+_m = _t = None
+
+
+def _load():
+    global _m, _t
+    if _m is not None: return _m, _t
+    from transformers import AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+    _t = AutoTokenizer.from_pretrained(BASE_MODEL, token=HF_TOKEN or None,
+                                        trust_remote_code=True)
+    if _t.pad_token_id is None: _t.pad_token_id = _t.eos_token_id
+    bnb = BitsAndBytesConfig(load_in_4bit=True,
+                             bnb_4bit_compute_dtype=torch.bfloat16,
+                             bnb_4bit_quant_type="nf4",
+                             bnb_4bit_use_double_quant=True)
+    _m = AutoModelForCausalLM.from_pretrained(
         BASE_MODEL, token=HF_TOKEN or None, trust_remote_code=True,
         device_map="cuda", quantization_config=bnb)
-    return _model, _tok
+    return _m, _t
 
 
-def _generate(prompt, max_new=512, temp=0.7):
-    model, tok = _load_lazy()
-    inputs = tok(prompt, return_tensors="pt", truncation=True,
-                 max_length=8000).to("cuda")
-    out = model.generate(
-        **inputs, max_new_tokens=int(max_new), temperature=float(temp),
-        top_p=0.9, do_sample=temp > 0,
-        pad_token_id=tok.pad_token_id, eos_token_id=tok.eos_token_id)
-    return tok.decode(out[0][inputs["input_ids"].shape[1]:],
-                      skip_special_tokens=True).strip()
+def _gen(prompt, max_new=512, temp=0.7):
+    m, t = _load()
+    inputs = t(prompt, return_tensors="pt", truncation=True, max_length=8000).to("cuda")
+    out = m.generate(**inputs, max_new_tokens=int(max_new),
+                     temperature=float(temp), top_p=0.9, do_sample=temp > 0,
+                     pad_token_id=t.pad_token_id, eos_token_id=t.eos_token_id)
+    return t.decode(out[0][inputs["input_ids"].shape[1]:], skip_special_tokens=True).strip()
 
 
 @spaces.GPU(duration=300)
-def synth_batch(domain="code-python", count=10):
-    model, tok = _load_lazy()
-    seed_text = DOMAIN_SEEDS.get(domain, DOMAIN_SEEDS["code-python"])
+def synth_batch(domain: str, count: int) -> str:
+    m, t = _load()
+    seed = SEED_TPL.format(domain.replace("-", " "))
     out_lines = []
     for i in range(int(count)):
         instr_msgs = [
             {"role": "system",
-             "content": f"Generate ONE realistic, diverse, high-quality user request about {seed_text}. "
+             "content": f"Generate ONE realistic, diverse, high-quality user request about {seed}. "
                         "Output ONLY the request as a single paragraph. No preamble."},
             {"role": "user", "content": ""},
         ]
-        ip = tok.apply_chat_template(instr_msgs, tokenize=False, add_generation_prompt=True)
-        instruction = _generate(ip, max_new=180, temp=0.95).strip().split("\n")[0][:600]
+        ip = t.apply_chat_template(instr_msgs, tokenize=False, add_generation_prompt=True)
+        instruction = _gen(ip, max_new=180, temp=0.95).strip().split("\n")[0][:600]
         if len(instruction) < 30: continue
-
         resp_msgs = [
-            {"role": "system", "content": "You are Surrogate-1, expert DevSecOps + coding agent. "
-             "Cite real APIs. No phantom imports."},
+            {"role": "system",
+             "content": "You are Surrogate-1, expert DevSecOps + coding agent. Real APIs only."},
             {"role": "user", "content": instruction},
         ]
-        rp = tok.apply_chat_template(resp_msgs, tokenize=False, add_generation_prompt=True)
-        response = _generate(rp, max_new=512, temp=0.4)
+        rp = t.apply_chat_template(resp_msgs, tokenize=False, add_generation_prompt=True)
+        response = _gen(rp, max_new=512, temp=0.4)
         if len(response) < 50: continue
-
         out_lines.append(json.dumps({
             "prompt": instruction, "response": response,
-            "source": "magpie-zerogpu-32b",
+            "source": "magpie-zerogpu",
             "meta": {"domain": domain, "ix": i},
         }, ensure_ascii=False))
     return "\n".join(out_lines)
 
 
 @spaces.GPU(duration=120)
-def judge_pair(prompt, response, criteria="default"):
+def judge_pair(prompt: str, response: str) -> str:
     if not prompt or not response:
         return json.dumps({"score": 0.0, "why": "empty"})
-    model, tok = _load_lazy()
-    j_msgs = [
-        {"role": "system", "content": "You are a strict senior code reviewer. " + JUDGE_PRINCIPLES},
-        {"role": "user", "content": f"PROMPT:\n{prompt[:2000]}\n\nRESPONSE:\n{response[:4000]}\n\nScore. JSON only."},
-    ]
-    jp = tok.apply_chat_template(j_msgs, tokenize=False, add_generation_prompt=True)
-    raw = _generate(jp, max_new=400, temp=0.1)
-    m = re.search(r"\{[^{}]*\"score\"[^{}]*\}", raw, re.DOTALL)
-    if m:
-        try: return json.dumps(json.loads(m.group(0)), ensure_ascii=False)
+    m, t = _load()
+    j_msgs = [{"role": "system", "content": "You are a strict reviewer. " + JUDGE_RULES},
+              {"role": "user", "content": f"PROMPT:\n{prompt[:2000]}\n\nRESPONSE:\n{response[:4000]}\n\nScore. JSON only."}]
+    raw = _gen(t.apply_chat_template(j_msgs, tokenize=False, add_generation_prompt=True),
+               max_new=300, temp=0.1)
+    mm = re.search(r"\{[^{}]*\"score\"[^{}]*\}", raw, re.DOTALL)
+    if mm:
+        try: return json.dumps(json.loads(mm.group(0)), ensure_ascii=False)
         except: pass
-    return json.dumps({"score": 5.0, "why": raw[:300], "raw": True})
+    return json.dumps({"score": 5.0, "why": raw[:200], "raw": True})
 
 
-@spaces.GPU(duration=300)
-def best_of_n(prompt, n=4, max_new=512):
-    if not prompt: return json.dumps({"error": "empty"})
-    model, tok = _load_lazy()
-    sys_msg = "You are Surrogate-1. Solve the task with production-quality code."
-    cands = []
-    for i in range(int(n)):
-        msgs = [{"role": "system", "content": sys_msg}, {"role": "user", "content": prompt}]
-        p = tok.apply_chat_template(msgs, tokenize=False, add_generation_prompt=True)
-        cands.append(_generate(p, max_new=int(max_new), temp=0.7 + 0.05 * i))
-    scored = []
-    for c in cands:
-        s = min(1.0, len(c) / 800)
-        if "```" in c: s += 0.2
-        if "import " in c or "def " in c: s += 0.1
-        scored.append((s, c))
-    scored.sort(key=lambda x: -x[0])
-    return json.dumps({"best": scored[0][1], "best_score": scored[0][0],
-                        "all": [c for _, c in scored]}, ensure_ascii=False)
-
-
-with gr.Blocks(title="Surrogate-1 32B synth+judge") as demo:
-    gr.Markdown(
-        f"# Surrogate-1 — synth + judge (Qwen2.5-Coder-32B AWQ)\n"
-        f"3 endpoints: `/run/synth_batch`, `/run/judge_pair`, `/run/best_of_n`"
-    )
-    with gr.Tab("synth"):
-        d = gr.Dropdown(list(DOMAIN_SEEDS.keys()), value="code-python", label="domain")
-        n = gr.Slider(1, 20, value=10, step=1, label="count")
-        gr.Button("synth_batch").click(synth_batch, [d, n], gr.Textbox(label="JSONL", lines=20),
-                                         api_name="synth_batch")
-    with gr.Tab("judge"):
-        p = gr.Textbox(label="prompt", lines=3); r = gr.Textbox(label="response", lines=8)
-        c = gr.Textbox(label="criteria", value="default")
-        gr.Button("judge_pair").click(judge_pair, [p, r, c], gr.Textbox(label="JSON", lines=8),
-                                        api_name="judge_pair")
-    with gr.Tab("best-of-n"):
-        bp = gr.Textbox(label="prompt", lines=3)
-        bn = gr.Slider(2, 6, value=4, step=1, label="n")
-        bm = gr.Slider(128, 1024, value=512, step=64, label="max_new")
-        gr.Button("best_of_n").click(best_of_n, [bp, bn, bm], gr.Textbox(label="JSON", lines=15),
-                                        api_name="best_of_n")
-
-if __name__ == "__main__":
-    demo.queue(max_size=6).launch()
+synth_iface = gr.Interface(synth_batch,
+    [gr.Dropdown(DOMAINS, value="code-python", label="domain"),
+     gr.Slider(1, 20, value=10, step=1, label="count")],
+    gr.Textbox(label="JSONL", lines=20),
+    title="Magpie synth_batch")
+
+judge_iface = gr.Interface(judge_pair,
+    [gr.Textbox(label="prompt", lines=3),
+     gr.Textbox(label="response", lines=8)],
+    gr.Textbox(label="JSON", lines=6),
+    title="LLM-as-judge")
+
+demo = gr.TabbedInterface([synth_iface, judge_iface], ["synth", "judge"])
+demo.queue(max_size=6).launch()