evaluation/README.md

Reproduce SEGALE-COMET evaluation

This directory contains the code needed to score the released Chinese-to-English tests: SEGALE alignment code, VecAlign, input adapters, COMET aggregation and document chrF2. It runs locally on CPU or one CUDA GPU.

Original SEGALE repository: https://github.com/NVlabs/SEGALE

Paper: https://aclanthology.org/2025.emnlp-main.1645/

VecAlign: https://github.com/shuoyangd/vecalign (upstream: https://github.com/thompsonb/vecalign)

Versions and modifications are recorded in NOTICE.md and provenance.json. Code licenses are included; they do not cover the datasets' book text.

1. Install

Use Python 3.11 in a dedicated environment. VecAlign needs a C compiler (build-essential on Ubuntu, or Xcode Command Line Tools on macOS).

From the repository root:

python3.11 -m venv .venv
source .venv/bin/activate
python -m pip install -r evaluation/requirements.txt
python -m pip install https://github.com/explosion/spacy-models/releases/download/en_core_web_sm-3.8.0/en_core_web_sm-3.8.0-py3-none-any.whl
python evaluation/setup_vecalign.py

The pinned PyTorch version supports CPU and compatible CUDA installations. The example uses CPU; choose --device cuda for longer tests on a CUDA GPU. Scores may differ slightly with GPU batching and dependency versions.

2. Download the models once

python evaluation/download_models.py

The script runs hf download with exact revisions from models.json: BAAI/bge-m3, Unbabel/wmt22-comet-da, and the XLM-R tokenizer/config required by COMET. Approximately 4.6 GB of weights are downloaded into the standard Hugging Face cache. Set HF_HOME before downloading and scoring if you need a different cache location. Existing matching files are reused. No model weights are committed to this repository.

Scoring uses those cached snapshots with network access disabled. Downloading the XLM-R config/tokenizer is necessary even though the COMET checkpoint already contains encoder weights.

3. Run the short example

python evaluation/run.py --example --output runs/example --device cpu

The example contains two original, short Chinese passages, English references, and handwritten demonstration predictions. One prediction omits a sentence. These are interface examples, not benchmark cases or actual model outputs. The example's length label is example, so its five-band benchmark aggregate is deliberately null.

Read runs/example/summary.json. The run also retains:

Output	Contents
generations.jsonl	Predictions with preserved text, hashes and available metadata
adapter/	SEGALE input and case-ID mapping
adapter/system/aligned_spacy_system.jsonl	Actual source/reference/prediction alignment
comet/	Window scores, per-document results and diagnostics
chrf2/	Full-document chrF2 scores
summary.json	Per-case results, length groups, coverage and five-band macro

The recorded CPU example result is example/expected.json. Its scores are a numerical reference; hardware or library differences can affect the last digits.

GLM API example

This optional example obtains translations from the official domestic GLM API, then passes them to the same evaluator. Complete installation and model download above first. The API helper uses only the Python standard library and makes two short requests for the original example passages.

Endpoint: https://open.bigmodel.cn/api/paas/v4/chat/completions; model: glm-5.3-flash. The example uses these settings: streaming with usage, temperature 1, top-p 0.95, low reasoning effort, and thinking enabled. The short example reserves 4,096 output tokens, including thinking. Only the final translation is saved as mt; references are used by the local scorer, never sent to the API.

From the repository root, enter your key without displaying it, obtain predictions, and score them:

export BIGMODEL_API_KEY="$(python -c 'import getpass; print(getpass.getpass("GLM API key: "))')"
python evaluation/glm_api_example.py \
  --example --output runs/glm-example/generations.jsonl
python evaluation/run.py \
  --data-root evaluation/example \
  --generations runs/glm-example/generations.jsonl \
  --output runs/glm-example/score --device cpu

Read runs/glm-example/score/summary.json: cases contains the two SEGALE-COMET scores and scored.segale_comet their mean. These short examples have no benchmark length bands, so five_band_macro.value is null. The API outputs are new model translations; the handwritten example/expected.json is not their expected result.

The live check on 2026-09-30 completed both official API calls and CPU scoring: 2/2 cases scored, with a case mean of 0.920040. This verifies the example workflow; new API calls can produce different translations and scores.

To evaluate one real BWB case, extract the archive and use its frozen request:

tar -xzf bwb/bwb-4k-64k.tar.gz
python evaluation/glm_api_example.py \
  --requests bwb-4k-64k/requests.jsonl \
  --case-id bwb-a3-main-45-start-4k --max-tokens 131072 \
  --output runs/glm-bwb-one/generations.jsonl
python evaluation/run.py \
  --data-root bwb-4k-64k \
  --generations runs/glm-bwb-one/generations.jsonl \
  --output runs/glm-bwb-one/score --device cuda

For GuoFeng, use the reconstructed requests.jsonl and its case IDs. Omitting --case-id sends every request in that file, sequentially. This command sets a 131,072-token output ceiling; check the context and output limits for the model you use. A single BWB case has 1/84 coverage and no five-band score; scoring a full dataset requires predictions for that dataset.

Use new output files for new runs. The helper preserves token usage, response ID, returned model name, settings and finish reason in each prediction, without saving the key. It stops on an API error, interrupted stream or explicit filter and records that case as non-success; it does not retry automatically. Outputs ending with length retain their translation and are scored with cap_hit=true.

4. Score BWB or reconstructed GuoFeng

Supply saved translations from your model or API in the format below. Check the input and output budgets before obtaining them. This entrypoint reads predictions and computes scores; it does not call an inference service.

Extract the included BWB archive first:

tar -xzf bwb/bwb-4k-64k.tar.gz
python evaluation/run.py \
  --data-root bwb-4k-64k \
  --generations predictions/bwb.jsonl \
  --output runs/bwb --device cuda

For GuoFeng, follow its README to reconstruct the data, then run:

python evaluation/run.py \
  --data-root reconstructed/guofeng \
  --generations predictions/guofeng.jsonl \
  --output runs/guofeng --device cuda

Each prediction is one UTF-8 JSONL record. The minimum fields are:

{"case_id":"bwb-a3-main-45-start-4k","mt":"Your complete English translation."}

Use the exact case IDs from that dataset. For an API response, put its final English translation text in mt, rather than the response envelope or reasoning text. finish_reason, input_tokens, output_tokens, cap_hit, model_revision, generation_config_sha256 and output_sha256 are accepted when available. Missing metadata is recorded as unknown (null); a missing text hash is computed. Supplied hashes are checked. Predictions are not trimmed, deduplicated or otherwise cleaned.

Missing predictions and explicit non-success records such as {"case_id":"...","status":"not_admissible"} are reported separately. They do not receive fabricated zero scores. An empty successful translation is rejected by the SEGALE adapter. Use a new output directory for each run.

--batch-size defaults to 8 and --case-workers to 1; both can be set explicitly. This portable entrypoint provides CPU/single-GPU evaluation. For multiple GPUs, run disjoint case subsets externally and aggregate per-case results, rather than averaging unequal shard means.

5. Read the results

SEGALE-COMET is the primary metric. For each dataset, report five_band_macro.value from summary.json, which weights the five length groups equally. It uses a 0–1 scale; multiply by 100 to report on a 0–100 scale.

Field in summary.json	Meaning
five_band_macro.value	Primary benchmark score: equal mean of the five band means
five_band_macro.band_means	SEGALE-COMET for each length band
five_band_macro.coverage	Scored and total cases for each band
scored.segale_comet	Mean over individual scored cases, with different weights because bands contain different numbers of cases
scored.diagnostics.cap_hit_cases / cap_observed_cases	Outputs reaching their limit / outputs with known limit status

Report coverage with the score. A missing entire band produces null; partial coverage within a band can still produce a mean and must be disclosed. Unknown limit status does not mean that no output was truncated. BWB and GuoFeng have separate scores. Full-document chrF2 is an auxiliary metric, and a normal finish or high score alone does not establish complete translation.

Metric settings

• Alignment: spaCy en_core_web_sm==3.8.0, public BGE-M3, embedding limit 512 tokens, max_size=8, seeded VecAlign adaptive search with online-stop.
• Main metric: reference-based Unbabel/wmt22-comet-da; null model alignments receive 0, canonical missing-reference units are excluded from scoring.
• Auxiliary metric: full-document chrF2 from SacreBLEU 2.6.0, already on a 0–100 scale.

BWB and GuoFeng are scored and reported separately. This profile uses spaCy and public BGE-M3, not the SEGALE paper's Ersatz/fine-tuned embedding configuration. Saved scores describe the specified profile.