Show CodeQL in the bug and security benchmark tables

README.md

@@ -28,7 +28,7 @@ Pairs come from open-source projects in Rust, JavaScript, TypeScript, Python, Go
 
 Each line shows how many issues a model finds and what percentage of clean methods it wrongly flags as its score cutoff changes. Higher and farther left is better.
 
-The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best displayed value in each column; cost compares priced runs captured here.
+The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best full-set value in each column; cost compares priced runs captured here.
 
 ## Bugs
 
@@ -47,6 +47,9 @@ The tables use each run's recorded alert settings. A value of 20% under ‘Clean
 | [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 25.3% | 22.6% | 2.7% | **$0.182** |
 | [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 4.1% | **2.5%** | 1.6% | Free tier |
 | [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **81.9%** | 80.9% | 1.0% | ~$0.210 |
+| [CodeQL](https://codeql.github.com/) (52 pairs) | 0.0% | 0.0% | 0.0% | — |
+
+CodeQL scored 52 of the 2,220 public pairs; other models scored all pairs. Its [method decisions](codeql-comparison/) and [evaluation protocol](CODEQL.md) are available here.
 
 ### Private — 498 pairs
 
@@ -75,9 +78,12 @@ The tables use each run's recorded alert settings. A value of 20% under ‘Clean
 | [Liquid d1](https://docs.liquid.ai/lfm/models/decision-models) | 55.6% | 46.8% | 8.8% | Free tier |
 | [DiffusionGemma Jev](https://github.com/razorback16/openjev) | 33.1% | 25.8% | 7.3% | **$0.208** |
 | [Span-01](https://www.respan.ai/docs/documentation/span-01/concept) | 21.0% | **17.2%** | 3.9% | $0.251 |
+| [CodeQL](https://codeql.github.com/) (70 pairs) | 3.7% | 0.0% | 3.7% | — |
 | [SemiF](https://github.com/TheoLeeCJ/SemIf) | **100.0%** | 99.9% | 0.1% | **$0.208** |
 | [CLM-v0.1-8B](https://huggingface.co/Contrastive-LM/CLM-v0.1-8B) | **100.0%** | 100.0% | 0.0% | ~$1.432 |
 
+CodeQL scored 70 of the 1,311 public pairs; other models scored all pairs. Its [method decisions](codeql-comparison/) and [evaluation protocol](CODEQL.md) are available here.
+
 ### Private — 439 pairs
 
 | Model | Recall | Clean methods wrongly flagged | Recall − false-positive rate | Inference cost |
@@ -132,28 +138,6 @@ Inference costs cover scoring the method sides in each table. Jev costs are esti
 
 JevLike (192-byte input), Laya (512-token input), and Kev (packed-branch limit) could not score every full-context method. NanoJev was unavailable on Beam. They are excluded rather than ranked on partial results.
 
-## CodeQL comparison
-
-[CodeQL](https://codeql.github.com/) and Jev were evaluated on the same public method sides in a separate cohort. CodeQL analyzed full repository snapshots; Jev used its saved Perch inputs and recorded alert settings. A CodeQL finding counts when its primary location falls inside the labelled method. The matched set contains 52 bug pairs and 70 security pairs.
-
-### Bugs: 52 pairs
-
-| Tool | TP | FP | FN | Precision | Recall | F1 | False-positive rate |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| CodeQL | 0 | 0 | 21 | — (0 alerts) | 0.0% | 0.0% | 0.0% |
-| Jev | 6 | 8 | 15 | 42.9% | 28.6% | 34.3% | 9.6% |
-
-### Security: 70 pairs
-
-| Tool | TP | FP | FN | Precision | Recall | F1 | False-positive rate |
-| --- | ---: | ---: | ---: | ---: | ---: | ---: | ---: |
-| CodeQL | 1 | 0 | 26 | 100.0% (1 alert) | 3.7% | 7.1% | 0.0% |
-| Jev | 8 | 12 | 19 | 40.0% | 29.6% | 34.0% | 10.6% |
-
-TP is a finding on a labelled issue, FP is a finding on a labelled clean method, and FN is a missed issue. False-positive rate is FP divided by clean methods: 83 for bugs and 113 for security. CodeQL found an [OpenJPEG integer-overflow cast](https://github.com/uclouvain/openjpeg/commit/ef01f18dfc6780b776d0674ed3e7415c6ef54d24) in `opj_pi_create_decode` before the repair; Jev did not alert on that pair.
-
-The [CodeQL protocol](CODEQL.md), [runner](codeql_compare.py), [matched method decisions](codeql-comparison/), and [cohort list](codeql-cohort.json) are published here. Four selected bug pairs and three security pairs were excluded because a source snapshot could not be analyzed. CodeQL returns findings rather than probabilities, so these rows have no average-precision score or threshold curve.
-
 ## Files and reproduction
 
 - [`results-current.jsonl`](https://huggingface.co/datasets/perchscan/benchmark-results/blob/main/results-current.jsonl): current-pack aggregate results for public and private splits; no private pair data.

tradeoff.py

@@ -110,6 +110,8 @@ def money(row: dict) -> str:
 
 
 def model_link(model: str) -> str:
+    if model == "codeql":
+        return "[CodeQL](https://codeql.github.com/)"
     name, url = NAMES[model]
     return f"[{name}]({url})"
 
@@ -119,12 +121,14 @@ def percent(value: float) -> str:
 
 
 def results_table(rows: list[dict]) -> str:
-    ordered = sorted(rows, key=lambda row: (-operating_metrics(row)[2], ORDER.index(row["model_id"])))
+    ordered = sorted(rows, key=lambda row: (-operating_metrics(row)[2],
+                                             ORDER.index(row["model_id"]) if row["model_id"] in ORDER else len(ORDER)))
     metrics = {row["model_id"]: operating_metrics(row) for row in ordered}
-    best_recall = max(round(value[0] * 100, 1) for value in metrics.values())
-    best_false_positive_rate = min(round(value[1] * 100, 1) for value in metrics.values())
-    best_net_recall = max(round(value[2] * 100, 1) for value in metrics.values())
-    priced_costs = [round(row["inference_cost_usd"], 3) for row in ordered if row.get("inference_cost_usd") is not None]
+    full_rows = [row for row in ordered if row["model_id"] != "codeql"]
+    best_recall = max(round(metrics[row["model_id"]][0] * 100, 1) for row in full_rows)
+    best_false_positive_rate = min(round(metrics[row["model_id"]][1] * 100, 1) for row in full_rows)
+    best_net_recall = max(round(metrics[row["model_id"]][2] * 100, 1) for row in full_rows)
+    priced_costs = [round(row["inference_cost_usd"], 3) for row in full_rows if row.get("inference_cost_usd") is not None]
     best_priced_cost = min(priced_costs) if priced_costs else None
 
     def mark(value: str, winner: bool) -> str:
@@ -135,12 +139,16 @@ def results_table(rows: list[dict]) -> str:
     for row in ordered:
         recall, false_positive_rate, j = metrics[row["model_id"]]
         cost = row.get("inference_cost_usd")
+        is_codeql = row["model_id"] == "codeql"
+        name = model_link(row["model_id"])
+        if is_codeql:
+            name += f" ({row['benchmark_pairs']:,} pairs)"
         table.append("| " + " | ".join((
-            model_link(row["model_id"]),
-            mark(percent(recall), round(recall * 100, 1) == best_recall),
-            mark(percent(false_positive_rate), round(false_positive_rate * 100, 1) == best_false_positive_rate),
-            mark(percent(j), round(j * 100, 1) == best_net_recall),
-            mark(money(row), cost is not None and round(cost, 3) == best_priced_cost),
+            name,
+            mark(percent(recall), not is_codeql and round(recall * 100, 1) == best_recall),
+            mark(percent(false_positive_rate), not is_codeql and round(false_positive_rate * 100, 1) == best_false_positive_rate),
+            mark(percent(j), not is_codeql and round(j * 100, 1) == best_net_recall),
+            "—" if is_codeql else mark(money(row), cost is not None and round(cost, 3) == best_priced_cost),
         )) + " |")
     return "\n".join(table)
 
@@ -196,10 +204,11 @@ def svg(domain: str, curves: dict[str, tuple[list[tuple[int, int]], int, int]],
     output.write_text("\n".join(out) + "\n")
 
 
-def render_sections(results: list[dict], curves_by_domain: dict[str, dict], output_dir: Path) -> str:
+def render_sections(results: list[dict], curves_by_domain: dict[str, dict], output_dir: Path,
+                    codeql_results: dict) -> str:
     sections = ["## Reading the results", "",
                 "Each line shows how many issues a model finds and what percentage of clean methods it wrongly flags as its score cutoff changes. Higher and farther left is better.", "",
-                "The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best displayed value in each column; cost compares priced runs captured here.", ""]
+                "The tables use each run's recorded alert settings. A value of 20% under ‘Clean methods wrongly flagged’ means one in five clean methods received an alert. Models are ranked by recall minus that percentage. Bold marks the best full-set value in each column; cost compares priced runs captured here.", ""]
     for domain in ("bug", "security", "lint"):
         title = {"bug": "Bugs", "security": "Security", "lint": "Perch Lint Bench"}[domain]
         link = {"bug": "bug-pairs-public", "security": "security-pairs-public", "lint": "perch-lint-bench-public"}[domain]
@@ -207,13 +216,25 @@ def render_sections(results: list[dict], curves_by_domain: dict[str, dict], outp
         private = [r for r in results if r["domain"] == domain and r["track"] == "private"]
         if set(r["model_id"] for r in public) != set(ORDER) or set(r["model_id"] for r in private) != set(ORDER):
             raise ValueError(f"Unexpected models in {domain} results")
+        if domain in ("bug", "security"):
+            comparison = codeql_results[domain]
+            if comparison["pairs"] > public[0]["benchmark_pairs"]:
+                raise ValueError(f"CodeQL cohort exceeds public {domain} pairs")
+            counts = comparison["models"]["codeql"]
+            if sum(counts[key] for key in ("tp", "fp", "fn", "tn")) != 2 * comparison["pairs"]:
+                raise ValueError(f"CodeQL {domain} counts do not match its paired cohort")
+            public.append({"model_id": "codeql", "benchmark_pairs": comparison["pairs"],
+                           "confusion": counts})
         image = output_dir / f"{domain}-tradeoff.svg"
         svg(domain, curves_by_domain[domain], image)
         sections += [f"## {title}", "", f"[Public pairs](https://huggingface.co/datasets/perchscan/{link})", "",
                      f"![{title} recall versus false alerts](assets/{domain}-tradeoff.svg)", "",
                      f"### Public — {public[0]['benchmark_pairs']:,} pairs", "",
-                     results_table(public), "",
-                     f"### Private — {private[0]['benchmark_pairs']:,} pairs", "",
+                     results_table(public), ""]
+        if domain in ("bug", "security"):
+            sections += [f"CodeQL scored {comparison['pairs']:,} of the {public[0]['benchmark_pairs']:,} public pairs; other models scored all pairs. "
+                         "Its [method decisions](codeql-comparison/) and [evaluation protocol](CODEQL.md) are available here.", ""]
+        sections += [f"### Private — {private[0]['benchmark_pairs']:,} pairs", "",
                      results_table(private), ""]
     return "\n".join(sections)
 
@@ -224,6 +245,7 @@ def main() -> None:
     parser.add_argument("--check", action="store_true", help="Check generated card and SVGs without writing")
     args = parser.parse_args()
     results = lines(ROOT / "results-current.jsonl")
+    codeql_results = json.loads((ROOT / "codeql-comparison" / "results.json").read_text())
     curves_by_domain = {}
     for domain in ("bug", "security", "lint"):
         labels = labels_for(domain, dataset(domain, args.dataset_root))
@@ -247,13 +269,13 @@ def main() -> None:
         end += len(end_marker)
     if args.check:
         with TemporaryDirectory() as temporary:
-            content = render_sections(results, curves_by_domain, Path(temporary))
+            content = render_sections(results, curves_by_domain, Path(temporary), codeql_results)
             for domain in DATASET_URLS:
                 name = f"{domain}-tradeoff.svg"
                 if (Path(temporary) / name).read_bytes() != (ROOT / "assets" / name).read_bytes():
                     raise SystemExit(f"assets/{name} is not up to date; run python3 tradeoff.py")
     else:
-        content = render_sections(results, curves_by_domain, ROOT / "assets")
+        content = render_sections(results, curves_by_domain, ROOT / "assets", codeql_results)
     updated = (original[:start].rstrip("\n") + "\n\n" + start_marker + "\n\n" + content
                + "\n" + end_marker + "\n\n" + original[end:].lstrip("\n"))
     if args.check and original != updated: