Update README

README.md

@@ -134,80 +134,51 @@ Rubrics (18):
 
 ## Evaluation
 
-### Scoring a single response
-
-Each rubric carries a signed weight: positive weights are points earned when the criterion is met, negative weights are penalties applied when violated. Sum the weights of all satisfied rubrics and normalize against the maximum possible (positive-only) score:
-
-```python
-def score_entry(response: str, rubrics: list, judge_fn) -> dict:
-    """
-    judge_fn(response, rubric_detail) -> bool
-        Returns True if the response satisfies the rubric criterion.
-    """
-    max_possible = sum(r["rubric_weight"] for r in rubrics if r["rubric_weight"] > 0)
-    earned = sum(r["rubric_weight"] for r in rubrics if judge_fn(response, r["rubric_detail"]))
-    return {"earned": earned, "max_possible": max_possible, "pct": earned / max_possible if max_possible else 0}
-```
-
-### End-to-end rubric-based eval
-
-Below is a complete example that loads the benchmark from Hugging Face, queries a model, and scores every entry with an LLM-as-judge:
+Each rubric carries a signed weight: positive weights are points earned when the criterion is met, negative weights are penalties applied when violated. The judge evaluates **all rubrics in a single call** and returns a JSON array of binary (yes/no) verdicts.
 
 ```python
+# pip install datasets openai
+import json, re
 from datasets import load_dataset
 from openai import OpenAI
 
-SUBSETS = [
-    "economics_and_finance",
-    "healthcare_and_medicine",
-    "industry",
-    "law",
-    "natural_science",
-]
-
 client = OpenAI()  # or any OpenAI-compatible client
 
-def get_model_response(question: str, system_prompt: str = "") -> str:
-    messages = []
-    if system_prompt:
-        messages.append({"role": "system", "content": system_prompt})
-    messages.append({"role": "user", "content": question})
-    return client.chat.completions.create(
-        model="gpt-4o", messages=messages
-    ).choices[0].message.content
-
-def judge_rubric(response: str, rubric_detail: str) -> bool:
-    verdict = client.chat.completions.create(
-        model="gpt-4o",
+def evaluate(question, response, rubrics, judge_model="gpt-4o-mini"):
+    """Judge all rubrics in one call, return weighted score."""
+    rubrics_text = "\n\n".join(
+        f"**Rubric {r['rubric_number']}** (weight {r['rubric_weight']:+d})\n{r['rubric_detail']}"
+        for r in rubrics
+    )
+    judge_out = client.chat.completions.create(
+        model=judge_model, temperature=0,
         messages=[
-            {"role": "system", "content": (
-                "You are a strict rubric grader. Determine whether the response "
-                "satisfies the following criterion. Reply ONLY 'YES' or 'NO'."
-            )},
+            {"role": "system", "content": "You are a strict rubric grader. Reply ONLY with a JSON array."},
             {"role": "user", "content": (
-                f"### Criterion\n{rubric_detail}\n\n### Response\n{response}"
+                f"For each rubric, output {{\"rubric_id\": <number>, \"status\": \"yes\" or \"no\"}}.\n\n"
+                f"## Question\n{question}\n\n## Response\n{response}\n\n## Rubrics\n{rubrics_text}"
             )},
         ],
-        temperature=0,
     ).choices[0].message.content
-    return verdict.strip().upper().startswith("YES")
-
-def score_entry(response: str, rubrics: list) -> dict:
-    max_possible = sum(r["rubric_weight"] for r in rubrics if r["rubric_weight"] > 0)
-    results = []
-    for r in rubrics:
-        met = judge_rubric(response, r["rubric_detail"])
-        results.append({**r, "met": met})
-    earned = sum(r["rubric_weight"] for r in results if r["met"])
-    return {"earned": earned, "max_possible": max_possible, "pct": earned / max_possible if max_possible else 0, "details": results}
-
-# --- Run ---
-for subset in SUBSETS:
-    ds = load_dataset("humanlaya-data-lab/OneMillion-Bench", subset, split="test")
-    for entry in ds:
-        response = get_model_response(entry["question"], entry["system_prompt"])
-        result = score_entry(response, entry["rubrics"])
-        print(f"[{subset}] {entry['id']}  score={result['earned']}/{result['max_possible']} ({result['pct']:.1%})")
+
+    # Parse JSON (handles ```json fences and trailing commas)
+    m = re.search(r"```(?:json)?\s*(\[[\s\S]*?\])\s*```", judge_out)
+    verdicts = json.loads(re.sub(r",\s*([}\]])", r"\1", m.group(1) if m else judge_out))
+    hits = {v["rubric_id"] for v in verdicts if str(v.get("status", "")).lower() in ("yes", "是")}
+
+    max_pos = sum(r["rubric_weight"] for r in rubrics if r["rubric_weight"] > 0)
+    earned = sum(r["rubric_weight"] for r in rubrics if r["rubric_number"] in hits)
+    return {"earned": earned, "max": max_pos, "pct": earned / max_pos if max_pos else 0}
+
+# --- Run on one subset ---
+ds = load_dataset("humanlaya-data-lab/OneMillion-Bench", "natural_science", split="test")
+for entry in ds.select(range(3)):
+    response = client.chat.completions.create(
+        model="gpt-4o-mini",
+        messages=[{"role": "user", "content": entry["question"]}],
+    ).choices[0].message.content
+    result = evaluate(entry["question"], response, entry["rubrics"])
+    print(f"{' > '.join(entry['tags']['topics'])}  →  {result['earned']}/{result['max']} ({result['pct']:.1%})")
 ```
 
 ## License