Datasets:
File size: 8,398 Bytes
1b62586 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 | #!/usr/bin/env python3
"""CPU-only whole-document chrF2 sidecar; never rewrites source artifacts."""
from __future__ import annotations
import argparse
import hashlib
import inspect
import json
import platform
import statistics
from collections import Counter, defaultdict
from pathlib import Path
from prepare_document_segale import read_jsonl, sha_text, write_jsonl
from summarize_document_segale import case_metadata
VERSION = "2.6.0"
PARAMETERS = dict(char_order=6, word_order=0, beta=2, lowercase=False,
whitespace=False, eps_smoothing=False)
def sha_file(path):
digest = hashlib.sha256()
with Path(path).open('rb') as stream:
for block in iter(lambda: stream.read(1024 * 1024), b''):
digest.update(block)
return digest.hexdigest()
def metric():
import sacrebleu
from sacrebleu.metrics import CHRF
if sacrebleu.__version__ != VERSION:
raise ValueError(f"Expected sacrebleu=={VERSION}, got {sacrebleu.__version__}")
return CHRF(**PARAMETERS)
def aggregate(rows):
scores = [r['chrf2'] for r in rows if r['chrf2'] is not None]
return {
'label': 'document macro chrF2', 'scale': [0, 100],
'value': statistics.fmean(scores) if scores else None,
'case_count': len(rows), 'scored_case_count': len(scores),
'macro_denominator': len(scores), 'failed_case_count': len(rows) - len(scores),
'empty_output_count': sum(r['empty_output'] is True and r['chrf2'] is not None for r in rows),
'generation_status_counts': dict(sorted(Counter(r['generation_status'] for r in rows).items())),
'eligibility_status_counts': dict(sorted(Counter(r['eligibility_status'] for r in rows).items())),
}
def score(cases, units, generations):
scorer = metric()
by_id = {r['case_id']: r for r in cases}
runs = {r['case_id']: r for r in generations}
if not cases or len(by_id) != len(cases) or len(runs) != len(generations):
raise ValueError('Empty cases or duplicate case_id')
if set(runs) - set(by_id):
raise ValueError('Unexpected generations')
grouped = defaultdict(list)
for unit in units:
if unit['case_id'] not in by_id:
raise ValueError('Unexpected alignment unit case_id')
grouped[unit['case_id']].append(unit)
result = []
for case in cases:
cid = case['case_id']
ordered = grouped[cid]
indices = [u['alignment_unit_index'] for u in ordered]
if any(type(i) is not int for i in indices) or len(set(indices)) != len(indices):
raise ValueError(f'Invalid or duplicate alignment_unit_index: {cid}')
ordered = sorted(ordered, key=lambda u: u['alignment_unit_index'])
if len(ordered) != case['alignment_unit_count']:
raise ValueError(f'Alignment unit count mismatch: {cid}')
ref = case['reference']
reconstructed = '\n'.join(u['reference'] for u in ordered)
if not isinstance(ref, str) or ref not in (reconstructed, reconstructed + '\n'):
raise ValueError(f'Reference reconstruction mismatch: {cid}')
run = runs.get(cid)
status = 'missing' if run is None else run.get('status', 'ok')
if not isinstance(status, str) or not status:
raise ValueError(f'Invalid generation status: {cid}')
mt = None if run is None else run.get('mt')
if status == 'ok':
if not isinstance(mt, str):
raise ValueError(f'Missing string mt: {cid}')
if sha_text(mt) != run.get('output_sha256'):
raise ValueError(f'Generation output hash mismatch: {cid}')
eligible = status == 'ok' and bool(ref.strip())
result.append({
'case_id': cid, 'metadata': case_metadata(case),
'generation_status': status,
'eligibility_status': ('scored_empty_output' if not mt.strip() else 'scored') if eligible
else (status if status != 'ok' else 'empty_reference'),
'chrf2': scorer.sentence_score(mt, [ref]).score if eligible else None,
'empty_output': not mt.strip() if isinstance(mt, str) else None,
'hypothesis_chars': len(mt) if isinstance(mt, str) else None,
'reference_chars': len(ref),
'hypothesis_sha256': sha_text(mt) if isinstance(mt, str) else None,
'reference_sha256': sha_text(ref),
'reference_unit_count': len(ordered),
'reference_unit_indices_sha256': sha_text(json.dumps(sorted(indices))),
})
# The signature needs a reference count even for an all-failed batch.
scorer.num_refs = 1
return result, str(scorer.get_signature())
def main():
parser = argparse.ArgumentParser(description=__doc__)
for name in ('data-manifest', 'cases', 'alignment-units', 'generations', 'output-dir'):
parser.add_argument('--' + name, type=Path, required=True)
parser.add_argument('--suite-id', required=True)
parser.add_argument('--system-key', required=True)
parser.add_argument('--group-by', action='append', default=[])
args = parser.parse_args()
if args.output_dir.exists() or args.output_dir.is_symlink():
raise ValueError('Output directory already exists; use a new independent directory')
if any((parent / 'COMPLETED.json').exists() for parent in args.output_dir.resolve().parents):
raise ValueError('Output must be outside completed runs; use an independent directory')
inputs = {name: {'path': str(getattr(args, name).resolve()),
'sha256': sha_file(getattr(args, name))}
for name in ('data_manifest', 'cases', 'alignment_units', 'generations')}
rows, signature = score(read_jsonl(args.cases), read_jsonl(args.alignment_units),
read_jsonl(args.generations))
groups = {}
for field in args.group_by:
buckets = defaultdict(list)
for row in rows:
value = row['metadata'].get(field)
if isinstance(value, (dict, list)):
raise ValueError(f'Grouping field {field} must be a scalar')
buckets['__missing__' if value is None else str(value)].append(row)
groups[field] = {key: aggregate(value) for key, value in sorted(buckets.items())}
import sacrebleu.metrics.chrf as implementation
import sacrebleu.metrics.helpers as helpers
import sacrebleu.metrics.base as base
summary = {
'schema_version': 'document-chrf2-v1', 'suite_id': args.suite_id,
'system_key': args.system_key, 'metric': {
'implementation': 'sacrebleu', 'version': VERSION, 'parameters': PARAMETERS,
'signature': signature, 'reference_count': 1,
'implementation_sha256': {m.__name__: sha_file(inspect.getfile(m))
for m in (implementation, helpers, base)},
'aggregation': 'document macro chrF2', 'scale': [0, 100],
},
'inputs': inputs, 'python_version': platform.python_version(),
'scorer_sha256': sha_file(__file__),
'reference_policy': 'cases.reference verbatim; verified against all canonical units sorted by alignment_unit_index joined with LF, allowing one final LF; no null-source filtering',
'hypothesis_policy': 'generations.mt verbatim; no truncation, deduplication or cleanup',
'eligibility_policy': 'status ok (including empty mt) and nonblank reference; failures/missing/empty reference retain null; macro denominator is scored_case_count',
'aggregate': aggregate(rows), 'groups': groups,
}
args.output_dir.mkdir(parents=True, exist_ok=False)
write_jsonl(args.output_dir / 'cases.jsonl', rows)
(args.output_dir / 'summary.json').write_text(json.dumps(summary, ensure_ascii=False, indent=2) + '\n')
manifest = {name: sha_file(args.output_dir / name) for name in ('cases.jsonl', 'summary.json')}
(args.output_dir / 'artifact-manifest.json').write_text(json.dumps(manifest, indent=2) + '\n')
(args.output_dir / 'COMPLETED.json').write_text(json.dumps({
'status': 'completed', 'scope': 'document-chrf2-sidecar-only',
'artifact_manifest_sha256': sha_file(args.output_dir / 'artifact-manifest.json'),
'aggregate': summary['aggregate'],
}, indent=2) + '\n')
print(json.dumps(summary['aggregate']))
if __name__ == '__main__':
main()
|