versioned rubric + judge machinery

judge/judge_eval.py

@@ -0,0 +1,194 @@
+"""LLM-judge labeling for GitHub issues: bug / feature / question / support.
+
+Judge: openai/gpt-oss-120b via HF Inference Providers (novita), strict JSON schema,
+reasoning_effort=low. Reads the FULL issue text (title + body) — no truncation.
+
+Usage:
+  python judge_eval.py --n-per-class 1   # smoke: 4 issues, 1 per maintainer label
+  python judge_eval.py --n-per-class 50  # full eval set: 200 issues
+Writes judge/review_<N>.jsonl + .csv to pngwn/github-issues-4class and prints summary.
+
+References: hf://docs/inference-providers/guides/structured-output,
+hf://docs/huggingface_hub/guides/inference.md, hf://docs/hub/jobs-configuration.md
+"""
+import argparse
+import asyncio
+import io
+import json
+import os
+
+import pandas as pd
+from huggingface_hub import AsyncInferenceClient, HfApi, hf_hub_download
+
+MODEL = "openai/gpt-oss-120b"
+PROVIDER = "novita"
+DATASET_REPO = "pngwn/github-issues-4class"
+LABELS = ["bug", "feature", "question", "support"]
+CONCURRENCY = 8
+MAX_RETRIES = 4
+
+SCHEMA = {
+    "type": "json_schema",
+    "json_schema": {
+        "name": "IssueVerdict",
+        "schema": {
+            "type": "object",
+            "properties": {
+                "label": {"enum": LABELS},
+                "confidence": {"type": "number", "description": "0-1"},
+                "rationale": {"type": "string", "description": "at most 30 words"},
+            },
+            "required": ["label", "confidence", "rationale"],
+            "additionalProperties": False,
+        },
+        "strict": True,
+    },
+}
+
+SYSTEM = """You are an expert triage labeler for GitHub issues. Classify the issue into exactly \
+one of four labels, judging the FULL text (title and body). Judge intent and context, not \
+formatting: template headers and title prefixes like "[Bug]" are conventions, not evidence — \
+some repos use them inconsistently or incorrectly.
+
+Definitions and decision rules:
+- bug: The software behaves incorrectly, crashes, regresses, or fails under usage that is \
+correct according to its documented/intended behavior. There is a defect or gap in the library \
+itself. Key test: would resolving this require a change to the library? A crash whose root \
+cause is the user's misconfiguration, unsupported environment, or incorrect usage is NOT a bug.
+- support: The user needs help getting something to work. Their usage, configuration, \
+environment, or setup is likely wrong or unsupported, and the software is behaving as designed. \
+The likely resolution is guidance, configuration, or environment changes on the user side.
+- question: The user asks how something works, how to do something, whether something is \
+possible, or requests information — without claiming the software misbehaves. Documentation \
+gaps surfaced as "how do I...?" are questions, not bugs.
+- feature: The user requests new functionality, an enhancement, or a behavior change they \
+want — not a report that existing behavior is broken.
+
+Ambiguity resolution (this is where most errors happen):
+- "X crashes" alone is ambiguous. Decide from evidence: stack traces pointing into library \
+code with correct/documented usage, or reproduction via documented APIs, indicate bug; \
+evidence of user-side setup, version mismatch the user can fix, or misconfiguration indicates \
+support.
+- A carefully written report analyzing library internals to find a root cause is a bug even \
+if it reads like a request for help.
+- A request phrased as "help me" that describes a genuine defect is a bug.
+- If a defect claim and a new-capability request both appear, follow the dominant intent.
+- If the text is genuinely undecidable, pick the closest label and lower your confidence.
+
+Respond with JSON only: label, confidence (0-1), rationale (max 30 words)."""
+
+
+def parse_args():
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--n-per-class", type=int, default=50)
+    ap.add_argument("--split", default="test")
+    ap.add_argument("--seed", type=int, default=42)
+    ap.add_argument("--out-prefix", default=None)
+    return ap.parse_args()
+
+
+def load_split(split):
+    path = hf_hub_download(repo_id=DATASET_REPO, repo_type="dataset", filename=f"data/{split}-00000-of-00001.parquet")
+    return pd.read_parquet(path)
+
+
+async def judge_one(client, sem, row_id, text):
+    async with sem:
+        last_err = None
+        for attempt in range(MAX_RETRIES):
+            try:
+                resp = await client.chat_completion(
+                    model=MODEL,
+                    messages=[
+                        {"role": "system", "content": SYSTEM},
+                        {"role": "user", "content": text},
+                    ],
+                    response_format=SCHEMA,
+                    max_tokens=250,
+                )
+                content = resp.choices[0].message.content
+                verdict = json.loads(content)
+                if verdict.get("label") not in LABELS:
+                    raise ValueError(f"bad label: {verdict.get('label')!r}")
+                usage = getattr(resp, "usage", None)
+                return {
+                    "id": row_id,
+                    "verdict": verdict,
+                    "prompt_tokens": getattr(usage, "prompt_tokens", None),
+                    "completion_tokens": getattr(usage, "completion_tokens", None),
+                }
+            except Exception as e:  # noqa: BLE001 — retry any transient failure
+                last_err = e
+                await asyncio.sleep(min(2 ** attempt * 3, 30))
+        return {"id": row_id, "error": str(last_err)}
+
+
+async def run(rows):
+    client = AsyncInferenceClient(provider=PROVIDER, api_key=os.environ["HF_TOKEN"])
+    sem = asyncio.Semaphore(CONCURRENCY)
+    tasks = [judge_one(client, sem, r["id"], r["text"]) for r in rows]
+    return await asyncio.gather(*tasks)
+
+
+def main():
+    args = parse_args()
+    df = load_split(args.split)
+    assert {"text", "label"} <= set(df.columns)
+
+    df = df.reset_index(drop=False).rename(columns={"index": "row_id"})
+    parts = []
+    for lbl in LABELS:
+        sub = df[df["label"] == lbl]
+        if len(sub) > args.n_per_class:
+            sub = sub.sample(n=args.n_per_class, random_state=args.seed)
+        parts.append(sub)
+    strat = pd.concat(parts).reset_index(drop=True)
+    rows = [
+        {"id": int(r["row_id"]), "text": str(r["text"]), "maintainer_label": str(r["label"]), "repo": str(r["repo"])}
+        for _, r in strat.iterrows()
+    ]
+    print(f"judging {len(rows)} issues ({args.n_per_class}/class from {args.split})...")
+
+    results = asyncio.run(run(rows))
+
+    by_id = {r["id"]: r for r in results}
+    out_rows, errs, ptok, ctok = [], 0, 0, 0
+    for row in rows:
+        res = by_id[row["id"]]
+        if "error" in res:
+            errs += 1
+            verdict = {"label": "ERROR", "confidence": 0.0, "rationale": res["error"][:200]}
+        else:
+            verdict = res["verdict"]
+            ptok += res["prompt_tokens"] or 0
+            ctok += res["completion_tokens"] or 0
+        out_rows.append({**row, "judge_label": verdict["label"], "judge_confidence": verdict["confidence"],
+                         "judge_rationale": verdict["rationale"]})
+
+    out = pd.DataFrame(out_rows)
+    agree = (out["judge_label"] == out["maintainer_label"]).mean()
+    print(f"\nerrors: {errs}/{len(out)}")
+    print(f"judge agrees with maintainer label: {agree:.1%}")
+    print("\nconfusion (rows=maintainer, cols=judge):")
+    print(pd.crosstab(out["maintainer_label"], out["judge_label"]).to_string())
+    print(f"\ntokens: {ptok} in / {ctok} out  (~${ptok * 0.05 / 1e6 + ctok * 0.25 / 1e6:.4f} at gpt-oss-120b novita rates)")
+
+    prefix = args.out_prefix or f"review_{len(out)}"
+    api = HfApi()
+    for name, data in [
+        (f"judge/{prefix}.jsonl", "\n".join(json.dumps(r) for r in out_rows)),
+        (f"judge/{prefix}.csv", out.to_csv(index=False)),
+    ]:
+        api.upload_file(
+            path_or_fileobj=data.encode(),
+            path_in_repo=name,
+            repo_id=DATASET_REPO,
+            repo_type="dataset",
+            commit_message=f"judge labels: {prefix}",
+        )
+        print(f"uploaded {name}")
+    print("DONE")
+
+
+if __name__ == "__main__":
+    main()