evaluate.py

#!/usr/bin/env python3
"""Evaluate saved predictions without GPU model loading or reference leakage."""
import argparse
from collections import defaultdict
import hashlib
import json
import os
from pathlib import Path
import re
import statistics
import time
import syllable_calculation as sc
from judge_prompt import JUDGE_PROMPT, LANG_CN


def read_jsonl(path):
    with Path(path).open(encoding='utf-8') as f:
        return [json.loads(line) for line in f if line.strip()]


def parse_score(text):
    text = text.strip()
    if text.startswith('[') and text.endswith(']'):
        text = text[1:-1].strip()
    return float(text) if re.fullmatch(r'(?:0(?:\.0+)?|0\.50*|1(?:\.0+)?)', text) else None


def load_predictions(path, valid_ids):
    result = {}
    for row in read_jsonl(path):
        key = row['case_id']
        if key not in valid_ids or key in result:
            raise ValueError('Unknown or duplicate case_id: ' + key)
        if not isinstance(row.get('prediction'), str):
            raise ValueError('prediction must be a string: ' + key)
        result[key] = row['prediction']
    return result


def syllable_metrics(hyp, meta):
    target = meta['target_syllables']
    if target <= 0:
        raise ValueError('Non-positive target')
    n = sc.cal_syllable_count(hyp, lang=meta['target_language']) if hyp.strip() else 0
    diff, dev = abs(n - target), abs(n - target) / target
    reward = 1.0 if diff <= 1 or dev <= .05 else 0.0 if dev >= .5 else (.5 - dev) / .45
    if not hyp.strip():
        reward = 0.0
    return dict(hyp_syllables=n, abs_diff=diff, dev=dev, signed_dev=(n-target)/target,
        syllable_reward=reward, hit_pm1=int(diff<=1), hit_strict5=int(dev<=.05), hit_10=int(dev<=.1), hit_20=int(dev<=.2))


def aggregate(rows):
    quality = [r['quality'] for r in rows if r['quality'] is not None]
    return dict(cases=len(rows), quality_cases=len(quality),
        quality=statistics.mean(quality) if quality else None,
        score=statistics.mean(r['score'] for r in rows) if rows and all(r['score'] is not None for r in rows) else None,
        **{k: statistics.mean(r[k] for r in rows) if rows else None for k in
           ['syllable_reward','hit_pm1','hit_strict5','hit_10','hit_20','dev']})


def controllability(rows):
    groups = defaultdict(dict)
    for r in rows:
        groups[(r['uuid'],r['target_language'])][r['target_kind']] = r
    slopes, short, long = [], [], []
    for g in groups.values():
        if set(g) != {'short','natural','long'}:
            continue
        xs = [r['target_syllables'] for r in g.values()]
        ys = [r['hyp_syllables'] for r in g.values()]
        mx, my = statistics.mean(xs), statistics.mean(ys)
        denom = sum((x-mx)**2 for x in xs)
        if denom:
            slopes.append(sum((x-mx)*(y-my) for x,y in zip(xs,ys))/denom)
        if all(r['quality'] is not None for r in g.values()):
            short.append(g['short']['quality']-g['natural']['quality'])
            long.append(g['long']['quality']-g['natural']['quality'])
    return dict(slope=statistics.mean(slopes) if slopes else None, complete_groups=len(slopes),
        q_gap_short=statistics.mean(short) if short else None, q_gap_long=statistics.mean(long) if long else None)


def main():
    ap = argparse.ArgumentParser(description=__doc__)
    ap.add_argument('--data-file',type=Path,default=Path(__file__).parent/'sandglass_bench.jsonl')
    ap.add_argument('--predictions',type=Path,required=True)
    ap.add_argument('--output-dir',type=Path,required=True)
    ap.add_argument('--skip-judge',action='store_true')
    ap.add_argument('--limit',type=int,default=0)
    ap.add_argument('--judge-model',default='gemini-2.5-flash')
    ap.add_argument('--judge-api-base',default=os.environ.get('JUDGE_API_BASE',''))
    args = ap.parse_args()
    if args.limit < 0:
        ap.error('--limit must be nonnegative')
    rows = read_jsonl(args.data_file)
    if args.limit:
        rows = rows[:args.limit]
    if not rows or len({r['case_id'] for r in rows}) != len(rows):
        ap.error('Empty dataset or duplicate case IDs')
    preds = load_predictions(args.predictions,{r['case_id'] for r in rows})
    args.output_dir.mkdir(parents=True,exist_ok=True)
    config = dict(model=args.judge_model,api_base=args.judge_api_base,reasoning_effort='low')
    cache_file = args.output_dir/'judge_cache.jsonl'
    cache = {r['key']:r['response'] for r in read_jsonl(cache_file)} if cache_file.exists() else {}
    client = None
    if not args.skip_judge:
        if not args.judge_api_base or not os.environ.get('JUDGE_API_KEY'):
            ap.error('Set JUDGE_API_BASE and JUDGE_API_KEY, or use --skip-judge')
        from openai import OpenAI
        client = OpenAI(base_url=args.judge_api_base,api_key=os.environ['JUDGE_API_KEY'],timeout=120,max_retries=0)
    scored = []
    for row in rows:
        m, hyp = row['metadata'], preds.get(row['case_id'],'')
        quality = None if args.skip_judge else 0.0
        if client and hyp.strip():
            prompt = JUDGE_PROMPT.format(target_lang=LANG_CN[m['target_language']],duration=m['duration'],
                target_syllables=m['target_syllables'],summary=m.get('summary',''),up_context=m.get('up_context',''),
                down_context=m.get('down_context',''),origin_text=m['source'],translate_text=hyp,
                lang_notes='\n- 注意: 日语存在敬体/简体，打分时请忽略这一问题。' if m['target_language']=='ja' else '',
                bad_case='- 你需要特别注意中文汉字直出现象，若不是日语本土表达，算严重错误。' if m['target_language']=='ja' else '')
            key = hashlib.sha256(json.dumps(dict(config=config,prompt=prompt),ensure_ascii=False,sort_keys=True).encode()).hexdigest()
            response = cache.get(key)
            if response is None:
                for attempt in range(3):
                    try:
                        res = client.chat.completions.create(model=args.judge_model,messages=[dict(role='user',content=prompt)],reasoning_effort='low')
                        response = res.choices[0].message.content or ''
                        if parse_score(response) is None:
                            raise ValueError('Judge must return exactly 0, 0.5 or 1')
                        break
                    except Exception:
                        response = None
                        if attempt == 2:
                            raise
                        time.sleep(2**attempt)
                with cache_file.open('a',encoding='utf-8') as f:
                    f.write(json.dumps(dict(key=key,response=response),ensure_ascii=False)+'\n')
                cache[key] = response
            quality = parse_score(response)
            if quality is None:
                raise ValueError('Invalid cached Judge score')
        metrics = syllable_metrics(hyp,m)
        scored.append(dict(case_id=row['case_id'],uuid=m['uuid'],target_language=m['target_language'],
            target_kind=m['target_kind'],target_syllables=m['target_syllables'],prediction=hyp,**metrics,
            quality=quality,score=(metrics['syllable_reward']+quality)/2 if quality is not None else None))
    summary = dict(formal_result=not args.limit and not args.skip_judge,subset=bool(args.limit),skip_judge=args.skip_judge,
        data_sha256=hashlib.sha256(args.data_file.read_bytes()).hexdigest(),judge=config if client else None,
        prediction_coverage=sum(bool(r['prediction'].strip()) for r in scored)/len(scored),
        overall=aggregate(scored),controllability=controllability(scored))
    for field in ['target_language','target_kind']:
        summary[field] = {k:aggregate([r for r in scored if r[field]==k]) for k in sorted({r[field] for r in scored})}
    (args.output_dir/'scores.jsonl').write_text(''.join(json.dumps(r,ensure_ascii=False)+'\n' for r in scored),encoding='utf-8')
    (args.output_dir/'summary.json').write_text(json.dumps(summary,ensure_ascii=False,indent=2)+'\n',encoding='utf-8')
    print(json.dumps(summary['overall'],ensure_ascii=False))

if __name__ == '__main__':
    main()