#!/usr/bin/env python3 """Score SEGALE-aligned windows with COMET and aggregate document diagnostics. This adapter follows SEGALE's document aggregation rule: every null alignment receives a COMET score of 0 and remains in document and corpus means. It runs only reference-based COMET; unavailable optional metrics are represented by an explicit status and a JSON null value rather than a synthetic numeric score. """ from __future__ import annotations import argparse import hashlib import importlib.metadata import json import platform import re import statistics import time from collections import Counter, defaultdict from pathlib import Path from typing import Iterable import torch # unbabel-comet 2.2.7 can select an unusable MPS DataLoader path on macOS even # when CPU inference is requested. CUDA inference is unaffected by this guard. torch.backends.mps.is_available = lambda: False from comet import download_model, load_from_checkpoint # noqa: E402 POSITION_BUCKETS = ("beginning", "middle", "end") def read_jsonl(path: Path) -> list[dict]: with path.open(encoding="utf-8") as stream: return [json.loads(line) for line in stream if line.strip()] def sha256_file(path: Path) -> str: digest = hashlib.sha256() with path.open("rb") as stream: for block in iter(lambda: stream.read(1024 * 1024), b""): digest.update(block) return digest.hexdigest() def classify_window(row: dict) -> str: src = row.get("src", "") ref = row.get("ref", "") hypothesis = row.get("tgt", "") if src and ref and hypothesis: return "aligned" if src and ref and not hypothesis: return "under_translation_null" if not src and not ref and hypothesis: return "over_translation_null" if src and not ref: return "canonical_null_reference" raise ValueError( f"Unexpected empty-field pattern in {row.get('doc_id')} segment {row.get('seg_id')}: " f"src={bool(src)} ref={bool(ref)} tgt={bool(hypothesis)}" ) def mean(values: Iterable[float | None]) -> float | None: present = [value for value in values if value is not None] return statistics.fmean(present) if present else None def ratio(numerator: int, denominator: int) -> float | None: return numerator / denominator if denominator else None def segment_sort_key(row: dict) -> tuple[int, int | str]: value = row.get("seg_id", 0) try: return (0, int(value)) except (TypeError, ValueError): return (1, str(value)) def position_bucket(fraction: float) -> str: if fraction < 1 / 3: return "beginning" if fraction < 2 / 3: return "middle" return "end" def assign_source_positions( doc_rows: list[dict], source_lines: list[str] | None = None ) -> None: """Assign source spans and positions, preferably against original sentences. VecAlign joins a multi-sentence source window with spaces. Those inserted spaces are not present in the original BWB character coordinates, so probe and position calculations first recover each window's ordered source sentence span when the manifest carries the original source lines. """ if source_lines is not None: if not isinstance(source_lines, list) or not all( isinstance(line, str) for line in source_lines ): raise ValueError("evaluation_source_lines must be a list of strings") sentence_cursor = 0 char_prefix = [0] for line in source_lines: char_prefix.append(char_prefix[-1] + len(line)) for row in doc_rows: source = row.get("src", "") if not source: sentence_start = sentence_cursor sentence_end = sentence_cursor else: target = normalized_exact_text(source) sentence_start = sentence_cursor sentence_end = None for candidate_end in range(sentence_cursor + 1, len(source_lines) + 1): candidates = ( " ".join(source_lines[sentence_cursor:candidate_end]), "".join(source_lines[sentence_cursor:candidate_end]), ) if any(normalized_exact_text(value) == target for value in candidates): sentence_end = candidate_end break if sentence_end is None: raise ValueError( "Cannot map aligned source window to original source lines: " f"cursor={sentence_cursor} src={source[:160]!r}" ) sentence_cursor = sentence_end row["source_sentence_start"] = sentence_start row["source_sentence_end"] = sentence_end row["source_char_start"] = char_prefix[sentence_start] row["source_char_end"] = char_prefix[sentence_end] if sentence_cursor != len(source_lines): raise ValueError( "Aligned source does not cover all original source lines: " f"covered={sentence_cursor} expected={len(source_lines)}" ) source_total = char_prefix[-1] else: source_total = sum(len(row.get("src", "")) for row in doc_rows) source_cursor = 0 for index, row in enumerate(doc_rows): if source_lines is None: source_chars = len(row.get("src", "")) start = source_cursor end = start + source_chars row["source_char_start"] = start row["source_char_end"] = end else: start = row["source_char_start"] end = row["source_char_end"] source_chars = end - start if source_total: fraction = (start + source_chars / 2) / source_total else: # A pathological all-empty-source document still gets deterministic # buckets, while runtime metadata records the normal basis. fraction = (index + 0.5) / len(doc_rows) row["source_position_fraction"] = fraction row["position_bucket"] = position_bucket(fraction) source_cursor = end def normalized_exact_text(text: str) -> str: return re.sub(r"\s+", " ", text).strip() def duplicate_stats(texts: Iterable[str], *, example_limit: int = 20) -> dict: normalized = [normalized_exact_text(text) for text in texts] normalized = [text for text in normalized if text] counts = Counter(normalized) duplicate_occurrences = sum(count - 1 for count in counts.values() if count > 1) examples = [text for text, count in counts.items() if count > 1] return { "items": len(normalized), "duplicate_occurrences": duplicate_occurrences, "duplicate_ratio": ratio(duplicate_occurrences, len(normalized)), "duplicate_unique_items": len(examples), "duplicate_examples": examples[:example_limit], "duplicate_examples_truncated": len(examples) > example_limit, } def row_totals(rows: list[dict]) -> dict[str, int]: return { "source_chars": sum(len(row.get("src", "")) for row in rows), "reference_chars": sum(len(row.get("ref", "")) for row in rows), "hypothesis_chars": sum(len(row.get("tgt", "")) for row in rows), } def length_fields(totals: dict[str, int]) -> dict: source_chars = totals["source_chars"] reference_chars = totals["reference_chars"] hypothesis_chars = totals["hypothesis_chars"] return { **totals, "reference_source_char_ratio": ratio(reference_chars, source_chars), "hypothesis_source_char_ratio": ratio(hypothesis_chars, source_chars), "hypothesis_reference_char_ratio": ratio(hypothesis_chars, reference_chars), } def null_text_statistics(rows: list[dict]) -> dict: """Reporting only: character mass in null blocks, never scoring weights.""" evaluable = [row for row in rows if row['alignment_type'] != 'canonical_null_reference'] source_chars = sum(len(row.get('src', '')) for row in evaluable) hypothesis_chars = sum(len(row.get('tgt', '')) for row in evaluable) under_chars = sum(len(row['src']) for row in evaluable if row['alignment_type'] == 'under_translation_null') over_chars = sum(len(row['tgt']) for row in evaluable if row['alignment_type'] == 'over_translation_null') return { 'evaluable_source_chars': source_chars, 'evaluable_hypothesis_chars': hypothesis_chars, 'under_null_source_chars': under_chars, 'over_null_hypothesis_chars': over_chars, 'null_source_char_ratio': ratio(under_chars, source_chars), 'null_hypothesis_char_ratio': ratio(over_chars, hypothesis_chars), } def summarize_bucket(rows: list[dict]) -> dict: evaluable_rows = [row for row in rows if row["alignment_type"] != "canonical_null_reference"] null_rows = [row for row in evaluable_rows if row["alignment_type"] != "aligned"] under_nulls = sum( row["alignment_type"] == "under_translation_null" for row in rows ) over_nulls = sum( row["alignment_type"] == "over_translation_null" for row in rows ) totals = row_totals(rows) return { "windows": len(rows), "evaluable_windows": len(evaluable_rows), "canonical_null_reference_windows": len(rows) - len(evaluable_rows), "comet": mean(row["comet"] for row in evaluable_rows), "na_ratio": ratio(len(null_rows), len(evaluable_rows)), "under_translation_nulls": under_nulls, "over_translation_nulls": over_nulls, "under_translation_na_ratio": ratio(under_nulls, len(evaluable_rows)), "over_translation_na_ratio": ratio(over_nulls, len(evaluable_rows)), **length_fields(totals), } def summarize_probe(doc_rows: list[dict], probe: dict | None) -> dict | None: if not probe: return None sentence_start = probe.get("source_sentence_start") sentence_end = probe.get("source_sentence_end") if isinstance(sentence_start, int) and isinstance(sentence_end, int): if not 0 <= sentence_start < sentence_end: raise ValueError(f"Invalid probe source sentence span: {probe}") mapped_total = max( (row.get("source_sentence_end", 0) for row in doc_rows), default=0 ) if sentence_end > mapped_total: raise ValueError( "Probe sentence span ends after aligned source: " f"end={sentence_end} source_total={mapped_total}" ) selected = [] boundary_crossings = 0 for row in doc_rows: row_start = row.get("source_sentence_start") row_end = row.get("source_sentence_end") if not isinstance(row_start, int) or not isinstance(row_end, int): raise ValueError("Probe sentence selection requires mapped source windows") if row_end > row_start: midpoint = (row_start + row_end) / 2 include = sentence_start <= midpoint < sentence_end boundary_crossings += int( row_start < sentence_start < row_end or row_start < sentence_end < row_end ) else: include = sentence_start <= row_start < sentence_end or ( row_start == sentence_end == mapped_total ) if include: selected.append(row) if not selected: raise ValueError(f"Probe selected no aligned windows: {probe}") return { "probe_id": probe.get("probe_id"), "source_sha256": probe.get("source_sha256"), "source_char_start": probe.get("source_char_start"), "source_char_end": probe.get("source_char_end"), "source_sentence_start": sentence_start, "source_sentence_end": sentence_end, "selection_rule": ( "mapped_source_sentence_window_midpoint; source-empty window at " "sentence insertion cursor, including document-end cursor" ), "boundary_crossing_windows": boundary_crossings, **summarize_bucket(selected), } start = probe.get("source_char_start") end = probe.get("source_char_end") if not isinstance(start, int) or not isinstance(end, int) or not 0 <= start < end: raise ValueError(f"Invalid probe source span: {probe}") source_total = sum(len(row.get("src", "")) for row in doc_rows) if end > source_total: raise ValueError( f"Probe span ends after aligned source: end={end} source_total={source_total}" ) selected = [] boundary_crossings = 0 for row in doc_rows: row_start = row["source_char_start"] row_end = row["source_char_end"] if row_end > row_start: midpoint = (row_start + row_end) / 2 include = start <= midpoint < end boundary_crossings += int( row_start < start < row_end or row_start < end < row_end ) else: # Source-empty over-translation windows are attached to the source # cursor at which the aligner inserted them. include = start <= row_start < end or row_start == end == source_total if include: selected.append(row) if not selected: raise ValueError(f"Probe selected no aligned windows: {probe}") return { "probe_id": probe.get("probe_id"), "source_sha256": probe.get("source_sha256"), "source_char_start": start, "source_char_end": end, "selection_rule": ( "source_window_midpoint; source-empty window at insertion cursor, " "including document-end cursor" ), "boundary_crossing_windows": boundary_crossings, **summarize_bucket(selected), } def summarize_case( doc_id: str, doc_rows: list[dict], case_metadata: dict, sentence_segmenter=None, hypothesis_sentences: list[str] | None = None, ) -> dict: evaluable_rows = [row for row in doc_rows if row["alignment_type"] != "canonical_null_reference"] null_rows = [row for row in evaluable_rows if row["alignment_type"] != "aligned"] aligned_rows = [row for row in doc_rows if row["alignment_type"] == "aligned"] position = { bucket: summarize_bucket( [row for row in doc_rows if row["position_bucket"] == bucket] ) for bucket in POSITION_BUCKETS } if hypothesis_sentences is None: hypothesis_text = "\n".join( row.get("tgt", "") for row in doc_rows if row.get("tgt", "") ) hypothesis_sentences = [ normalized_exact_text(sentence.text) for sentence in sentence_segmenter(hypothesis_text).sents if sentence.text.strip() ] sentence_duplicates = duplicate_stats(hypothesis_sentences) window_duplicates = duplicate_stats(row.get("tgt", "") for row in doc_rows) totals = row_totals(doc_rows) benchmark_metadata = case_metadata.get("benchmark_metadata") probe = ( benchmark_metadata.get("probe") if isinstance(benchmark_metadata, dict) else None ) return { "case_id": case_metadata.get("case_id", doc_id), "segale_doc_id": doc_id, "operation": case_metadata.get("operation", "none"), "affected_segments": case_metadata.get("affected_segments", []), "benchmark_metadata": benchmark_metadata, "metadata": case_metadata.get("metadata", {}), "windows": len(doc_rows), "evaluable_windows": len(evaluable_rows), "canonical_null_reference_windows": len(doc_rows) - len(evaluable_rows), "aligned_windows": len(aligned_rows), "null_windows": len(null_rows), "under_translation_nulls": sum( row["alignment_type"] == "under_translation_null" for row in doc_rows ), "over_translation_nulls": sum( row["alignment_type"] == "over_translation_null" for row in doc_rows ), "na_ratio": ratio(len(null_rows), len(evaluable_rows)), "comet": mean(row["comet"] for row in evaluable_rows), "comet_aligned_only": mean(row["comet"] for row in aligned_rows), "diagnostics": null_text_statistics(doc_rows), **length_fields(totals), "hypothesis_sentences": sentence_duplicates["items"], "exact_duplicate_sentence_occurrences": sentence_duplicates[ "duplicate_occurrences" ], "exact_duplicate_sentence_ratio": sentence_duplicates["duplicate_ratio"], "exact_duplicate_sentence_unique_items": sentence_duplicates[ "duplicate_unique_items" ], "exact_duplicate_sentence_examples": sentence_duplicates["duplicate_examples"], "exact_duplicate_sentence_examples_truncated": sentence_duplicates[ "duplicate_examples_truncated" ], "nonempty_hypothesis_windows": window_duplicates["items"], "exact_duplicate_window_occurrences": window_duplicates["duplicate_occurrences"], "exact_duplicate_window_ratio": window_duplicates["duplicate_ratio"], "exact_duplicate_window_unique_items": window_duplicates[ "duplicate_unique_items" ], "exact_duplicate_window_examples": window_duplicates["duplicate_examples"], "exact_duplicate_window_examples_truncated": window_duplicates[ "duplicate_examples_truncated" ], "position_buckets": position, "probe": summarize_probe(doc_rows, probe), } def aggregate_cases(cases: list[dict], rows: list[dict]) -> dict: totals = row_totals(rows) evaluable_rows = [row for row in rows if row["alignment_type"] != "canonical_null_reference"] null_rows = [row for row in evaluable_rows if row["alignment_type"] != "aligned"] aligned_rows = [row for row in rows if row["alignment_type"] == "aligned"] macro = { "comet": mean(case["comet"] for case in cases), "comet_aligned_only": mean(case["comet_aligned_only"] for case in cases), "na_ratio": mean(case["na_ratio"] for case in cases), "reference_source_char_ratio": mean( case["reference_source_char_ratio"] for case in cases ), "hypothesis_source_char_ratio": mean( case["hypothesis_source_char_ratio"] for case in cases ), "hypothesis_reference_char_ratio": mean( case["hypothesis_reference_char_ratio"] for case in cases ), "exact_duplicate_sentence_ratio": mean( case["exact_duplicate_sentence_ratio"] for case in cases ), "exact_duplicate_window_ratio": mean( case["exact_duplicate_window_ratio"] for case in cases ), "position_buckets": { bucket: { "comet": mean( case["position_buckets"][bucket]["comet"] for case in cases ), "na_ratio": mean( case["position_buckets"][bucket]["na_ratio"] for case in cases ), "hypothesis_reference_char_ratio": mean( case["position_buckets"][bucket][ "hypothesis_reference_char_ratio" ] for case in cases ), } for bucket in POSITION_BUCKETS }, } sentence_count = sum(case["hypothesis_sentences"] for case in cases) sentence_duplicates = sum( case["exact_duplicate_sentence_occurrences"] for case in cases ) window_count = sum(case["nonempty_hypothesis_windows"] for case in cases) window_duplicates = sum( case["exact_duplicate_window_occurrences"] for case in cases ) weighted = { "comet": mean(row["comet"] for row in evaluable_rows), "comet_aligned_only": mean(row["comet"] for row in aligned_rows), "na_ratio": ratio(len(null_rows), len(evaluable_rows)), **length_fields(totals), "hypothesis_sentences": sentence_count, "exact_duplicate_sentence_occurrences": sentence_duplicates, "exact_duplicate_sentence_ratio": ratio(sentence_duplicates, sentence_count), "nonempty_hypothesis_windows": window_count, "exact_duplicate_window_occurrences": window_duplicates, "exact_duplicate_window_ratio": ratio(window_duplicates, window_count), "position_buckets": { bucket: summarize_bucket( [row for row in rows if row["position_bucket"] == bucket] ) for bucket in POSITION_BUCKETS }, } return { "documents": len(cases), "windows": len(rows), "evaluable_windows": len(evaluable_rows), "canonical_null_reference_windows": len(rows) - len(evaluable_rows), "aligned_windows": len(aligned_rows), "null_windows": len(null_rows), "macro": macro, "weighted": weighted, } def package_versions() -> dict[str, str | None]: versions = {} for package in ("segale", "spacy", "transformers", "unbabel-comet", "numpy"): try: versions[package] = importlib.metadata.version(package) except importlib.metadata.PackageNotFoundError: versions[package] = None return versions def metric_statuses(aggregate: dict) -> dict: not_requested = { "status": "not_requested", "availability": "not_run_in_this_experiment", "value": None, } unavailable = { "status": "unavailable", "availability": "unavailable_in_comet_only_evaluator", "value": None, } return { "comet": { "status": "ok", "value": { "macro": aggregate["macro"]["comet"], "weighted": aggregate["weighted"]["comet"], }, "null_alignment_score": 0.0, }, "comet_qe": dict(not_requested), "metricx": dict(unavailable), "metricx_qe": dict(unavailable), } def main() -> None: parser = argparse.ArgumentParser() parser.add_argument("--input-file", type=Path, required=True) parser.add_argument("--manifest", type=Path, required=True) parser.add_argument("--output-dir", type=Path, required=True) parser.add_argument("--model", default="Unbabel/wmt22-comet-da") parser.add_argument( "--model-checkpoint", type=Path, help="Local COMET .ckpt; when set, skip model download/resolution", ) parser.add_argument( "--model-checkpoint-sha256", help="Preverified checkpoint SHA-256 supplied by the runner", ) parser.add_argument("--batch-size", type=int, default=4) parser.add_argument( "--gpus", type=int, default=0, help="Number of CUDA GPUs passed to COMET (0 keeps CPU behavior)", ) parser.add_argument("--spacy-model", default="es_core_news_sm") parser.add_argument( "--target-sentences", type=Path, help="Optional target sentence sidecar emitted by the aligner", ) parser.add_argument("--encoder-model", type=Path, help="Pinned local XLM-R tokenizer/config") args = parser.parse_args() if args.gpus < 0: parser.error("--gpus must be non-negative") if args.batch_size < 1: parser.error("--batch-size must be positive") if args.model_checkpoint_sha256 and not re.fullmatch( r"[a-f0-9]{64}", args.model_checkpoint_sha256 ): parser.error("--model-checkpoint-sha256 must be a lowercase SHA-256") total_started = time.perf_counter() rows = read_jsonl(args.input_file) if not rows: raise ValueError(f"No rows in {args.input_file}") grouped: dict[str, list[dict]] = defaultdict(list) for row in rows: if "doc_id" not in row: raise ValueError(f"Aligned row has no doc_id: {row}") row["alignment_type"] = classify_window(row) grouped[str(row["doc_id"])].append(row) for doc_rows in grouped.values(): doc_rows.sort(key=segment_sort_key) manifest = json.loads(args.manifest.read_text(encoding="utf-8")) manifest_cases = manifest.get("cases", []) manifest_case_ids = [str(case["case_id"]) for case in manifest_cases] if len(manifest_case_ids) != len(set(manifest_case_ids)): raise ValueError("Manifest contains duplicate case_id values") manifest_doc_ids = [str(case.get("segale_doc_id", case["case_id"])) for case in manifest_cases] if len(manifest_doc_ids) != len(set(manifest_doc_ids)): raise ValueError("Manifest contains duplicate SEGALE document IDs") aligned_doc_ids = set(grouped) expected_doc_ids = set(manifest_doc_ids) if aligned_doc_ids != expected_doc_ids: raise ValueError( "Aligned/manifest document coverage mismatch: " f"missing={sorted(expected_doc_ids - aligned_doc_ids)} " f"unexpected={sorted(aligned_doc_ids - expected_doc_ids)}" ) for doc_id, doc_rows in grouped.items(): segment_ids = [] for row in doc_rows: if "seg_id" not in row: raise ValueError(f"Aligned row has no seg_id in document {doc_id}") segment_ids.append(str(row["seg_id"])) if len(segment_ids) != len(set(segment_ids)): raise ValueError(f"Aligned document {doc_id} contains duplicate seg_id values") cases_by_id = { str(case.get("segale_doc_id", case["case_id"])): case for case in manifest_cases } mapped_source_documents = 0 for doc_id, doc_rows in grouped.items(): source_lines = cases_by_id[doc_id].get("evaluation_source_lines") mapped_source_documents += isinstance(source_lines, list) assign_source_positions(doc_rows, source_lines) rows = [row for doc_rows in grouped.values() for row in doc_rows] scorable = [] scorable_rows = [] for row in rows: if row["alignment_type"] == "aligned": scorable.append({"src": row["src"], "ref": row["ref"], "mt": row["tgt"]}) scorable_rows.append(row) elif row["alignment_type"] in {"under_translation_null", "over_translation_null"}: row["comet"] = 0.0 else: row["comet"] = None model_path: Path | None = None if args.model_checkpoint: # Preserve snapshot symlinks: COMET locates hparams.yaml relative to # the checkpoint path rather than its resolved blob-store target. model_path = args.model_checkpoint.expanduser().absolute() if not model_path.is_file(): raise FileNotFoundError(f"COMET checkpoint does not exist: {model_path}") if scorable: if model_path is None: model_path = Path(download_model(args.model)) model_load_started = time.perf_counter() # Portable release: use the pinned local encoder config/tokenizer. if args.encoder_model: from comet.models import RegressionMetric model = RegressionMetric.load_from_checkpoint(str(model_path), map_location=torch.device("cpu"), strict=False, load_pretrained_weights=False, pretrained_model=str(args.encoder_model), local_files_only=True) else: model = load_from_checkpoint(str(model_path)) model_load_seconds = time.perf_counter() - model_load_started prediction_started = time.perf_counter() prediction = model.predict( scorable, batch_size=args.batch_size, gpus=args.gpus, num_workers=0, ) prediction_seconds = time.perf_counter() - prediction_started scores = prediction.scores if hasattr(prediction, "scores") else prediction["scores"] for row, score in zip(scorable_rows, scores, strict=True): row["comet"] = float(score) else: model_load_seconds = 0.0 prediction_seconds = 0.0 aggregation_started = time.perf_counter() target_sentences_by_doc = None if args.target_sentences: target_rows = read_jsonl(args.target_sentences) target_sentences_by_doc = {} for row in target_rows: doc_id = str(row.get("doc_id")) sentences = row.get("sentences") if doc_id in target_sentences_by_doc: raise ValueError(f"Duplicate target sentence document: {doc_id}") if not isinstance(sentences, list) or not all( isinstance(sentence, str) for sentence in sentences ): raise ValueError(f"Invalid target sentence document: {doc_id}") target_sentences_by_doc[doc_id] = sentences if set(target_sentences_by_doc) != expected_doc_ids: raise ValueError("Target sentence/manifest document coverage mismatch") for doc_id, sentences in target_sentences_by_doc.items(): sidecar_text = normalized_exact_text(" ".join(sentences)) aligned_text = normalized_exact_text( " ".join( row.get("tgt", "") for row in grouped[doc_id] if row.get("tgt", "") ) ) if sidecar_text != aligned_text: raise ValueError( f"Target sentence/aligned text mismatch: {doc_id}" ) sentence_segmenter = None else: import spacy sentence_segmenter = spacy.load(args.spacy_model) summaries = [ summarize_case( doc_id, doc_rows, cases_by_id.get(doc_id, {}), sentence_segmenter, target_sentences_by_doc.get(doc_id) if target_sentences_by_doc is not None else None, ) for doc_id, doc_rows in grouped.items() ] manifest_order = {str(case["case_id"]): index for index, case in enumerate(manifest_cases)} summaries.sort( key=lambda item: ( manifest_order.get(item["case_id"], len(manifest_order)), item["case_id"], ) ) aggregate = aggregate_cases(summaries, rows) aggregation_seconds = time.perf_counter() - aggregation_started args.output_dir.mkdir(parents=True, exist_ok=True) per_window_path = args.output_dir / "per_window.jsonl" with per_window_path.open("w", encoding="utf-8") as stream: for row in rows: stream.write(json.dumps(row, ensure_ascii=False) + "\n") if mapped_source_documents == len(grouped): position_basis = ( "window_midpoint_in_original_source_characters_after_ordered_sentence_mapping" ) elif mapped_source_documents == 0: position_basis = "window_midpoint_in_cumulative_aligned_source_characters" else: position_basis = ( "per-document: original source characters when manifest sentences are " "available, otherwise cumulative aligned source characters" ) runtime = { "platform": platform.platform(), "machine": platform.machine(), "python": platform.python_version(), "torch": torch.__version__, "packages": package_versions(), "comet_model": args.model, "comet_checkpoint": str(model_path) if model_path else None, "comet_checkpoint_sha256": ( args.model_checkpoint_sha256 if model_path and args.model_checkpoint_sha256 else sha256_file(model_path) if model_path else None ), "comet_device": "cuda" if args.gpus else "cpu", "comet_gpus": args.gpus, "comet_batch_size": args.batch_size, "sentence_segmenter": args.spacy_model, "position_bucket_basis": position_basis, "source_sentence_mapped_documents": mapped_source_documents, "target_sentences": ( str(args.target_sentences.absolute()) if args.target_sentences else None ), "target_sentences_sha256": ( sha256_file(args.target_sentences) if args.target_sentences else None ), "target_sentence_source": ( "alignment_sidecar" if args.target_sentences else "scorer_spacy" ), "probe_window_basis": ( "mapped source-sentence-window midpoint; source-empty over-translation " "window at sentence insertion cursor including document end; legacy " "character fallback" ), "exact_duplicate_basis": "case-sensitive_text_after_whitespace_normalization", "aligned_input": str(args.input_file.absolute()), "aligned_input_sha256": sha256_file(args.input_file), "manifest": str(args.manifest.absolute()), "manifest_sha256": sha256_file(args.manifest), "phase_seconds": { "model_load": model_load_seconds, "prediction": prediction_seconds, "aggregation": aggregation_seconds, "total": time.perf_counter() - total_started, }, } result = { "experiment": manifest.get("experiment", {}), "runtime": runtime, "metrics": metric_statuses(aggregate), "aggregate": aggregate, "cases": summaries, } (args.output_dir / "summary.json").write_text( json.dumps(result, ensure_ascii=False, indent=2) + "\n", encoding="utf-8" ) print( f"Scored {len(rows)} windows across {len(summaries)} cases; " f"COMET macro={aggregate['macro']['comet']:.6f}, " f"weighted={aggregate['weighted']['comet']:.6f}" ) if __name__ == "__main__": main()