Update README

README.md

@@ -86,7 +86,7 @@ Each entry is a JSON object with 7 fields:
       "rubric_number": 1,
       "rubric_detail": "...",     // specific grading criterion
       "rubric_weight": 5,         // positive = reward, negative = penalty
-      "rubric_label": "..."       // category (see below)
+      "rubric_tag": "..."         // category (see below)
     }
   ]
 }
@@ -104,22 +104,21 @@ Each entry is a JSON object with 7 fields:
 ## Quick Start
 
 ```python
-import json
+from datasets import load_dataset
 
-# Load a subset (test split)
-with open("natural_science/test.json") as f:
-    data = json.load(f)
+# Load a subset from Hugging Face (test split)
+ds = load_dataset("humanlaya-data-lab/OneMillion-Bench", "natural_science", split="test")
 
 # Filter English entries
-en_entries = [e for e in data if e["language"] == "en"]
+en_entries = ds.filter(lambda x: x["language"] == "en")
 
 # Iterate with rubrics
-for entry in en_entries[:1]:
+for entry in en_entries.select(range(1)):
     print(f"Topic: {' > '.join(entry['tags']['topics'])}")
     print(f"Question: {entry['question'][:200]}...")
     print(f"Rubrics ({len(entry['rubrics'])}):")
     for r in entry["rubrics"][:3]:
-        print(f"  [{r['rubric_weight']:+d}] {r['rubric_label']}: {r['rubric_detail'][:80]}...")
+        print(f"  [{r['rubric_weight']:+d}] {r['rubric_tag']}: {r['rubric_detail'][:80]}...")
 ```
 
 Example output:
@@ -135,21 +134,80 @@ Rubrics (18):
 
 ## Evaluation
 
-Score a model response by summing the weights of satisfied rubrics:
+### 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(response: str, rubrics: list, judge_fn) -> dict:
+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.
     """
-    total, earned = 0, 0
+    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:
+
+```python
+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",
+        messages=[
+            {"role": "system", "content": (
+                "You are a strict rubric grader. Determine whether the response "
+                "satisfies the following criterion. Reply ONLY 'YES' or 'NO'."
+            )},
+            {"role": "user", "content": (
+                f"### Criterion\n{rubric_detail}\n\n### Response\n{response}"
+            )},
+        ],
+        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_fn(response, r["rubric_detail"])
-        if met:
-            earned += r["rubric_weight"]
-        if r["rubric_weight"] > 0:
-            total += r["rubric_weight"]
-    return {"score": earned, "max_possible": total, "pct": earned / total if total else 0}
+        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%})")
 ```
 
 ## License