Upload 4 files

sample-evaluation-scripts/README.md

@@ -0,0 +1,189 @@
+# Evaluation scripts
+
+Three scripts for scoring model responses against the golden answers. Two are
+deterministic and need no model, no API key and no network; the third uses an
+LLM judge.
+
+| Script | Protocol | Needs a model? |
+|---|---|---|
+| `exact_substring.py` | Golden answer must appear as one contiguous substring | No |
+| `word_overlap.py` | Every golden word must appear, in any order | No |
+| `llm_judge.py` | A judge model decides semantic equivalence | Yes |
+
+Only `pandas` is required for the deterministic scripts.
+
+## Input format
+
+Each script takes one CSV: a language file from this dataset with a `response`
+column added.
+
+| column | source |
+|---|---|
+| `question` | dataset |
+| `answer` | dataset (golden answer) |
+| `Domain` | dataset |
+| `response` | your model's raw output |
+
+```bash
+python exact_substring.py --responses my_model_english.csv
+python word_overlap.py    --responses my_model_english.csv --out scored.csv
+python llm_judge.py       --responses my_model_english.csv --limit 50
+```
+
+Each prints per-domain and combined accuracy. Combined is the micro-average
+over all pooled questions, which is identical to weighting each domain by its
+size. `--out` writes per-question verdicts.
+
+`llm_judge.py` ships with `call_model()` as a stub — implement it for your
+backend (the docstring sketches a local `transformers` pipeline and an
+OpenAI-compatible endpoint) and use temperature 0, or scores will not
+reproduce.
+
+---
+
+## 1. Exact substring
+
+The entire logic:
+
+```python
+is_correct = answer.lower() in response.lower()
+```
+
+The golden answer must appear as **one contiguous run of characters**.
+Lowercasing is the only normalisation — no trimming, no punctuation handling,
+no tokenisation, no word boundaries.
+
+| Golden | Response | Verdict | Why |
+|---|---|---|---|
+| `Ruru Jataka` | `The answer is the Ruru Jataka, depicted at Bharhut.` | correct | surrounding prose is irrelevant |
+| `ruru jataka` | `RURU JATAKA` | correct | case-insensitive |
+| `गंगा` | `गंगा नदी` | correct | works for Devanagari |
+| `Ruru Jataka` | `Jataka Ruru` | wrong | order matters |
+| `Narmada valley` | `the Narmada river valley` | wrong | must be contiguous |
+| `Delhi ` (trailing space) | `Delhi` | wrong | golden answer is not stripped |
+| `amalak` | `Amalaka` | correct | matches inside a longer word |
+| `No` | `There is **no** such temple` | correct | false positive: no word boundary |
+| `Delhi` | `Delhi is not the answer; it's Mumbai` | correct | false positive: mention is not assertion |
+
+**What it measures:** whether the model reproduced the golden phrase verbatim,
+including word order and internal spacing. A phrase-fidelity test.
+
+**Failure modes.** False negatives dominate and are mostly cosmetic —
+reordering, an inserted qualifier, stray whitespace in the golden answer — so
+the score is a lower bound. False positives are rarer but more damaging:
+nothing anchors the match to a word boundary or to what the model actually
+asserted, so short golden answers can match inside unrelated words, and a
+response that names the golden answer only to reject it still scores correct.
+
+---
+
+## 2. Word overlap
+
+Both sides are lowercased, split on whitespace, stripped of leading and
+trailing punctuation (`delhi.` → `delhi`), and compared as **sets**:
+
+```python
+is_correct = set(golden_words) <= set(response_words)
+```
+
+All golden words must appear, in any order, anywhere in the response. Extra
+words are free — a subset test, not equality. The output CSV also carries
+`matching_words` and `total_golden_words`, giving partial credit that the
+binary verdict hides.
+
+| Golden | Response | Verdict | Count | Why |
+|---|---|---|---|---|
+| `Narmada valley` | `valley Narmada` | correct | 2/2 | order is irrelevant |
+| `Narmada valley` | `the Narmada river valley in India` | correct | 2/2 | insertions are free |
+| `Narmada valley` | `Narmada` | wrong | 1/2 | every golden word required |
+| `1947 to 1947` | `it was 1947` | wrong | 1/2 | duplicates collapse to a set |
+| `Amalaka` | `amalak` | wrong | 0/1 | whole-token match, no stemming |
+| `Chola ideals` | `Chola and Hoysala ideals` | correct | 2/2 | false positive: different claim |
+
+**What it measures:** whether the response contains the golden vocabulary,
+disregarding order, position, and anything said between the words. A
+content-word recall test.
+
+**Failure modes.** Extra words are never penalised, so a verbose answer that
+happens to include every golden word passes — this is the main false-positive
+channel and it grows with response length. The comparison is a set rather than
+a multiset, so repetition is never checked. There is no stemming, which matters
+a great deal for Indic morphology.
+
+---
+
+## How the two differ
+
+**Neither is a looser version of the other.** They disagree in both directions,
+because they relax and tighten different axes.
+
+| Axis | Exact substring | Word overlap |
+|---|---|---|
+| Word order | must match | irrelevant |
+| Inserted words inside the phrase | fails | passes |
+| Extra words elsewhere | passes | passes |
+| Sub-word match (`amalak` / `Amalaka`) | passes | fails |
+| Whitespace noise in golden answer | fails | tolerated |
+| Unit of comparison | character run | whole token |
+| Partial credit reported | no | yes |
+
+### Real disagreements
+
+From an actual run (Sarvam 30B on the Art domain, 233 rows — exact 59/233,
+word overlap 56/233). The near-identical totals hide rows that flip in
+*opposite* directions.
+
+Exact passes, overlap fails — morphological variants where the golden string
+sits inside a longer word:
+
+| Golden | Response |
+|---|---|
+| `amalak` | `Amalaka` |
+| `deul` | `Deula` |
+| `mithun` | `Mithuna` |
+| `Dipankar` | `Dipankara Buddha` |
+| `scroll painting` | `Scroll paintings` |
+
+Overlap passes, exact fails — all golden words present, but not contiguous:
+
+| Golden | Response |
+|---|---|
+| `Narmada valley` | `Narmada River valley` |
+| `Chola ideals` | `Chola and Hoysala ideals` |
+
+Every one of the first group is arguably a correct answer that exact substring
+catches and word overlap misses on a technicality. In the second group,
+`Narmada River valley` is correct and `Chola and Hoysala ideals` is not — word
+overlap gets one right and one wrong for the same reason.
+
+### Reading the two scores together
+
+Because the metrics are near-orthogonal, the pair is more informative than
+either alone:
+
+- **Both pass** → high confidence the answer is right.
+- **Both fail** → high confidence it is wrong, or phrased very differently.
+- **Exact only** → almost always an inflection difference; usually a correct
+  answer under-counted by word overlap.
+- **Overlap only** → the golden words are all there but rearranged. Could be a
+  correct paraphrase or a genuinely different claim. This bucket needs human or
+  judge review.
+
+Treat both numbers as **lower bounds**. Neither understands paraphrase,
+synonymy, negation, or numeric equivalence. For that, use `llm_judge.py`.
+
+---
+
+## Caveats for both deterministic scripts
+
+1. **An empty golden answer scores correct** in both (`"" in x` is `True`, and
+   an empty set is a subset of anything). Both scripts warn on stderr if the
+   input contains one.
+2. **Golden answers are not stripped**, so trailing whitespace breaks exact
+   substring outright.
+3. **No Unicode normalisation.** `.lower()` is a no-op for Indic scripts, and
+   NFC versus NFD forms of the same word compare unequal. Tokenising is fine,
+   but equality is fragile for Indic text — consider normalising to NFC before
+   scoring if your responses come from mixed sources.
+4. **Blank responses score incorrect**, and are counted separately in the
+   output so that missing data is distinguishable from wrong answers.

sample-evaluation-scripts/exact_substring.py

@@ -0,0 +1,87 @@
+"""
+Exact-substring scoring.
+
+A response is correct if the whole golden answer appears in it as one
+contiguous, case-insensitive substring. No tokenisation, no word boundaries,
+no stemming.
+
+    is_correct = answer.lower() in response.lower()
+
+See scripts/README.md for what this measures, where it gives false positives
+and false negatives, and how it compares with word_overlap.py.
+
+Usage:
+    python exact_substring.py --responses my_model_english.csv
+    python exact_substring.py --responses my_model_english.csv --out scored.csv
+
+Input CSV: the language file from this dataset (columns `question`, `answer`,
+`Domain`) with a `response` column added holding the model's raw output.
+"""
+
+import argparse
+import sys
+
+import pandas as pd
+
+REQUIRED = ["question", "answer", "Domain", "response"]
+
+
+def is_correct(answer, response):
+    """The golden answer must appear as one contiguous run of characters."""
+    return str(answer).lower() in str(response).lower()
+
+
+def report(df, label):
+    """Print per-domain and combined accuracy."""
+    per_domain = df.groupby("Domain")["is_correct"].agg(["sum", "size"])
+
+    print(f"\n{label}\n")
+    print(f"{'Domain':<20} {'Correct':>8} {'Total':>7} {'Accuracy':>10}")
+    print("-" * 48)
+    for domain, row in per_domain.iterrows():
+        acc = row["sum"] / row["size"] * 100
+        print(f"{domain:<20} {int(row['sum']):>8} {int(row['size']):>7} {acc:>9.2f}%")
+
+    correct, total = int(df["is_correct"].sum()), len(df)
+    blank = int((df["response"].fillna("").astype(str).str.strip() == "").sum())
+    print("-" * 48)
+    print(f"{'COMBINED':<20} {correct:>8} {total:>7} {correct / total * 100:>9.2f}%")
+    print("\nCombined is the micro-average over all pooled questions, which is")
+    print("identical to weighting each domain by its size.")
+    if blank:
+        print(f"Blank responses: {blank} (scored incorrect)")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--responses", required=True,
+                    help="CSV with columns: question, answer, Domain, response")
+    ap.add_argument("--out", help="Optional path to write per-question verdicts")
+    args = ap.parse_args()
+
+    df = pd.read_csv(args.responses)
+
+    missing = [c for c in REQUIRED if c not in df.columns]
+    if missing:
+        sys.exit(f"Error: {args.responses} is missing column(s): {', '.join(missing)}\n"
+                 f"Found: {', '.join(df.columns)}")
+
+    # A blank answer would match every response vacuously; flag rather than
+    # silently inflate the score.
+    blank_answers = int((df["answer"].fillna("").astype(str).str.strip() == "").sum())
+    if blank_answers:
+        print(f"Warning: {blank_answers} row(s) have an empty golden answer. "
+              f"These match any response and will score correct.", file=sys.stderr)
+
+    df["is_correct"] = [is_correct(a, r) for a, r in zip(df["answer"], df["response"])]
+
+    report(df, f"Exact substring — {args.responses}")
+
+    if args.out:
+        df.to_csv(args.out, index=False)
+        print(f"\nPer-question verdicts written to {args.out}")
+
+
+if __name__ == "__main__":
+    main()

sample-evaluation-scripts/llm_judge.py

@@ -0,0 +1,191 @@
+"""
+LLM-as-a-judge scoring.
+
+A judge model decides whether the response is semantically equivalent to the
+golden answer, and returns a TRUE/FALSE verdict with a short justification.
+Unlike the two deterministic scripts, this accepts paraphrases, alternate
+spellings, and transliteration variants.
+
+The judge used for the reported results was Gemma 3 12B. This script is
+provider-agnostic: implement `call_model()` for whatever backend you use, then
+run as normal.
+
+Usage:
+    python llm_judge.py --responses my_model_english.csv
+    python llm_judge.py --responses my_model_english.csv --limit 50 --out scored.csv
+
+Input CSV: the language file from this dataset (columns `question`, `answer`,
+`Domain`) with a `response` column added holding the model's raw output.
+"""
+
+import argparse
+import json
+import re
+import sys
+
+import pandas as pd
+
+REQUIRED = ["question", "answer", "Domain", "response"]
+
+JUDGE_PROMPT = """You are an evaluation judge. Your task is to determine if the given answer matches the ground truth answer for the given question.
+
+## Input
+Question: {question}
+Ground Truth Answer: {ground_truth_answer}
+Given Answer: {llm_answer}
+
+## Instructions
+1. Compare the "Given Answer" against the "Ground Truth Answer" in the context of the question.
+2. Correct if semantically equivalent (same meaning / same entity or fact).
+3. Minor phrasing, formatting, or extra detail is acceptable if the core answer is correct.
+4. Clearly wrong, meaning-changing, or unrelated answers are incorrect.
+5. Answers in a different language than the question and ground truth are incorrect.
+
+## Output Format
+Return ONLY a JSON object (no additional text, no markdown fences):
+{{"is_correct": true, "reasoning": "brief explanation"}}"""
+
+
+# ---------------------------------------------------------------------------
+# IMPLEMENT THIS
+# ---------------------------------------------------------------------------
+
+def call_model(prompt: str) -> str:
+    """
+    Send `prompt` to the judge model and return its raw text response.
+
+    Replace the body with a call to whichever backend you use. Two sketches:
+
+    Local, via transformers:
+
+        from transformers import pipeline
+        pipe = pipeline("text-generation", model="google/gemma-3-12b-it",
+                        device_map="auto", max_new_tokens=200)
+        return pipe(prompt)[0]["generated_text"][len(prompt):]
+
+    Any OpenAI-compatible endpoint (including local vLLM or Ollama):
+
+        from openai import OpenAI
+        client = OpenAI(base_url="http://localhost:8000/v1", api_key="...")
+        out = client.chat.completions.create(
+            model="google/gemma-3-12b-it",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0,
+        )
+        return out.choices[0].message.content
+
+    Use a temperature of 0 or the closest equivalent: the judge should be as
+    close to deterministic as the backend allows, or scores will not reproduce.
+    """
+    raise NotImplementedError(
+        "call_model() is a stub. Implement it for your backend before running "
+        "this script. See the docstring above for two examples."
+    )
+
+
+# ---------------------------------------------------------------------------
+
+def parse_verdict(raw: str):
+    """
+    Pull {"is_correct": bool, "reasoning": str} out of the judge's output.
+
+    Models sometimes wrap JSON in markdown fences or add a sentence around it
+    despite the instruction, so fall back to locating the first JSON object.
+    Returns (is_correct, reasoning); is_correct is None if parsing failed.
+    """
+    text = raw.strip()
+    text = re.sub(r"^```(?:json)?\s*|\s*```$", "", text, flags=re.MULTILINE).strip()
+
+    try:
+        obj = json.loads(text)
+    except json.JSONDecodeError:
+        match = re.search(r"\{.*?\}", text, flags=re.DOTALL)
+        if not match:
+            return None, f"unparseable judge output: {raw[:120]}"
+        try:
+            obj = json.loads(match.group(0))
+        except json.JSONDecodeError:
+            return None, f"unparseable judge output: {raw[:120]}"
+
+    verdict = obj.get("is_correct")
+    if isinstance(verdict, str):
+        verdict = verdict.strip().lower() in ("true", "yes", "1")
+    if not isinstance(verdict, bool):
+        return None, f"missing or non-boolean is_correct: {raw[:120]}"
+
+    return verdict, str(obj.get("reasoning", ""))
+
+
+def judge_row(question, answer, response):
+    prompt = JUDGE_PROMPT.format(question=question,
+                                 ground_truth_answer=answer,
+                                 llm_answer=response)
+    return parse_verdict(call_model(prompt))
+
+
+def report(df, label):
+    """Print per-domain and combined accuracy."""
+    scored = df[df["is_correct"].notna()].copy()
+    scored["is_correct"] = scored["is_correct"].astype(bool)
+    per_domain = scored.groupby("Domain")["is_correct"].agg(["sum", "size"])
+
+    print(f"\n{label}\n")
+    print(f"{'Domain':<20} {'Correct':>8} {'Total':>7} {'Accuracy':>10}")
+    print("-" * 48)
+    for domain, row in per_domain.iterrows():
+        acc = row["sum"] / row["size"] * 100
+        print(f"{domain:<20} {int(row['sum']):>8} {int(row['size']):>7} {acc:>9.2f}%")
+
+    correct, total = int(scored["is_correct"].sum()), len(scored)
+    print("-" * 48)
+    if total:
+        print(f"{'COMBINED':<20} {correct:>8} {total:>7} {correct / total * 100:>9.2f}%")
+    print("\nCombined is the micro-average over all pooled questions, which is")
+    print("identical to weighting each domain by its size.")
+
+    failed = len(df) - total
+    if failed:
+        print(f"\nWarning: {failed} row(s) produced unparseable judge output and are")
+        print("excluded from the accuracy above. Inspect them before reporting a score.")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--responses", required=True,
+                    help="CSV with columns: question, answer, Domain, response")
+    ap.add_argument("--out", help="Optional path to write per-question verdicts")
+    ap.add_argument("--limit", type=int,
+                    help="Judge only the first N rows (useful for a smoke test)")
+    args = ap.parse_args()
+
+    df = pd.read_csv(args.responses)
+
+    missing = [c for c in REQUIRED if c not in df.columns]
+    if missing:
+        sys.exit(f"Error: {args.responses} is missing column(s): {', '.join(missing)}\n"
+                 f"Found: {', '.join(df.columns)}")
+
+    if args.limit:
+        df = df.head(args.limit).copy()
+
+    verdicts, reasons = [], []
+    for i, row in enumerate(df.itertuples(index=False), start=1):
+        verdict, reason = judge_row(row.question, row.answer, row.response)
+        verdicts.append(verdict)
+        reasons.append(reason)
+        if i % 50 == 0 or i == len(df):
+            print(f"  judged {i}/{len(df)}", file=sys.stderr)
+
+    df["is_correct"] = verdicts
+    df["judge_reasoning"] = reasons
+
+    report(df, f"LLM as a judge — {args.responses}")
+
+    if args.out:
+        df.to_csv(args.out, index=False)
+        print(f"\nPer-question verdicts written to {args.out}")
+
+
+if __name__ == "__main__":
+    main()

sample-evaluation-scripts/word_overlap.py

@@ -0,0 +1,119 @@
+"""
+Word-overlap scoring.
+
+A response is correct if every word of the golden answer appears somewhere in
+it, in any order. Both sides are lowercased, split on whitespace, stripped of
+leading and trailing punctuation, and compared as sets.
+
+    is_correct = set(golden_words) <= set(response_words)
+
+Extra words in the response are free: this is a subset test, not equality.
+Because the comparison is set-based, repeated words in the golden answer
+collapse to one.
+
+See scripts/README.md for what this measures, where it gives false positives
+and false negatives, and how it compares with exact_substring.py.
+
+Usage:
+    python word_overlap.py --responses my_model_english.csv
+    python word_overlap.py --responses my_model_english.csv --out scored.csv
+
+Input CSV: the language file from this dataset (columns `question`, `answer`,
+`Domain`) with a `response` column added holding the model's raw output.
+"""
+
+import argparse
+import sys
+
+import pandas as pd
+
+REQUIRED = ["question", "answer", "Domain", "response"]
+
+# Stripped from the edges of each token. Includes the Devanagari danda and
+# double danda alongside ASCII punctuation.
+PUNCTUATION = " \t\n\r.,;:!?\"'()[]{}<>/\\|`~@#$%^&*-_=+।॥"
+
+
+def words(text):
+    """Lowercase, split on whitespace, strip edge punctuation, drop empties."""
+    tokens = (t.strip(PUNCTUATION) for t in str(text).lower().split())
+    return {t for t in tokens if t}
+
+
+def score_row(answer, response):
+    """Return (is_correct, matching_word_count, golden_word_count)."""
+    golden, given = words(answer), words(response)
+    matching = golden & given
+    # An empty golden answer is vacuously satisfied.
+    return len(matching) == len(golden), len(matching), len(golden)
+
+
+def report(df, label):
+    """Print per-domain and combined accuracy, plus word recall."""
+    per_domain = df.groupby("Domain").agg(
+        correct=("is_correct", "sum"),
+        total=("is_correct", "size"),
+        matched=("matching_words", "sum"),
+        golden=("total_golden_words", "sum"),
+    )
+
+    print(f"\n{label}\n")
+    print(f"{'Domain':<20} {'Correct':>8} {'Total':>7} {'Accuracy':>10} {'Word recall':>13}")
+    print("-" * 62)
+    for domain, row in per_domain.iterrows():
+        acc = row["correct"] / row["total"] * 100
+        recall = row["matched"] / row["golden"] * 100 if row["golden"] else 0.0
+        print(f"{domain:<20} {int(row['correct']):>8} {int(row['total']):>7} "
+              f"{acc:>9.2f}% {recall:>12.2f}%")
+
+    correct, total = int(df["is_correct"].sum()), len(df)
+    matched = int(df["matching_words"].sum())
+    golden = int(df["total_golden_words"].sum())
+    recall = matched / golden * 100 if golden else 0.0
+    blank = int((df["response"].fillna("").astype(str).str.strip() == "").sum())
+
+    print("-" * 62)
+    print(f"{'COMBINED':<20} {correct:>8} {total:>7} "
+          f"{correct / total * 100:>9.2f}% {recall:>12.2f}%")
+    print("\nCombined is the micro-average over all pooled questions, which is")
+    print("identical to weighting each domain by its size.")
+    print(f"Word recall: {matched}/{golden} golden words found. This is partial")
+    print("credit that the binary accuracy above hides.")
+    if blank:
+        print(f"Blank responses: {blank} (scored incorrect)")
+
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--responses", required=True,
+                    help="CSV with columns: question, answer, Domain, response")
+    ap.add_argument("--out", help="Optional path to write per-question verdicts")
+    args = ap.parse_args()
+
+    df = pd.read_csv(args.responses)
+
+    missing = [c for c in REQUIRED if c not in df.columns]
+    if missing:
+        sys.exit(f"Error: {args.responses} is missing column(s): {', '.join(missing)}\n"
+                 f"Found: {', '.join(df.columns)}")
+
+    blank_answers = int((df["answer"].fillna("").astype(str).str.strip() == "").sum())
+    if blank_answers:
+        print(f"Warning: {blank_answers} row(s) have an empty golden answer. "
+              f"These are vacuously satisfied and will score correct.", file=sys.stderr)
+
+    scored = [score_row(a, r) for a, r in zip(df["answer"], df["response"])]
+    df["is_correct"] = [s[0] for s in scored]
+    df["matching_words"] = [s[1] for s in scored]
+    df["total_golden_words"] = [s[2] for s in scored]
+
+    report(df, f"Word overlap — {args.responses}")
+
+    if args.out:
+        df.to_csv(args.out, index=False)
+        print(f"\nPer-question verdicts written to {args.out}")
+
+
+if __name__ == "__main__":
+    main()