Upload benchmark_eval.py with huggingface_hub

benchmark_eval.py

@@ -0,0 +1,112 @@
+import json
+import argparse
+import string
+import warnings
+warnings.filterwarnings("ignore")
+
+def normalize_text(s):
+    return s.lower().translate(str.maketrans("", "", string.punctuation))
+
+def calculate_elr(gold_records, predictions):
+    """
+    ELR: How many original entities leaked into the anonymized text.
+    Lower is better (0% is ideal).
+    """
+    total_entities = 0
+    leaked_entities = 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
+                
+    elr = (leaked_entities / max(total_entities, 1)) * 100
+    return elr, leaked_entities, total_entities
+
+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 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
+    
+    for gold, pred in zip(gold_records, predictions):
+        orig_text = gold.get("original_text", "")
+        pred_text = pred.get("anonymized_text", "")
+        
+        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
+
+def calculate_bertscore(gold_records, predictions):
+    """
+    BERTScore F1 computes the semantic similarity of the texts.
+    Higher is better (100 is ideal).
+    """
+    try:
+        from bert_score import score
+    except ImportError:
+        print("`bert_score` not installed. Skipping. Install with: pip install bert_score")
+        return None
+        
+    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")
+    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")
+    args = parser.parse_args()
+    
+    with open(args.gold, "r", encoding="utf-8") as f:
+        gold_records = [json.loads(line) for line in f]
+        
+    with open(args.pred, "r", encoding="utf-8") as f:
+        predictions = [json.loads(line) for line in f]
+        
+    if len(gold_records) != len(predictions):
+        raise ValueError(f"Mismatch in number of records! Gold: {len(gold_records)}, Pred: {len(predictions)}")
+        
+    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)
+    
+    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}%")
+    if bert_f1 is not None:
+        print(f" BERTScore (F1 ↑):            {bert_f1:5.2f}")
+    else:
+        print(f" BERTScore (F1 ↑):            N/A")
+    print("="*40)
+
+if __name__ == "__main__":
+    main()