| """ |
| Text utilities for V4 multi-task evaluation. |
| Includes: WER/CER (from v3) + accuracy + F1 + simple BLEU. |
| """ |
| import re |
| import unicodedata |
| from collections import Counter |
|
|
| |
| |
| |
| def detect_language(text: str) -> str: |
| if not text: return "en" |
| cjk = sum(1 for c in text if '\u4e00' <= c <= '\u9fff') |
| return "zh" if cjk / max(len(text), 1) >= 0.3 else "en" |
|
|
| def normalize_text(text: str, lang: str = None) -> str: |
| if lang is None: lang = detect_language(text) |
| text = text.strip().lower() |
| text = unicodedata.normalize("NFKC", text) |
| text = re.sub(r'[^\w\s]', '', text) |
| if lang == "zh": |
| text = re.sub(r'\s+', '', text) |
| else: |
| text = re.sub(r'\s+', ' ', text).strip() |
| return text |
|
|
| |
| |
| |
| def _edit_distance(a, b): |
| m, n = len(a), len(b) |
| dp = list(range(n + 1)) |
| for i in range(1, m + 1): |
| prev, dp[0] = dp[0], i |
| for j in range(1, n + 1): |
| temp = dp[j] |
| dp[j] = prev if a[i-1] == b[j-1] else 1 + min(dp[j], dp[j-1], prev) |
| prev = temp |
| return dp[n] |
|
|
| def compute_wer(ref: str, hyp: str) -> float: |
| ref_w = normalize_text(ref, "en").split() |
| hyp_w = normalize_text(hyp, "en").split() |
| if not ref_w: return 0.0 if not hyp_w else float(len(hyp_w)) |
| return _edit_distance(ref_w, hyp_w) / len(ref_w) |
|
|
| def compute_cer(ref: str, hyp: str) -> float: |
| ref_c = list(normalize_text(ref, "zh")) |
| hyp_c = list(normalize_text(hyp, "zh")) |
| if not ref_c: return 0.0 if not hyp_c else float(len(hyp_c)) |
| return _edit_distance(ref_c, hyp_c) / len(ref_c) |
|
|
| |
| |
| |
| def compute_accuracy(refs: list, hyps: list) -> float: |
| if not refs: return 0.0 |
| correct = 0 |
| for r, h in zip(refs, hyps): |
| rn = normalize_text(r).strip() |
| hn = normalize_text(h).strip() |
| if rn == hn: correct += 1 |
| return correct / len(refs) |
|
|
| |
| |
| |
| def compute_label_f1(refs: list, hyps: list) -> float: |
| """Macro-averaged F1 over samples. Each ref/hyp is comma-separated labels.""" |
| if not refs: return 0.0 |
| total_f1 = 0.0 |
| for r, h in zip(refs, hyps): |
| ref_set = set(x.strip().lower() for x in r.split(",") if x.strip()) |
| hyp_set = set(x.strip().lower() for x in h.split(",") if x.strip()) |
| if not ref_set and not hyp_set: |
| total_f1 += 1.0; continue |
| if not ref_set or not hyp_set: |
| continue |
| tp = len(ref_set & hyp_set) |
| prec = tp / len(hyp_set) if hyp_set else 0 |
| rec = tp / len(ref_set) if ref_set else 0 |
| total_f1 += 2*prec*rec / (prec+rec) if (prec+rec) > 0 else 0 |
| return total_f1 / len(refs) |
|
|
| |
| |
| |
| def _ngrams(tokens, n): |
| return [tuple(tokens[i:i+n]) for i in range(len(tokens)-n+1)] |
|
|
| def compute_bleu4(refs: list, hyps: list) -> float: |
| if not refs: return 0.0 |
| total = 0.0 |
| for r, h in zip(refs, hyps): |
| ref_tok = normalize_text(r).split() or list(normalize_text(r)) |
| hyp_tok = normalize_text(h).split() or list(normalize_text(h)) |
| if not ref_tok or not hyp_tok: continue |
| bp = min(1.0, len(hyp_tok) / len(ref_tok)) if ref_tok else 0 |
| score = bp |
| for n in range(1, 5): |
| ref_ng = Counter(_ngrams(ref_tok, n)) |
| hyp_ng = Counter(_ngrams(hyp_tok, n)) |
| matches = sum((hyp_ng & ref_ng).values()) |
| total_hyp = max(sum(hyp_ng.values()), 1) |
| prec = matches / total_hyp |
| score *= max(prec, 1e-10) ** 0.25 |
| total += score |
| return total / len(refs) |
|
|
