Upload benchmark_eval.py with huggingface_hub

benchmark_eval.py

@@ -1,67 +1,55 @@
 import json
 import argparse
-import string
+from collections import Counter
 import warnings
 warnings.filterwarnings("ignore")
 
-def normalize_text(s):
-    return s.lower().translate(str.maketrans("", "", string.punctuation))
-
-def calculate_elr(gold_records, predictions):
+def entity_leakage_rate(gold_records, predictions):
     """
-    ELR: How many original entities leaked into the anonymized text.
-    Lower is better (0% is ideal).
+    Fraction of original entities appearing in predicted anonymized text 
+    (case-insensitive).
+    Returns leaked fraction (0.0 to 1.0) and counts.
     """
-    total_entities = 0
-    leaked_entities = 0
+    leaked = 0
+    total = 0
     
-    for gold, pred in zip(gold_records, predictions):
-        pred_text = normalize_text(pred.get("anonymized_text", ""))
-        entities = gold.get("entities", [])
-        
-        for ent in entities:
-            ent_text = normalize_text(ent["text"])
-            if not ent_text: continue
-            total_entities += 1
-            # Simple substring leak detection
-            if ent_text in pred_text:
-                leaked_entities += 1
+    for g, p in zip(gold_records, predictions):
+        pred_text = p.get("anonymized_text", "").lower()
+        for ent in g.get("entities", []):
+            total += 1
+            if ent["text"].lower() in pred_text:
+                leaked += 1
                 
-    elr = (leaked_entities / max(total_entities, 1)) * 100
-    return elr, leaked_entities, total_entities
+    elr = leaked / total if total > 0 else 0.0
+    return elr * 100, leaked, total
 
-def get_ngrams(text, n=3):
-    words = normalize_text(text).split()
-    ngrams = zip(*[words[i:] for i in range(n)])
-    return set([" ".join(ngram) for ngram in ngrams])
+def get_capitalized_ngrams(text, n=3):
+    """Extract n-grams where at least one token starts with uppercase."""
+    tokens = text.split()
+    ngrams = [tuple(tokens[i:i+n]) for i in range(len(tokens)-n+1)]
+    return [ng for ng in ngrams if any(t[0].isupper() for t in ng)]
 
-def calculate_crr(gold_records, predictions, n=3):
-    """
-    CRR: Contextual Re-identification Risk.
-    Percentage of n-grams that appear in both original and anonymized text.
-    Lower is better, but it has a trade-off with utility.
-    """
-    total_overlap = 0
-    total_ngrams = 0
+def crr3(gold_records, predictions):
+    """Capitalized 3-gram survival rate."""
+    survived = 0
+    total = 0
     
-    for gold, pred in zip(gold_records, predictions):
-        orig_text = gold.get("original_text", "")
-        pred_text = pred.get("anonymized_text", "")
+    for g, p in zip(gold_records, predictions):
+        orig_3grams = get_capitalized_ngrams(g.get("original_text", ""), n=3)
+        pred_text = p.get("anonymized_text", "").lower()
         
-        orig_ngrams = get_ngrams(orig_text, n)
-        pred_ngrams = get_ngrams(pred_text, n)
-        
-        overlap = set(orig_ngrams).intersection(set(pred_ngrams))
-        total_overlap += len(overlap)
-        total_ngrams += len(orig_ngrams)
-        
-    crr = (total_overlap / max(total_ngrams, 1)) * 100
-    return crr
+        for ng in orig_3grams:
+            total += 1
+            if " ".join(ng).lower() in pred_text:
+                survived += 1
+                
+    crr = survived / total if total > 0 else 0.0
+    return crr * 100
 
-def calculate_bertscore(gold_records, predictions):
+def calculate_bertscore(gold_records, predictions, model_type="distilbert-base-uncased"):
     """
     BERTScore F1 computes the semantic similarity of the texts.
-    Higher is better (100 is ideal).
+    Pinned model for reproducible benchmarking computations.
     """
     try:
         from bert_score import score
@@ -72,14 +60,15 @@ def calculate_bertscore(gold_records, predictions):
     refs = [g.get("original_text", "") for g in gold_records]
     cands = [p.get("anonymized_text", "") for p in predictions]
     
-    # Using small model for fast default evaluation
-    P, R, F1 = score(cands, refs, lang="en", verbose=False, model_type="distilbert-base-uncased")
+    P, R, F1 = score(cands, refs, lang="en", verbose=False, model_type=model_type)
     return F1.mean().item() * 100
 
 def main():
     parser = argparse.ArgumentParser(description="SAHA-AL Benchmark Evaluator")
     parser.add_argument("--gold", type=str, default="data/test.jsonl", help="Path to gold dataset (e.g. test.jsonl)")
     parser.add_argument("--pred", type=str, required=True, help="Path to predictions JSONL")
+    parser.add_argument("--bert-model", type=str, default="distilbert-base-uncased", 
+                        help="Model to use for BERTScore (e.g., microsoft/deberta-xlarge-mnli)")
     args = parser.parse_args()
     
     with open(args.gold, "r", encoding="utf-8") as f:
@@ -93,17 +82,17 @@ def main():
         
     print(f"Evaluating {len(predictions)} records...")
     
-    elr, leaked, total_ents = calculate_elr(gold_records, predictions)
-    crr3 = calculate_crr(gold_records, predictions, n=3)
-    bert_f1 = calculate_bertscore(gold_records, predictions)
+    elr, leaked, total_ents = entity_leakage_rate(gold_records, predictions)
+    crr_3 = crr3(gold_records, predictions)
+    bert_f1 = calculate_bertscore(gold_records, predictions, model_type=args.bert_model)
     
     print("\n" + "="*40)
     print(" SAHA-AL Benchmark Results")
     print("="*40)
     print(f" Entity Leakage Rate (ELR ↓): {elr:5.2f}% ({leaked}/{total_ents} leaked)")
-    print(f" Contextual Re-ID (CRR-3 ↓):  {crr3:5.2f}%")
+    print(f" Contextual Re-ID (CRR-3 ↓):  {crr_3:5.2f}%")
     if bert_f1 is not None:
-        print(f" BERTScore (F1 ↑):            {bert_f1:5.2f}")
+        print(f" BERTScore (F1 ↑):            {bert_f1:5.2f} (Model: {args.bert_model})")
     else:
         print(f" BERTScore (F1 ↑):            N/A")
     print("="*40)