Publish reviewed insttrans benchmark

Reviewed dataset, reproducible evaluation code and release manifest. See RELEASE_REVIEW.md for changes and validation.

.gitattributes

@@ -58,3 +58,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 # Video files - compressed
 *.mp4 filter=lfs diff=lfs merge=lfs -text
 *.webm filter=lfs diff=lfs merge=lfs -text
+data/test.jsonl filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.py[cod]
+.venv/
+.env
+.env.*
+outputs/
+.cache/

LICENSE

@@ -0,0 +1,11 @@
+Creative Commons Attribution-NonCommercial 4.0 International (CC BY-NC 4.0)
+
+Copyright 2026 IndexTeam
+
+This dataset is licensed under the Creative Commons Attribution-NonCommercial
+4.0 International License. You may share and adapt the material for
+non-commercial purposes, provided that you give appropriate credit, provide a
+link to the license, and indicate if changes were made.
+
+The full legal code is available at:
+https://creativecommons.org/licenses/by-nc/4.0/legalcode

README.md

@@ -0,0 +1,389 @@
+---
+pretty_name: Instruction-Following Translation Bench
+license: cc-by-nc-4.0
+language:
+  - zh
+  - en
+  - ja
+  - ko
+  - ar
+  - de
+  - es
+  - fil
+  - fr
+  - hi
+  - id
+  - it
+  - ms
+  - nl
+  - pl
+  - pt
+  - ro
+  - ru
+  - sv
+  - th
+  - tr
+  - vi
+task_categories:
+  - translation
+size_categories:
+  - 1K<n<10K
+tags:
+  - evaluation
+  - benchmark
+  - instruction-following
+  - constrained-translation
+  - subtitle
+  - terminology
+configs:
+  - config_name: default
+    data_files:
+      - split: test
+        path: data/test.jsonl
+---
+
+# Instruction-Following Translation Bench
+
+Instruction-Following Translation Bench measures whether a translation system can
+**obey explicit production constraints while translating**. Real content pipelines
+rarely want a free translation: a subtitle line has to fit the time it is on
+screen, a glossary term has to come out exactly as the glossary says, a JSON
+payload has to come back with its keys intact, and a hashtag has to survive
+untranslated so it still links. A system that translates beautifully but breaks
+the structure around the text cannot be shipped.
+
+The benchmark contains **3,000 evaluation instances** across **10 constraint
+types**, **10 content domains** and **61 language pairs**, built from Bilibili
+production content: subtitles, comments, on-screen comments, posts, novels,
+columns, books, web text and academic papers.
+
+The benchmark is released as part of the **Index-Translate** model family and is
+referred to as **InstTrans** in the Index-Translate technical report.
+See [Citation](#citation) for how to refer to it.
+
+## Task and motivation
+
+Each instance gives the model a source text plus a numbered list of constraints,
+and asks for a translation that satisfies all of them. Constraints are not
+suggestions: the scoring treats five of them as gates, so a single structural
+break zeroes the instance no matter how good the prose is.
+
+The benchmark separates two things that are usually conflated:
+
+- **Instruction following** — did the output keep the JSON keys, hit the glossary,
+  preserve the hashtag, respect the syllable budget, keep the line breaks?
+- **Translation quality** — is the translation itself accurate and fluent?
+
+Both are reported. A system can score well on quality and badly on
+instruction following, and that gap is the thing this benchmark exists to expose.
+
+## Constraint types
+
+Ten constraint types, split by how they are scored. **Hard** constraints are
+checked by deterministic rules and act as gates. **Soft** constraints are scored
+0 / 0.5 / 1 by an LLM Judge and average into a multiplier.
+
+| Constraint | Type | Instances | What it requires |
+| --- | --- | ---: | --- |
+| `format_preserve` | hard | 2,098 | Keep JSON / HTML / Markdown / placeholder structure intact |
+| `syllable_order` | hard | 601 | Shorter on-screen durations get fewer syllables in the translation |
+| `term_compliance` | hard | 502 | Render each glossary term exactly as specified |
+| `social_preserve` | hard | 316 | Leave hashtags, `@mentions` and emote codes untranslated |
+| `layout_break` | hard | 266 | Preserve line breaks, indentation and table alignment |
+| `style_consistency` | soft | 633 | Hold the requested register (casual / neutral / formal) |
+| `term_cross_sentence` | soft | 508 | Use one rendering of a term throughout the document |
+| `academic_format_preserve` | soft | 412 | Leave LaTeX and citation markers untranslated |
+| `context_disambiguate` | soft | 42 | Resolve a stated ambiguity the way the instruction says |
+| `coref_resolution` | soft | 24 | Keep pronoun reference consistent with the stated antecedent |
+
+Instances carry 1–5 constraints each: 1,307 have one, 1,138 two, 426 three, 104
+four, and 25 five. The 5,402 constraint annotations over 3,000 instances mean the
+average instance is scored on 1.8 constraints at once, which is where systems
+tend to fail — satisfying a glossary while also preserving JSON is harder than
+either alone.
+
+### The syllable constraint
+
+`syllable_order` is the least obvious of the ten, and it is the one subtitle
+production actually needs. Each subtitle instance ships `duration_s`, the
+on-screen duration of every line. The requirement is not an absolute syllable
+count but the **ordering**: if line 6 is on screen longer than line 2, its
+translation should not be shorter in syllables.
+
+Scoring is pairwise. For every pair of lines with different durations, the pair is
+an inversion if the duration ordering and the syllable-count ordering disagree.
+Concordance is `1 - inversions / comparable_pairs`, and the constraint passes at
+**concordance >= 0.9**. Pairs with equal syllable counts are not inversions, and
+pairs with equal durations are not comparable. Syllable counting is
+language-specific (see [`eval/syllable.py`](eval/syllable.py)) and handles
+numbers, acronyms and mixed scripts.
+
+## Dataset statistics
+
+| Item | Count |
+| --- | ---: |
+| Evaluation instances | 3,000 |
+| Constraint types | 10 |
+| Constraint annotations | 5,402 |
+| Language pairs | 61 |
+| Target languages | 22 |
+| Content domains | 10 |
+
+| Domain | Value in `domain` | Instances |
+| --- | --- | ---: |
+| Bilibili posts | `B站动态` | 320 |
+| Novels | `小说` | 303 |
+| OGV subtitles | `ogv字幕` | 302 |
+| On-screen comments | `弹幕` | 302 |
+| Comments | `评论` | 300 |
+| Columns | `专栏文章` | 300 |
+| Academic papers | `学术论文` | 299 |
+| UGC subtitles | `UGC字幕` | 299 |
+| Books | `书籍` | 293 |
+| Web text | `网页文本` | 282 |
+
+The dominant direction is Chinese into 21 other languages (2,419 instances), plus
+313 English-source instances and 14–15 instances from each of 19 other source
+languages. `zh` is also the most common target (296 instances), from the
+English-source and other-source material.
+
+Domains do not carry every constraint. On-screen comments, comments and posts only
+ever carry `format_preserve`, `social_preserve` and `term_compliance`;
+`syllable_order` appears only on subtitles, since only subtitles have durations;
+`academic_format_preserve` concentrates in papers. This is a property of the
+content, not a sampling gap — a hashtag constraint on an academic paper would be
+artificial.
+
+## Files and schema
+
+```text
+README.md
+manifest.json
+LICENSE
+requirements.txt
+data/test.jsonl
+prepare_inputs.py
+evaluate.py
+eval/
+    __init__.py
+    constraints.py
+    prompts.py
+    judge_client.py
+    metrics.py
+    syllable.py
+```
+
+`manifest.json` records release statistics, prompt versions, the redaction policy
+and the SHA-256 checksum of the data file.
+
+| Field | Type | Description |
+| --- | --- | --- |
+| `case_id` | string | Unique instance identifier; use it to match predictions. |
+| `prompt` | string | The complete instruction sent to the model, including source text and constraints. |
+| `reference` | string | Reference translation satisfying the constraints. Used by the quality Judge, never sent to the model. |
+| `source_lang` | string | Source language code. |
+| `target_lang` | string | Target language code. |
+| `source_text` | string | Source text alone, extracted from `prompt`. Convenience field for rule checking. |
+| `constraints` | list of strings | The numbered constraint lines, verbatim from `prompt`. Aligned 1:1 with `constraint_ids`. |
+| `constraint_ids` | list of strings | Machine-readable constraint types for this instance. |
+| `scenario` | string | Coarse content grouping (7 values). |
+| `domain` | string | Fine content grouping (10 values); several domains share one scenario. |
+| `duration_s` | list of floats | Per-line on-screen duration in seconds. Present on the 601 subtitle instances with `syllable_order`. |
+| `batch_size` | integer | Number of sentences in a multi-sentence instance. Present when applicable. |
+| `style` | object | Requested register, e.g. `{"formality": "casual"}`. Present when the instance specifies one. |
+
+`prompt` is the single source of truth for what the model sees. `source_text` and
+`constraints` are derived from it with the same extraction the scorer uses, so
+they cannot drift apart.
+
+Source text retains its original informal spelling, punctuation, emote codes and
+`@mentions`; the `social_preserve` constraint depends on those surviving
+translation, so they are not masked. Provenance identifiers (video and post IDs,
+internal file paths) and authorship fields were removed from the release;
+`manifest.json` records exactly which.
+
+Contact details that can reach a person or a group chat — phone numbers, email
+addresses, QQ group numbers and WeChat IDs, mostly appearing in promotional spam
+inside user-generated text — are replaced by bare uppercase tokens
+(`PHONE_REDACTED`, `EMAIL_REDACTED`, `QQ_GROUP_REDACTED`, `WECHAT_ID_REDACTED`)
+in `prompt`, `reference` and `source_text`. This touches 15 of the 3,000
+instances. No constraint scores contact details, and the masks were chosen to
+contain no regex-special characters so they cannot be mistaken for an HTML tag, a
+placeholder or a Markdown link by the format checkers; scoring the references
+gives the same IF_Score before and after masking, with zero per-constraint
+verdict changes. URLs and `@mentions` are kept, since `format_preserve` and
+`social_preserve` score them.
+
+## Loading the data
+
+```bash
+pip install -r requirements.txt
+```
+
+```python
+from datasets import load_dataset
+
+dataset = load_dataset(
+    "IndexTeam/InstTrans-Bench", split="test"
+)
+print(len(dataset))            # 3000
+print(dataset[0]["prompt"])
+print(dataset[0]["constraint_ids"])
+```
+
+## Generating translations
+
+Export the standard model inputs from the repository root:
+
+```bash
+python prepare_inputs.py --output outputs/model_inputs.jsonl
+```
+
+Each output row contains only `case_id` and a chat-format `messages` list. Send
+**only `messages`** to the model; use `case_id` locally to associate the returned
+translation with the instance. Do not send the complete dataset row, since it
+contains the reference translation.
+
+Use any inference engine, then save one translation per instance as JSONL:
+
+```python
+import json
+
+with open("outputs/model_inputs.jsonl", encoding="utf-8") as handle:
+    inputs = [json.loads(line) for line in handle]
+
+translations = [...]  # one string per input, aligned with the rows above
+assert len(translations) == len(inputs)
+with open("outputs/predictions.jsonl", "w", encoding="utf-8") as handle:
+    for row, translation in zip(inputs, translations):
+        handle.write(json.dumps({
+            "case_id": row["case_id"],
+            "prediction": translation,
+        }, ensure_ascii=False) + "\n")
+```
+
+Predictions should be final translations without reasoning traces or commentary.
+Many instances require the output to be a JSON object with the source's keys, so
+any wrapper text around it will fail `format_preserve` on its own. Record the
+model revision, inference engine, decoding parameters and reasoning setting with
+reported results.
+
+## Evaluation protocol
+
+Scoring has two independent dimensions.
+
+**IF_Score** is the headline metric, on a 0–1 scale:
+
+```
+IF_Score = product(hard_constraint_passed) x mean(soft_constraint_scores)
+```
+
+Every hard constraint is a gate: one failure sets the product to 0 and the
+instance scores 0 regardless of the soft scores. Soft constraints are scored
+0 / 0.5 / 1 by the Judge and averaged. An instance with no soft constraints uses a
+multiplier of 1.0, so it scores either 1.0 or 0.0.
+
+**Translation quality** is scored separately by an LLM Judge that sees the source,
+the reference and the candidate, and is told to ignore format and constraints
+entirely. It is reported alongside IF_Score, not folded into it.
+
+| Score | Quality interpretation |
+| --- | --- |
+| 1 | Accurate and natural; no serious errors, minimal minor ones. |
+| 0.5 | Minor errors only, or few serious ones (under 10% of sentences); readable overall. |
+| 0 | Many serious errors (over 10% of sentences); quality badly affected. |
+
+Hard constraints are checked by deterministic rules in
+[`eval/constraints.py`](eval/constraints.py), so that part of the score is
+reproducible without a Judge at all:
+
+```bash
+python evaluate.py \
+  --predictions outputs/predictions.jsonl \
+  --output-dir outputs/evaluation \
+  --skip-judge
+```
+
+The full run needs a Judge. The default is `gpt-5.6-sol`. Configure an endpoint
+and credentials for a provider you have access to; none are bundled.
+
+```bash
+export JUDGE_API_BASE="https://YOUR_PROVIDER/v1"
+export JUDGE_API_KEY="YOUR_API_KEY"
+
+python evaluate.py \
+  --predictions outputs/predictions.jsonl \
+  --output-dir outputs/evaluation \
+  --judge-model gpt-5.6-sol
+```
+
+The client picks a request shape from the model name. A reasoning model
+(`gpt-5*`, `gpt-6*`, `o1`/`o3`/`o4`) goes to `/responses` with a 4,096-token
+output budget and reasoning effort `none`; every other model goes to
+`/chat/completions` at temperature `0` with a 2,048-token limit. Reasoning is
+disabled so the Judge scores rather than deliberates, and the response cache keys
+on the endpoint and its parameters, so switching Judge models never serves a
+verdict produced under a different configuration.
+
+If your provider serves a reasoning model on `/chat/completions` instead, pass a
+model name outside those prefixes, or adjust `uses_responses_endpoint` in
+[`eval/judge_client.py`](eval/judge_client.py).
+
+The evaluator writes per-instance scores (`scores.jsonl`), aggregate metrics
+(`summary.json`) and a reusable response cache. The summary breaks results down by
+constraint, scenario, domain and language pair, and reports per-constraint pass
+rates so a low IF_Score can be traced to the constraint causing it. Missing or
+empty predictions score 0 and stay in the denominator. Duplicate or unknown
+`case_id`s are rejected. Provider failures and invalid or incomplete Judge scores abort the run rather
+than silently becoming quality scores. This public release validates the exact
+0/0.5/1 verdict, including the soft-constraint entries; malformed verdicts are
+not excluded from the denominator or treated as a passed instruction.
+
+`--limit N` scores the first N instances as a smoke check and marks the summary as
+non-formal. Subset and `--skip-judge` scores are not full-benchmark results.
+
+Scores obtained with a different Judge model, provider or decoding configuration
+are not comparable. Report the Judge configuration alongside any new numbers.
+
+## Links
+
+- Technical report: [Index-Translate Technical Report](https://github.com/bilibili/Index-Translate)
+
+## Citation
+
+```bibtex
+@misc{indextranslate2026insttransbench,
+  title        = {Instruction-Following Translation Bench},
+  author       = {{Index LLM Team}},
+  year         = {2026},
+  howpublished = {Evaluation benchmark},
+  note         = {InstTrans benchmark of the Index-Translate model family}
+}
+```
+
+Cite the technical report for the model family, the training recipe, and the full
+evaluation suite:
+
+```bibtex
+@misc{indextranslate2026,
+  title        = {Index-Translate: Controllable Multilingual Translation for
+                  Content Production},
+  subtitle     = {Text, Speech, Controlled Dubbing, and Long-Document Translation},
+  author       = {{Index LLM Team}},
+  year         = {2026},
+  howpublished = {Technical report},
+  url          = {https://github.com/bilibili/Index-Translate}
+}
+```
+
+## License
+
+This dataset is released under the **Creative Commons
+Attribution–NonCommercial 4.0 International (CC BY-NC 4.0)** license. You may
+share and adapt the dataset for non-commercial purposes with appropriate
+attribution. See [LICENSE](LICENSE) and the
+[full license text](https://creativecommons.org/licenses/by-nc/4.0/).
+
+## Benchmark collection
+
+Part of the [Index-Translate Benchmarks collection](https://huggingface.co/collections/IndexTeam/index-translate-benchmarks-6ac16fee5057f40abd7d31b7).

RELEASE_REVIEW.md

@@ -0,0 +1,9 @@
+# Public release review
+
+Reviewed on 2026-10-04.
+
+- Preserved data and model/Judge prompts
+- Rejected invalid quality and missing soft-constraint Judge verdicts
+- Corrected redaction-policy description
+
+Validation checks cover dataset loading, input/reference separation, source hashes, IDs and offline scoring behavior. No paid Judge calls or full model inference were run. Historical leaderboard numbers are source-reported results, not remeasured in this release.

data/test.jsonl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:fa47b65120a3c00e8c7e66bfdfe0dd75274de8d100dbd1ce0540d754bd5a4b63
+size 28217329

eval/__init__.py

@@ -0,0 +1 @@
+"""Evaluation helpers for Instruction-Following Translation Bench."""

eval/constraints.py

@@ -0,0 +1,370 @@
+"""Rule-based checkers for the five hard constraints.
+
+Ported unchanged from the internal scorer so published scores stay comparable.
+Each checker returns ``{"is_valid": bool, ...}`` with diagnostic detail.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from .syllable import cal_syllable_count
+
+HARD_CONSTRAINT_IDS = frozenset({
+    "format_preserve", "layout_break", "term_compliance",
+    "syllable_order", "social_preserve",
+})
+SOFT_CONSTRAINT_IDS = frozenset({
+    "style_consistency", "context_disambiguate", "coref_resolution",
+    "term_cross_sentence", "academic_format_preserve",
+})
+
+
+# ======================== Constraint text parsing ========================
+
+def parse_term_targets(constraint_lines: list[str]) -> list[str]:
+    """Target-side renderings from a `专名/术语对照: X→Y、...` line."""
+    target_terms = []
+    for line in constraint_lines:
+        if "术语对照" not in line and "专名" not in line:
+            continue
+        match = re.search(r"(?:专名/?)?术语对照[:：]\s*(.*)", line)
+        if not match:
+            continue
+        for pair in re.split(r"[、,，]", match.group(1)):
+            if "→" in pair:
+                target = pair.split("→", 1)[1].strip()
+                if target:
+                    target_terms.append(target)
+    return target_terms
+
+
+def parse_layout_features(constraint_lines: list[str]) -> list[str]:
+    features = []
+    for line in constraint_lines:
+        if "布局" not in line and "排版" not in line:
+            continue
+        if "换行" in line:
+            features.append("newlines")
+        if "缩进" in line:
+            features.append("indent")
+        if "表格" in line:
+            features.append("table_align")
+    return features if features else ["newlines", "indent"]
+
+
+def parse_social_elements(constraint_lines: list[str]) -> list[str]:
+    elements = []
+    for line in constraint_lines:
+        if "社交元素" not in line:
+            continue
+        for sep in (":", "："):
+            if sep in line:
+                raw = line.split(sep, 1)[1].strip()
+                elements.extend(p.strip() for p in re.split(r"[、,，]", raw) if p.strip())
+                break
+    return elements
+
+
+def collect_soft_constraint_descs(
+    constraint_ids: list[str], constraint_lines: list[str]
+) -> dict[str, str]:
+    """Map each soft constraint id to the prompt line stating it."""
+    keyword_map = {
+        "style_consistency": ["语体", "风格"],
+        "context_disambiguate": ["歧义", "消歧"],
+        "coref_resolution": ["指代", "代词"],
+        "term_cross_sentence": ["跨句", "全文统一"],
+        "academic_format_preserve": ["学术", "LaTeX", "学术格式"],
+    }
+    soft_descs: dict[str, str] = {}
+    for cid in constraint_ids:
+        if cid not in SOFT_CONSTRAINT_IDS:
+            continue
+        for line in constraint_lines:
+            if any(kw in line for kw in keyword_map.get(cid, [])):
+                soft_descs[cid] = line
+                break
+        soft_descs.setdefault(cid, cid)
+    return soft_descs
+
+
+# ======================== Rule-based checkers ========================
+
+def _build_term_pattern(term: str) -> str:
+    escaped = re.escape(term)
+    # CJK has no word boundaries; \b would never match against them.
+    if any(("一" <= ch <= "鿿") or ("぀" <= ch <= "ヿ") for ch in term):
+        return escaped
+    return rf"(?<!\w){escaped}(?!\w)"
+
+
+def check_glossary(target_text: str, required_terms: list[str]) -> dict[str, Any]:
+    missing = [t for t in required_terms
+               if not re.search(_build_term_pattern(t), target_text)]
+    return {"is_valid": not missing, "missing_terms": missing}
+
+
+def check_json_preserved(source_text: str, target_text: str) -> dict[str, Any]:
+    def extract_keys(text: str) -> tuple[bool, list[str]]:
+        try:
+            parsed = json.loads(text)
+        except json.JSONDecodeError:
+            return False, []
+        keys: list[str] = []
+
+        def walk(obj: Any, path: str = "") -> None:
+            if isinstance(obj, dict):
+                for key, value in obj.items():
+                    current = f"{path}.{key}" if path else key
+                    keys.append(current)
+                    walk(value, current)
+            elif isinstance(obj, list):
+                for index, element in enumerate(obj):
+                    walk(element, f"{path}[{index}]")
+
+        walk(parsed)
+        return True, keys
+
+    src_valid, src_keys = extract_keys(source_text)
+    tgt_valid, tgt_keys = extract_keys(target_text)
+    if not src_valid:
+        return {"is_valid": False, "issues": ["源文不是有效JSON"]}
+    if not tgt_valid:
+        return {"is_valid": False, "issues": ["译文不是有效JSON"]}
+
+    issues = []
+    missing = set(src_keys) - set(tgt_keys)
+    extra = set(tgt_keys) - set(src_keys)
+    if missing:
+        issues.append(f"缺失key: {missing}")
+    if extra:
+        issues.append(f"多余key: {extra}")
+    return {"is_valid": not issues, "issues": issues}
+
+
+def _extract_visible_text(html: str) -> str:
+    return re.sub(r"<[^>]+>", "", html).strip()
+
+
+def _chinese_ratio(text: str) -> float:
+    text = re.sub(r"\s+", "", text)
+    if not text:
+        return 0.0
+    return sum(1 for ch in text if "一" <= ch <= "鿿") / len(text)
+
+
+def check_html_preserved(
+    source_text: str, target_text: str,
+    src_lang: str | None = None, tgt_lang: str | None = None,
+) -> dict[str, Any]:
+    tag_pattern = re.compile(r"</?[a-z][a-z0-9]*\b[^>]*>", re.IGNORECASE)
+    src_tag_types = [re.sub(r"\s+.*?>", ">", t) for t in tag_pattern.findall(source_text)]
+    tgt_tag_types = [re.sub(r"\s+.*?>", ">", t) for t in tag_pattern.findall(target_text)]
+
+    issues = []
+    if src_tag_types != tgt_tag_types:
+        issues.append(f"标签不一致: 源文{len(src_tag_types)}个, 译文{len(tgt_tag_types)}个")
+
+    if src_lang == "zh" and tgt_lang not in ("ja", "zh"):
+        tgt_visible = _extract_visible_text(target_text)
+        if tgt_visible and _extract_visible_text(source_text):
+            ratio = _chinese_ratio(tgt_visible)
+            if ratio > 0.01:
+                issues.append(f"译文中残留中文（占比{ratio:.1%}）")
+
+    return {"is_valid": not issues, "issues": issues}
+
+
+def check_markdown_preserved(source_text: str, target_text: str) -> dict[str, Any]:
+    md_patterns = [
+        (r"^#{1,6}\s", "标题"), (r"\*\*[^*]+\*\*", "粗体"),
+        (r"\*[^*]+\*", "斜体"), (r"`[^`]+`", "行内代码"),
+        (r"```[\s\S]*?```", "代码块"), (r"^[-*+]\s", "列表项"),
+        (r"^\d+\.\s", "有序列表"), (r"\[.*?\]\(.*?\)", "链接"),
+        (r"!\[.*?\]\(.*?\)", "图片"), (r"^>\s", "引用"),
+        (r"\|.*\|", "表格"),
+    ]
+    issues = []
+    for pattern, name in md_patterns:
+        if re.search(pattern, source_text, re.MULTILINE) and not re.search(
+            pattern, target_text, re.MULTILINE
+        ):
+            issues.append(f"丢失{name}标记")
+    return {"is_valid": not issues, "issues": issues}
+
+
+def check_placeholder_preserved(source_text: str, target_text: str) -> dict[str, Any]:
+    patterns = [
+        r"\{[a-zA-Z_][a-zA-Z0-9_]*\}",
+        r"%[dsf]",
+        r"\$\d+",
+        r"\{\{[a-zA-Z_][a-zA-Z0-9_]*\}\}",
+    ]
+    issues = []
+    for pattern in patterns:
+        missing = set(re.findall(pattern, source_text)) - set(re.findall(pattern, target_text))
+        if missing:
+            issues.append(f"丢失占位符: {missing}")
+    return {"is_valid": not issues, "issues": issues}
+
+
+def check_format_preserve(
+    source_text: str, target_text: str,
+    src_lang: str | None = None, tgt_lang: str | None = None,
+) -> dict[str, Any]:
+    """Dispatch to whichever format checkers the source text actually triggers."""
+    results: dict[str, Any] = {}
+    issues: list[str] = []
+    stripped = source_text.strip()
+
+    if stripped[:1] in ("{", "["):
+        try:
+            json.loads(stripped)
+            is_json = True
+        except json.JSONDecodeError:
+            is_json = False
+        if is_json:
+            sub = check_json_preserved(stripped, target_text.strip())
+            results["json"] = sub
+            if not sub["is_valid"]:
+                issues.extend(sub.get("issues", []))
+
+    if re.search(r"</?[a-z][a-z0-9]*\b[^>]*>", source_text, re.IGNORECASE):
+        sub = check_html_preserved(source_text, target_text, src_lang=src_lang, tgt_lang=tgt_lang)
+        results["html"] = sub
+        if not sub["is_valid"]:
+            issues.extend(sub.get("issues", []))
+
+    if re.search(r"^#{1,6}\s|\*\*|`|^[-*+]\s|^>\s|\[.*?\]\(.*?\)", source_text, re.MULTILINE):
+        sub = check_markdown_preserved(source_text, target_text)
+        results["markdown"] = sub
+        if not sub["is_valid"]:
+            issues.extend(sub.get("issues", []))
+
+    if re.search(
+        r"\{[a-zA-Z_][a-zA-Z0-9_]*\}|%[dsf]|\$\d+|\{\{[a-zA-Z_][a-zA-Z0-9_]*\}\}", source_text
+    ):
+        sub = check_placeholder_preserved(source_text, target_text)
+        results["placeholder"] = sub
+        if not sub["is_valid"]:
+            issues.extend(sub.get("issues", []))
+
+    return {"is_valid": not issues, "issues": issues, "sub_results": results}
+
+
+def check_layout_preserved(
+    source_text: str, target_text: str, layout_features: list[str] | None = None
+) -> dict[str, Any]:
+    layout_features = layout_features or ["newlines", "indent"]
+    issues = []
+
+    if "newlines" in layout_features:
+        src_nl, tgt_nl = source_text.count("\n"), target_text.count("\n")
+        if src_nl != tgt_nl:
+            issues.append(f"换行数不一致: 源文{src_nl}, 译文{tgt_nl}")
+
+    if "indent" in layout_features:
+        src_indent = len(source_text) - len(source_text.lstrip())
+        tgt_indent = len(target_text) - len(target_text.lstrip())
+        if (src_indent > 0) != (tgt_indent > 0):
+            issues.append("缩进风格不一致")
+
+    if "table_align" in layout_features:
+        src_has = any("|" in l and l.count("|") >= 2 for l in source_text.splitlines())
+        tgt_has = any("|" in l and l.count("|") >= 2 for l in target_text.splitlines())
+        if src_has and not tgt_has:
+            issues.append("源文含表格对齐结构但译文丢失")
+
+    return {"is_valid": not issues, "issues": issues}
+
+
+def check_social_preserve(target_text: str, elements: list[str]) -> dict[str, Any]:
+    if not elements:
+        return {"is_valid": True, "note": "no elements to check"}
+    missing = [e for e in elements if e not in target_text]
+    return {"is_valid": not missing, "missing_elements": missing}
+
+
+def check_syllable_order(
+    prediction: str, durations: list[float], tgt_lang: str
+) -> dict[str, Any]:
+    """Rank-correlate per-sentence duration against translated syllable count.
+
+    Passes at concordance >= 0.9. Pairs with equal durations, and pairs with equal
+    syllable counts, are not counted as inversions.
+    """
+    if not durations or not prediction:
+        return {"is_valid": True, "note": "no duration data"}
+
+    try:
+        output = json.loads(prediction)
+    except (json.JSONDecodeError, TypeError):
+        return {"is_valid": False, "note": "output is not valid JSON"}
+    if not isinstance(output, dict):
+        return {"is_valid": False, "note": "output is not a JSON object"}
+
+    syllables = [
+        cal_syllable_count(output.get(str(i), ""), tgt_lang)
+        for i in range(1, len(durations) + 1)
+    ]
+    if len(syllables) < 2:
+        return {"is_valid": True, "note": "too few sentences"}
+
+    inversions = total_pairs = 0
+    for i in range(len(durations)):
+        for j in range(i + 1, len(durations)):
+            if durations[i] == durations[j]:
+                continue
+            total_pairs += 1
+            if syllables[i] == syllables[j]:
+                continue
+            if (durations[i] > durations[j]) != (syllables[i] > syllables[j]):
+                inversions += 1
+
+    if total_pairs == 0:
+        return {"is_valid": True, "note": "all durations equal"}
+
+    concordance = 1.0 - inversions / total_pairs
+    return {
+        "is_valid": concordance >= 0.9,
+        "concordance": round(concordance, 3),
+        "inversions": inversions,
+        "total_pairs": total_pairs,
+    }
+
+
+def check_hard_constraints(row: dict[str, Any], prediction: str) -> dict[str, Any]:
+    """Run every hard checker this instance is annotated for."""
+    if not prediction:
+        return {}
+
+    source_text = row["source_text"]
+    constraint_lines = row["constraints"]
+    results: dict[str, Any] = {}
+
+    for cid in row["constraint_ids"]:
+        if cid not in HARD_CONSTRAINT_IDS:
+            continue
+        if cid == "format_preserve":
+            results[cid] = check_format_preserve(
+                source_text, prediction,
+                src_lang=row["source_lang"], tgt_lang=row["target_lang"],
+            )
+        elif cid == "layout_break":
+            results[cid] = check_layout_preserved(
+                source_text, prediction, parse_layout_features(constraint_lines))
+        elif cid == "term_compliance":
+            terms = parse_term_targets(constraint_lines)
+            results[cid] = (check_glossary(prediction, terms) if terms
+                            else {"is_valid": True, "note": "no terms to check"})
+        elif cid == "syllable_order":
+            results[cid] = check_syllable_order(
+                prediction, row.get("duration_s", []), row["target_lang"])
+        elif cid == "social_preserve":
+            results[cid] = check_social_preserve(
+                prediction, parse_social_elements(constraint_lines))
+
+    return results

eval/judge_client.py

@@ -0,0 +1,185 @@
+"""OpenAI-compatible Judge client with a durable append-only cache.
+
+Two request shapes, chosen by model name. Reasoning models are served on
+``/responses`` instead of ``/chat/completions`` -- on the gateway this benchmark
+was scored with, a ``gpt-5.x`` model has no chat/completions cluster at all, so
+sending one there fails rather than falling back -- and they take an output-token
+budget and a reasoning effort in place of a temperature. Everything else uses
+``/chat/completions``.
+"""
+
+from __future__ import annotations
+
+import hashlib
+import json
+import random
+import threading
+import time
+from pathlib import Path
+
+# Chat models: deterministic decoding.
+JUDGE_TEMPERATURE = 0.0
+JUDGE_MAX_TOKENS = 2048
+
+# Reasoning models: no temperature knob. Thinking is disabled so the Judge is
+# scoring rather than deliberating, and the token budget is higher because the
+# reasoning envelope counts against it even at effort "none".
+JUDGE_MAX_OUTPUT_TOKENS = 4096
+JUDGE_REASONING_EFFORT = "none"
+
+
+def uses_responses_endpoint(model: str) -> bool:
+    return model.startswith(("gpt-5", "gpt-6", "o1", "o3", "o4"))
+
+
+class JudgeRequestError(RuntimeError):
+    pass
+
+
+class JudgeClient:
+    def __init__(
+        self,
+        *,
+        api_key: str,
+        base_url: str,
+        model: str,
+        prompt_version: str,
+        cache_path: Path,
+        timeout: float = 360.0,
+        max_attempts: int = 6,
+    ) -> None:
+        if not api_key:
+            raise ValueError("JUDGE_API_KEY is required")
+        from openai import OpenAI
+
+        self.model = model
+        self.prompt_version = prompt_version
+        self.timeout = timeout
+        self.max_attempts = max_attempts
+        self._use_responses = uses_responses_endpoint(model)
+        self.cache_path = cache_path
+        self.cache_path.parent.mkdir(parents=True, exist_ok=True)
+        self._client = OpenAI(api_key=api_key, base_url=base_url, timeout=timeout)
+        self._lock = threading.Lock()
+        self._cache: dict[str, str] = {}
+        self._load_cache()
+
+    def _key(self, prompt: str) -> str:
+        # The decoding parameters belong in the key, and the two endpoints do not
+        # share a set: keying a /responses verdict on a temperature it never used
+        # would let a cached chat verdict answer a reasoning-model request.
+        if self._use_responses:
+            params: dict[str, object] = {
+                "endpoint": "responses",
+                "max_output_tokens": JUDGE_MAX_OUTPUT_TOKENS,
+                "reasoning_effort": JUDGE_REASONING_EFFORT,
+            }
+        else:
+            params = {
+                "endpoint": "chat.completions",
+                "temperature": JUDGE_TEMPERATURE,
+                "max_tokens": JUDGE_MAX_TOKENS,
+            }
+        payload = json.dumps(
+            {
+                "model": self.model,
+                "prompt_version": self.prompt_version,
+                "prompt": prompt,
+                **params,
+            },
+            ensure_ascii=False,
+            sort_keys=True,
+            separators=(",", ":"),
+        )
+        return hashlib.sha256(payload.encode("utf-8")).hexdigest()
+
+    def _load_cache(self) -> None:
+        if not self.cache_path.is_file():
+            return
+        with self.cache_path.open(encoding="utf-8") as handle:
+            for line_number, line in enumerate(handle, 1):
+                if not line.strip():
+                    continue
+                try:
+                    record = json.loads(line)
+                    self._cache[record["key"]] = record["response"]
+                except (json.JSONDecodeError, KeyError, TypeError):
+                    # An interrupted final append must not destroy earlier cache entries.
+                    if line_number > 1:
+                        continue
+
+    def _cache_put(self, key: str, response: str) -> None:
+        with self._lock:
+            if key in self._cache:
+                return
+            self._cache[key] = response
+            with self.cache_path.open("a", encoding="utf-8") as handle:
+                handle.write(json.dumps({"key": key, "response": response}, ensure_ascii=False))
+                handle.write("\n")
+                handle.flush()
+
+    def _complete_via_chat(self, prompt: str) -> str:
+        response = self._client.chat.completions.create(
+            model=self.model,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=JUDGE_TEMPERATURE,
+            max_tokens=JUDGE_MAX_TOKENS,
+        )
+        return response.choices[0].message.content or ""
+
+    def _complete_via_responses(self, prompt: str) -> str:
+        response = self._client.responses.create(
+            model=self.model,
+            input=prompt,
+            max_output_tokens=JUDGE_MAX_OUTPUT_TOKENS,
+            reasoning={"effort": JUDGE_REASONING_EFFORT},
+        )
+        # Walk the output blocks rather than reading output_text: with reasoning
+        # enabled the array also carries reasoning items, and a provider that
+        # ignores effort="none" would otherwise fold thinking into the verdict.
+        parts = []
+        for block in response.output or []:
+            if getattr(block, "type", None) != "message":
+                continue
+            for item in getattr(block, "content", None) or []:
+                if getattr(item, "type", None) == "output_text":
+                    parts.append(getattr(item, "text", "") or "")
+        return "".join(parts)
+
+    def complete(self, prompt: str) -> tuple[str, bool]:
+        """Return (response_text, served_from_cache)."""
+        key = self._key(prompt)
+        with self._lock:
+            cached = self._cache.get(key)
+        if cached is not None:
+            return cached, True
+
+        error: BaseException | None = None
+        for attempt in range(self.max_attempts):
+            try:
+                content = (
+                    self._complete_via_responses(prompt) if self._use_responses
+                    else self._complete_via_chat(prompt)
+                )
+                self._cache_put(key, content)
+                return content, False
+            except BaseException as exc:
+                error = exc
+                status_code = getattr(exc, "status_code", None)
+                retryable = status_code == 429 or (
+                    isinstance(status_code, int) and 500 <= status_code < 600
+                )
+                # Connection/transport failures usually have no HTTP status.
+                if status_code is None:
+                    retryable = True
+                if retryable and attempt + 1 < self.max_attempts:
+                    time.sleep(min(2 ** (attempt + 1), 60) + random.uniform(0, 1))
+                    continue
+                break
+        raise JudgeRequestError(
+            f"Judge request failed after {self.max_attempts} attempts: {error}"
+        ) from error
+
+    @property
+    def cache_entries(self) -> int:
+        return len(self._cache)

eval/metrics.py

@@ -0,0 +1,155 @@
+"""Score parsing and aggregation.
+
+The headline metric is IF_Score: ``product(hard_pass) x mean(soft_scores)``. A
+single failed hard constraint zeroes the instance; soft constraints average into
+a 0-1 multiplier. Instances with no soft constraints use a multiplier of 1.0, so
+they score 1.0 or 0.0.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from collections import Counter, defaultdict
+from typing import Any
+
+SCORES = (0.0, 0.5, 1.0)
+
+
+def parse_quality_score(response: str) -> float | None:
+    """Parse a 0 / 0.5 / 1 quality verdict. Returns None if unparseable."""
+    text = (response or "").strip()
+    if text.startswith("[") and text.endswith("]"):
+        text = text[1:-1].strip()
+    if not re.fullmatch(r"(?:0(?:\.0+)?|0\.50*|1(?:\.0+)?)", text):
+        return None
+    return float(text)
+
+
+def parse_soft_constraint_scores(
+    response: str, constraint_ids: list[str]
+) -> dict[str, dict[str, Any]]:
+    """Parse the soft-constraint Judge's JSON verdict, keyed by constraint id."""
+    unscored = {cid: {"score": None} for cid in constraint_ids}
+    if not response:
+        return unscored
+
+    data = None
+    try:
+        data = json.loads(response.strip())
+    except json.JSONDecodeError:
+        # The Judge sometimes wraps the object in prose or a code fence.
+        match = re.search(r"\{[\s\S]*\}", response)
+        if match:
+            try:
+                data = json.loads(match.group(0))
+            except json.JSONDecodeError:
+                pass
+
+    if not isinstance(data, dict):
+        return unscored
+
+    results: dict[str, dict[str, Any]] = {}
+    for cid in constraint_ids:
+        entry = data.get(cid)
+        if isinstance(entry, dict):
+            try:
+                score = float(entry.get("score"))
+            except (TypeError, ValueError):
+                score = None
+            if score in (0, 0.5, 1):
+                results[cid] = {"score": score, "note": entry.get("note", "")}
+                continue
+        results[cid] = {"score": None}
+    return results
+
+
+def compute_if_score(
+    hard_results: dict[str, Any], soft_results: dict[str, Any]
+) -> float:
+    hard_pass = 1.0
+    for result in hard_results.values():
+        if not result.get("is_valid", True):
+            hard_pass = 0.0
+            break
+    soft_values = [r["score"] for r in soft_results.values() if r.get("score") is not None]
+    soft_mean = sum(soft_values) / len(soft_values) if soft_values else 1.0
+    return hard_pass * soft_mean
+
+
+def _score_key(score: float) -> str:
+    return "0" if score == 0 else "0.5" if score == 0.5 else "1"
+
+
+def aggregate_group(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    total = len(rows)
+    covered = sum(row["prediction_status"] == "present" for row in rows)
+    if_scores = [float(row["if_score"]) for row in rows]
+    quality = [row["quality_score"] for row in rows if row["quality_score"] is not None]
+    return {
+        "total": total,
+        "prediction_coverage": covered,
+        "prediction_coverage_rate": covered / total if total else 0.0,
+        "if_score": sum(if_scores) / total if total else 0.0,
+        "translation_quality": sum(quality) / len(quality) if quality else None,
+        "quality_scored": len(quality),
+        "quality_distribution": {
+            _score_key(s): sum(1 for q in quality if q == s) for s in SCORES
+        },
+    }
+
+
+def aggregate_constraints(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    """Per-constraint pass rate (hard) or mean score (soft)."""
+    hard: dict[str, Counter] = defaultdict(Counter)
+    soft: dict[str, list[float]] = defaultdict(list)
+
+    for row in rows:
+        for cid, result in row["hard_constraint_results"].items():
+            hard[cid]["total"] += 1
+            if result.get("is_valid", True):
+                hard[cid]["pass"] += 1
+        for cid, result in row["soft_constraint_results"].items():
+            if result.get("score") is not None:
+                soft[cid].append(float(result["score"]))
+
+    out: dict[str, Any] = {}
+    for cid, counts in sorted(hard.items()):
+        total = counts["total"]
+        out[cid] = {
+            "type": "hard",
+            "total": total,
+            "pass": counts["pass"],
+            "pass_rate": counts["pass"] / total if total else None,
+        }
+    for cid, scores in sorted(soft.items()):
+        out[cid] = {
+            "type": "soft",
+            "total": len(scores),
+            "mean_score": sum(scores) / len(scores) if scores else None,
+            "score_distribution": {
+                _score_key(s): sum(1 for v in scores if v == s) for s in SCORES
+            },
+        }
+    return out
+
+
+def compute_summary(rows: list[dict[str, Any]]) -> dict[str, Any]:
+    summary = aggregate_group(rows)
+    summary["by_constraint"] = aggregate_constraints(rows)
+
+    grouped: dict[str, dict[str, list[dict[str, Any]]]] = {
+        "scenario": defaultdict(list),
+        "domain": defaultdict(list),
+        "language_pair": defaultdict(list),
+    }
+    for row in rows:
+        grouped["scenario"][row["scenario"]].append(row)
+        grouped["domain"][row["domain"]].append(row)
+        grouped["language_pair"][f"{row['source_lang']}-{row['target_lang']}"].append(row)
+
+    summary["breakdowns"] = {
+        dimension: {key: aggregate_group(group) for key, group in sorted(groups.items())}
+        for dimension, groups in grouped.items()
+    }
+    return summary

eval/prompts.py

@@ -0,0 +1,170 @@
+"""Model input construction and Judge prompts.
+
+The model prompt is the dataset's own ``prompt`` field, sent verbatim: it already
+carries the task instruction, the source text and the numbered constraints, so
+rewriting it here would change what the benchmark measures.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+MODEL_PROMPT_VERSION = "insttrans-inference-v1"
+QUALITY_JUDGE_PROMPT_VERSION = "insttrans-quality-judge-v1"
+SOFT_CONSTRAINT_JUDGE_PROMPT_VERSION = "insttrans-soft-constraint-judge-v1"
+
+LANGUAGE_NAMES = {
+    "ar": "阿拉伯语", "de": "德语", "en": "英语", "es": "西班牙语",
+    "fil": "菲律宾语", "fr": "法语", "hi": "印地语", "id": "印尼语",
+    "it": "意大利语", "ja": "日语", "ko": "韩语", "ms": "马来语",
+    "nl": "荷兰语", "pl": "波兰语", "pt": "葡萄牙语", "ro": "罗马尼亚语",
+    "ru": "俄语", "sv": "瑞典语", "th": "泰语", "tr": "土耳其语",
+    "vi": "越南语", "zh": "中文",
+}
+
+
+def build_model_messages(row: dict[str, Any]) -> list[dict[str, str]]:
+    """Chat messages for the system under test. Sends `prompt` unchanged."""
+    return [{"role": "user", "content": row["prompt"]}]
+
+
+def _lang_name(code: str) -> str:
+    return LANGUAGE_NAMES.get(code, code)
+
+
+def build_quality_prompt(row: dict[str, Any], prediction: str) -> str:
+    """Translation-quality Judge prompt (0 / 0.5 / 1).
+
+    `web_html` instances get a variant that tells the Judge to score only the
+    visible text, because their source embeds HTML/JSON markup.
+    """
+    src_name = _lang_name(row["source_lang"])
+    tgt_name = _lang_name(row["target_lang"])
+    source_text = row["source_text"]
+    reference = row["reference"]
+
+    if row.get("scenario") == "web_html":
+        return f"""你是精通{src_name}和{tgt_name}的网页文本翻译质量评估专家。请仅从翻译准确性和流畅度角度评估以下<待评估译文>。
+注意：源文中包含HTML/JSON标签，这些标签是文本的一部分，评估时只关注可见文本的翻译质量。
+
+# 评估维度
+
+## 翻译准确性
+<严重错误>:
+- 可见文本的核心语义发生变化、漏译或严重误译。
+- 添加了原文中不存在的内容。
+
+<轻度错误>:
+- 专有名词翻译不准确。
+- 部分表达语义有偏移。
+
+## 译文流畅度
+<严重错误>:
+- 可见文本不通顺，无法正常阅读理解。
+
+<轻度错误>:
+- 用词不够自然，有翻译腔。
+- 语法有轻微瑕疵但不影响理解。
+
+# 评分标准
+评分时请考虑文本长度：短文本（1-3句）和长文本（10句以上）应使用相同的质量密度标准，即关注错误占比而非错误绝对数量。
+1分: 翻译准确自然，无严重错误。轻度错误占比极低（不超过总句数的10%）。
+0.5分: 无严重错误，轻度错误占比适中（约10%-30%的句子有轻度错误），整体可读。
+0分: 有严重错误；或轻度错误占比过高（超过30%的句子有轻度错误），严重影响整体质量。
+
+# 评估材料
+
+<源文>:
+{source_text}
+
+<参考译文>:
+{reference}
+
+<待评估译文>:
+{prediction}
+
+请将你的打分写在<输出>中，直接输出[0/0.5/1]中的数字，不要输出任何其他内容。
+<输出>:"""
+
+    return f"""你是精通{src_name}和{tgt_name}的翻译质量评估专家。请仅从翻译准确性和流畅度角度评估以下<待评估译文>，不评估格式、约束等方面。
+
+# 评估维度
+
+## 翻译准确性
+<严重错误>:
+- 核心语义发生变化，原文意思被曲解。
+- 重要内容漏译或严重误译。
+- 添加了原文中不存在的内容。
+
+<轻度错误>:
+- 专有名词翻译不准确。
+- 部分表达语义有偏移。
+
+## 译文流畅度
+<严重错误>:
+- 译文不通顺，无法正常阅读理解。
+- 出现目标语言中不自然的表达方式。
+
+<轻度错误>:
+- 用词不够自然，有翻译腔。
+- 语法有轻微瑕疵但不影响理解。
+
+# 评分标准
+评分时请考虑文本长度：短文本（1-3句）和长文本（10句以上）应使用相同的质量密度标准，即关注错误占比而非错误绝对数量。
+1分: 翻译准确自然，无严重错误，轻度错误极少。
+0.5分: 只有轻度错误，或仅有少量严重错误（不超过总句数的10%），整体可读。
+0分: 有大量严重错误（超过总句数的10%），严重影响整体质量。
+
+# 评估材料
+
+<源文>:
+{source_text}
+
+<参考译文>:
+{reference}
+
+<待评估译文>:
+{prediction}
+
+请将你的打分写在<输出>中，直接输出[0/0.5/1]中的数字，不要输出任何其他内容。
+<输出>:"""
+
+
+SOFT_CONSTRAINT_JUDGE_TEMPLATE = """请评估译文对每条约束的满足程度。
+
+【源文】
+{source_text}
+
+【译文】
+{target_text}
+
+【约束列表】
+{constraint_list}
+
+评分标准（每条约束三档）：
+- 1：完全满足
+- 0.5：部分满足（有小瑕疵但不影响理解）
+- 0：未满足或严重偏离
+
+如果译文中存在大���内容不断重复（同一句话或片段连续出现3次及以上），所有约束直接判0分。
+
+请输出JSON，以约束ID为key：
+{{
+    "constraint_id": {{
+      "score": 0或0.5或1,
+      "note": "简短说明"
+    }}
+}}
+
+只输出JSON，不要输出任何其他内容。"""
+
+
+def build_soft_constraint_prompt(
+    row: dict[str, Any], prediction: str, soft_descs: dict[str, str]
+) -> str:
+    constraint_list = "\n".join(f"[{cid}] {desc}" for cid, desc in soft_descs.items())
+    return SOFT_CONSTRAINT_JUDGE_TEMPLATE.format(
+        source_text=row["source_text"],
+        target_text=prediction,
+        constraint_list=constraint_list,
+    )

eval/syllable.py

@@ -0,0 +1,1232 @@
+import pyphen
+import re
+import threading
+import fugashi
+from num2words import num2words
+
+
+# ========== 工具模块：Pyphen 缓存 ==========
+
+class PyphenCache:
+    _instance = None
+    _cache = {}
+
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+        return cls._instance
+
+    def get_dictionary(self, lang_code):
+        if lang_code not in self._cache:
+            self._cache[lang_code] = pyphen.Pyphen(lang=lang_code)
+        return self._cache[lang_code]
+
+
+_pyphen_cache = PyphenCache()
+
+
+def _pyphen_syllable_count(word, pyphen_lang):
+    """使用 pyphen 计算音节数（带缓存，规范化处理）"""
+    # 规范化：去除尾部标点和连字符
+    clean_word = word.rstrip(".,;:!?()[]{}\"\'-")
+    normalized = clean_word.replace("-", "")  # 避免连字符被算作音节分隔
+
+    # 检查西语词典
+    if pyphen_lang == 'es_ES' and normalized.lower() in _SPANISH_SYLLABLES:
+        return _SPANISH_SYLLABLES[normalized.lower()]
+
+    try:
+        dic = _pyphen_cache.get_dictionary(pyphen_lang)
+        hyphenated = dic.inserted(normalized)
+        return hyphenated.count("-") + 1
+    except Exception:
+        return _fallback_syllable_count(normalized)
+
+def _fallback_syllable_count(word):
+    word = word.lower()
+    if len(word) <= 3:
+        return 1
+
+    count = 0
+    vowels = "aeiouy"
+
+    if word[0] in vowels:
+        count += 1
+
+    for i in range(1, len(word)):
+        if word[i] in vowels and word[i - 1] not in vowels:
+            count += 1
+
+    if word.endswith('e'):
+        count -= 1
+    if word.endswith('le') and len(word) > 2 and word[-3] not in vowels:
+        count += 1
+
+    return max(1, count)
+
+
+# ========== 混合内容解析器 ==========
+
+_SCRIPT_RANGES = [
+    (re.compile(r'[一-鿿㐀-䶿]'), 'han'),
+    (re.compile(r'[぀-ゟ゠-ヿ]'), 'kana'),
+    (re.compile(r'[ء-يٱ-ۓە-ۿ'
+                r'ݐ-ݿࢠ-ࣿ'
+                r'ﭐ-﷿ﹰ-]'), 'arabic'),
+    (re.compile(r'[ً-ٰٟٓ]'), 'arabic_diacritic'),
+    (re.compile(r'[a-zA-ZÀ-ÿŒœ]'), 'latin'),  # 包含扩展拉丁字母（包括 Œ/œ）
+    (re.compile(r'[0-9٠-٩０-９]'), 'number'),  # ASCII、阿拉伯语、全角数字
+]
+
+
+def _detect_script(char):
+    for pattern, script in _SCRIPT_RANGES:
+        if pattern.match(char):
+            return script
+    return 'other'
+
+
+def _parse_mixed_content(text):
+    if not text:
+        return []
+
+    segments = []
+    current_segment = ""
+    current_type = None
+
+    i = 0
+    while i < len(text):
+        char = text[i]
+        char_type = _detect_script(char)
+
+        # 处理数字相关的特殊格式
+        if char_type == 'number' or (char_type == 'other' and char in '.-/$'):
+            # 尝试匹配完整的数字格式（包括电话号码、小数、货币等）
+            number_match = re.match(r'[\d.,\-/$]+', text[i:])
+            if number_match:
+                number_str = number_match.group()
+                # 检查是否包含数字
+                if re.search(r'\d', number_str):
+                    # 检查是否是 COVID-19 这类字母+连字符+数字
+                    # 如果前面紧邻字母且以连字符开头，这是连字符词的一部分
+                    if number_str.startswith('-') and i > 0 and text[i-1].isalpha():
+                        # 这是连字符词的一部分，不单独处理
+                        if current_type:
+                            current_segment += char
+                        else:
+                            current_segment = char
+                            current_type = 'other'
+                        i += 1
+                        continue
+
+                    # 检查是否有序数后缀（st, nd, rd, th）
+                    ordinal_suffix = ''
+                    next_pos = i + len(number_str)
+                    if next_pos + 2 <= len(text):
+                        potential_suffix = text[next_pos:next_pos+2]
+                        if potential_suffix.lower() in ('st', 'nd', 'rd', 'th'):
+                            ordinal_suffix = potential_suffix
+
+                    if current_segment and current_type:
+                        segments.append((current_segment.strip(), current_type))
+
+                    # 如果有序数后缀，合并到数字中
+                    if ordinal_suffix:
+                        segments.append((number_str + ordinal_suffix, 'number'))
+                        i += len(number_str) + len(ordinal_suffix)
+                    else:
+                        segments.append((number_str, 'number'))
+                        i += len(number_str)
+
+                    current_segment = ""
+                    current_type = None
+                    continue
+
+        if char_type == 'other':
+            if char.isspace():
+                if current_type == 'latin':
+                    current_segment += char
+                    i += 1
+                    continue
+                elif current_segment:
+                    segments.append((current_segment.strip(), current_type))
+                    current_segment = ""
+                    current_type = None
+                i += 1
+                continue
+            if current_type:
+                current_segment += char
+            i += 1
+            continue
+
+        # arabic diacritics 归入 arabic
+        if char_type == 'arabic_diacritic':
+            char_type = 'arabic'
+
+        if char_type == current_type:
+            current_segment += char
+        else:
+            if current_segment:
+                segments.append((current_segment.strip(), current_type))
+            current_segment = char
+            current_type = char_type
+
+        i += 1
+
+    if current_segment and current_segment.strip():
+        segments.append((current_segment.strip(), current_type))
+
+    return segments
+
+
+# ========== 数字展开模块 ==========
+
+# num2words 语言代码映射
+_NUM2WORDS_LANG_MAP = {
+    'en': 'en',
+    'zh': 'zh',
+    'ja': 'ja',
+    'de': 'de',
+    'fr': 'fr',
+    'es': 'es',
+    'ar': 'ar',
+}
+
+# 英语字母发音音节数 (A=1, B=1, C=1, D=1, E=1, F=1, G=1, H=1, I=1,
+# J=1, K=1, L=1, M=1, N=1, O=1, P=1, Q=1, R=1, S=1, T=1, U=1,
+# V=1, W=3, X=1, Y=1, Z=1)
+_LETTER_SYLLABLES_EN = {
+    'A': 1, 'B': 1, 'C': 1, 'D': 1, 'E': 1, 'F': 1, 'G': 1, 'H': 1,
+    'I': 1, 'J': 1, 'K': 1, 'L': 1, 'M': 1, 'N': 1, 'O': 1, 'P': 1,
+    'Q': 1, 'R': 1, 'S': 1, 'T': 1, 'U': 1, 'V': 1, 'W': 3, 'X': 1,
+    'Y': 1, 'Z': 1,
+}
+
+
+def _is_year_like(num_str):
+    """判断数字是否可能是年份（1000-2099）"""
+    # 如果包含逗号，不是年份（是带千分位的数字）
+    if ',' in num_str:
+        return False
+    try:
+        n = int(num_str)
+        return 1000 <= n <= 2099 and len(num_str) == 4
+    except ValueError:
+        return False
+
+
+def _expand_year_en(year_str):
+    """英语年份特殊读法：2024 → twenty twenty-four"""
+    n = int(year_str)
+    if 2000 <= n <= 2009:
+        return num2words(n, lang='en')
+    if 2010 <= n <= 2099:
+        first = n // 100
+        second = n % 100
+        first_word = num2words(first, lang='en')
+        second_word = num2words(second, lang='en')
+        return f"{first_word} {second_word}"
+    # 1900-1999: nineteen ninety-nine
+    if 1000 <= n <= 1999:
+        first = n // 100
+        second = n % 100
+        first_word = num2words(first, lang='en')
+        if second == 0:
+            return f"{first_word} hundred"
+        second_word = num2words(second, lang='en')
+        return f"{first_word} {second_word}"
+    return num2words(n, lang='en')
+
+
+def _expand_number(num_str, lang):
+    """将数字字符串展开为对应语言的文字"""
+    # 处理特殊格式
+
+    # 处理英文序数后缀
+    ordinal_suffix = ''
+    if lang == 'en' and len(num_str) > 2:
+        last_two = num_str[-2:].lower()
+        if last_two in ('st', 'nd', 'rd', 'th'):
+            ordinal_suffix = last_two
+            num_str = num_str[:-2]
+
+    # 去除货币符号
+    num_str = num_str.lstrip('$¥€£')
+
+    # 处理千位分隔符和小数点（根据语言）
+    if lang in ('es', 'fr', 'de'):
+        # 欧洲大陆：逗号是小数点，点是千位分隔符
+        # 先去除千位分隔符（点）
+        num_str_temp = num_str.replace('.', '')
+        # 将逗号替换为点（标准化为英语格式）
+        num_str_clean = num_str_temp.replace(',', '.')
+    else:
+        # 英语/中文/阿拉伯语：点是小数点，逗号是千位分隔符
+        # 去除千位分隔符（逗号）
+        num_str_clean = num_str.replace(',', '')
+
+    # 处理小数
+    if '.' in num_str_clean:
+        parts = num_str_clean.split('.')
+        if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
+            try:
+                n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+                # 整数部分
+                result = num2words(int(parts[0]), lang=n2w_lang)
+                # 小数点的表达（根据语言）
+                if lang == 'zh':
+                    result += '点'
+                elif lang == 'es':
+                    result += ' coma'
+                elif lang == 'fr':
+                    result += ' virgule'
+                elif lang == 'de':
+                    result += ' Komma'
+                elif lang == 'ar':
+                    result += ' فاصلة'
+                else:
+                    result += ' point'
+                # 小数部分逐位读
+                for digit in parts[1]:
+                    if lang == 'zh':
+                        _ZH_DIGITS = '零一二三四五六七八九'
+                        result += _ZH_DIGITS[int(digit)]
+                    else:
+                        result += ' ' + num2words(int(digit), lang=n2w_lang)
+                return result
+            except Exception:
+                pass
+
+    # 处理日期（三段斜杠数字）
+    if '/' in num_str_clean:
+        parts = num_str_clean.split('/')
+        # 检查是否是日期格式（三段数字）
+        if len(parts) == 3 and all(p.isdigit() for p in parts):
+            try:
+                n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+                result_parts = []
+                for part in parts:
+                    result_parts.append(num2words(int(part), lang=n2w_lang))
+                return ' '.join(result_parts)
+            except Exception:
+                pass
+
+    # 处理分数
+    if '/' in num_str_clean:
+        parts = num_str_clean.split('/')
+        if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
+            try:
+                n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+                numerator_int = int(parts[0])
+                denominator_int = int(parts[1])
+
+                # 特殊处理常见分数
+                if lang == 'en':
+                    if numerator_int == 1 and denominator_int == 2:
+                        return "one half"
+                    elif numerator_int == 1 and denominator_int == 4:
+                        return "one quarter"
+                    elif numerator_int == 3 and denominator_int == 4:
+                        return "three quarters"
+
+                # 通用处理
+                numerator = num2words(numerator_int, lang=n2w_lang)
+                # 分母用序数
+                denominator = num2words(denominator_int, lang=n2w_lang, to='ordinal')
+                return f"{numerator} {denominator}"
+            except Exception:
+                pass
+
+    # 处理电话号码（连字符分隔的数字）
+    if '-' in num_str_clean and all(p.isdigit() for p in num_str_clean.split('-')):
+        # 电话号码逐位读
+        digits = num_str_clean.replace('-', '')
+        try:
+            n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+            if lang == 'zh':
+                _ZH_DIGITS = '零一二三四五六七八九'
+                return ''.join(_ZH_DIGITS[int(d)] for d in digits)
+            else:
+                result = []
+                for digit in digits:
+                    result.append(num2words(int(digit), lang=n2w_lang))
+                return ' '.join(result)
+        except Exception:
+            pass
+
+    # 处理纯整数
+    try:
+        n = int(num_str_clean)
+    except ValueError:
+        return num_str
+
+    # 检查是否是年份（使用原始字符串，包含逗号信息）
+    if lang == 'en' and _is_year_like(num_str):
+        return _expand_year_en(num_str_clean)
+
+    n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+
+    # 中文：逐位读数字（如电话号码、年份等场景更常见）
+    if lang == 'zh':
+        _ZH_DIGITS = '零一二三四五六七八九'
+        return ''.join(_ZH_DIGITS[int(d)] for d in num_str_clean)
+
+    try:
+        return num2words(n, lang=n2w_lang)
+    except Exception:
+        return num2words(n, lang='en')
+
+
+def _expand_decimal(text, lang):
+    """处理小数"""
+    n2w_lang = _NUM2WORDS_LANG_MAP.get(lang, 'en')
+    try:
+        n = float(text)
+        return num2words(n, lang=n2w_lang)
+    except Exception:
+        return text
+
+
+# ========== 缩写识别模块 ==========
+
+# 作为完整单词发音的缩写（不逐字母读）及其音节数
+_WORD_ACRONYMS = {
+    'NASA': 2, 'NATO': 2, 'ASAP': 4, 'IKEA': 3, 'OPEC': 2,
+    'FIFA': 2, 'UNESCO': 3, 'UNICEF': 3, 'NAFTA': 2, 'SARS': 1,
+    'AIDS': 1, 'RADAR': 2, 'LASER': 2, 'SCUBA': 2,
+    'PIN': 1, 'SIM': 1, 'RAM': 1, 'ROM': 1,
+    'LAN': 1, 'WAN': 1, 'JPEG': 2, 'GIF': 1,
+    'COVID': 2, 'COV': 1,  # COVID-19, SARS-CoV-2
+}
+
+# 已知缩写/品牌名的音节数
+_KNOWN_ABBREVIATIONS = {
+    # 品牌名
+    'iPhone': 2, 'iPad': 2, 'iPod': 2, 'iMac': 2,
+    'macOS': 3, 'iOS': 3, 'YouTube': 2, 'WiFi': 2,
+    'WhatsApp': 2, 'LinkedIn': 2, 'GitHub': 2, 'GitLab': 2,
+    'JavaScript': 3, 'TypeScript': 2, 'PowerPoint': 3,
+    'eBay': 2, 'PayPal': 2, 'FedEx': 2,
+
+    # 学位/职称缩写
+    'PhD': 3, 'Ph.D.': 3, 'Ph.D': 3,
+    'Dr': 2, 'Dr.': 2,  # Doctor
+    'Mr': 2, 'Mr.': 2,  # Mister
+    'Mrs': 2, 'Mrs.': 2,  # Missus
+    'Ms': 2, 'Ms.': 2,
+    'Prof': 2, 'Prof.': 2,  # Professor
+
+    # 技术缩写
+    'LaTeX': 2, 'MySQL': 3, 'PostgreSQL': 4,
+}
+
+
+def _is_spelled_out_acronym(word):
+    """判断是否是逐字母拼读的缩写"""
+    # 检查是否在作为单词发音的缩写列表中
+    if word.upper() in _WORD_ACRONYMS:
+        return False
+
+    clean = word.replace('.', '')
+    if len(clean) < 2:
+        return False
+
+    # 全大写缩写：USA, FBI, MIT
+    if clean.isupper() and 2 <= len(clean) <= 6:
+        return True
+
+    # 带点的缩写：U.S.A., Ph.D., Dr.
+    if '.' in word and all(c.isupper() or c == '.' for c in word):
+        return True
+
+    # Mixed-case 缩写识别
+    # 规则：至少2个大写字母，且大写字母占比 >= 50%
+    upper_count = sum(1 for c in clean if c.isupper())
+    alpha_count = sum(1 for c in clean if c.isalpha())
+
+    if alpha_count >= 2 and upper_count >= 2:
+        # PhD, eBay, iOS, macOS 等
+        upper_ratio = upper_count / alpha_count
+        if upper_ratio >= 0.5:
+            return True
+
+    return False
+
+
+def _abbreviation_syllable_count(word, lang='en'):
+    """计算缩写/品牌名的音节数"""
+    # 规范化：去除尾部标点
+    clean = word.rstrip('.,;:!?()[]{}"\'-')
+
+    # 先检查已知缩写词典（使用规范化后的 token）
+    if clean in _KNOWN_ABBREVIATIONS:
+        return _KNOWN_ABBREVIATIONS[clean]
+
+    # 作为单词发音的缩写（使用规范化后的 token）
+    upper = clean.upper()
+    if upper in _WORD_ACRONYMS:
+        return _WORD_ACRONYMS[upper]
+
+    # 逐字母拼读的缩写（使用规范化后的 token）
+    if _is_spelled_out_acronym(clean):
+        letters = [c for c in clean if c.isalpha()]
+        if lang == 'en':
+            return sum(_LETTER_SYLLABLES_EN.get(c.upper(), 1) for c in letters)
+        return len(letters)
+
+    return None
+
+
+# ========== 阿拉伯语音节计数（从原版保留并改进） ==========
+
+_AR_FATHA = 'َ'
+_AR_DAMMA = 'ُ'
+_AR_KASRA = 'ِ'
+_AR_SHORT_VOWELS = {_AR_FATHA, _AR_DAMMA, _AR_KASRA}
+
+_AR_FATHATAN = 'ً'
+_AR_DAMMATAN = 'ٌ'
+_AR_KASRATAN = 'ٍ'
+_AR_TANWEEN = {_AR_FATHATAN, _AR_DAMMATAN, _AR_KASRATAN}
+
+_AR_SUKUN = 'ْ'
+_AR_SHADDA = 'ّ'
+_AR_SUPERSCRIPT_ALEF = 'ٰ'
+
+_AR_DIACRITICS_RE = re.compile(r'[ً-ٰٟٓ]')
+
+_AR_ALEF = 'ا'
+_AR_WAW = 'و'
+_AR_YAA = 'ي'
+_AR_ALEF_MAQSURA = 'ى'
+
+_AR_ALEF_MADDA = 'آ'
+_AR_TAA_MARBUTA = 'ة'
+_AR_TATWEEL = 'ـ'
+
+_AR_LETTER_RE = re.compile(
+    r'[ء-غف-ي'
+    r'ً-ٰٟ'
+    r'ٱ-ۓە-ۿ'
+    r'ݐ-ݿࢠ-ࣿ'
+    r'ﭐ-﷿ﹰ-]+'
+)
+
+
+def _ar_is_letter(ch):
+    cp = ord(ch)
+    return ((0x0621 <= cp <= 0x063A)
+            or (0x0641 <= cp <= 0x064A)
+            or (0x0671 <= cp <= 0x06D3)
+            or (0x06D5 <= cp <= 0x06FF))
+
+
+def _ar_is_fully_vocalized(word):
+    consonant_count = 0
+    vocalized_count = 0
+    chars = list(word)
+    n = len(chars)
+
+    for i, ch in enumerate(chars):
+        if (_ar_is_letter(ch)
+                and ch not in (_AR_ALEF, _AR_WAW, _AR_YAA, _AR_ALEF_MAQSURA,
+                               _AR_ALEF_MADDA, _AR_TAA_MARBUTA)):
+            consonant_count += 1
+            if i + 1 < n and _AR_DIACRITICS_RE.match(chars[i + 1]):
+                vocalized_count += 1
+
+    if consonant_count == 0:
+        return False
+    return vocalized_count / consonant_count > 0.5
+
+
+def _ar_vocalized_syllables(word):
+    syllables = 0
+    covered = False
+
+    for i, ch in enumerate(word):
+        if ch in _AR_SHORT_VOWELS:
+            syllables += 1
+            covered = True
+        elif ch in _AR_TANWEEN:
+            syllables += 1
+            covered = True
+        elif ch == _AR_SUPERSCRIPT_ALEF:
+            if not covered:
+                syllables += 1
+            covered = False
+        elif ch == _AR_ALEF_MADDA:
+            syllables += 1
+            covered = False
+        elif ch in (_AR_ALEF, _AR_ALEF_MAQSURA):
+            if i > 0 and not covered:
+                syllables += 1
+            covered = False
+        elif _ar_is_letter(ch):
+            covered = False
+
+    return max(1, syllables)
+
+
+def _ar_unvocalized_syllables(word):
+    clean = _AR_DIACRITICS_RE.sub('', word)
+    clean = clean.replace(_AR_TATWEEL, '')
+    if not clean:
+        return 0
+
+    letters = list(clean)
+    n = len(letters)
+
+    if n == 0:
+        return 0
+    if n <= 2:
+        return 1
+
+    skeleton = []
+    for i, ch in enumerate(letters):
+        is_first = (i == 0)
+
+        if ch == _AR_ALEF_MAQSURA:
+            skeleton.append('V')
+        elif ch == _AR_ALEF_MADDA:
+            skeleton.append('V')
+        elif ch == _AR_ALEF:
+            skeleton.append('C' if is_first else 'V')
+        elif ch == _AR_TAA_MARBUTA:
+            skeleton.append('V')
+        elif ch in (_AR_WAW, _AR_YAA):
+            if (ch == _AR_YAA
+                    and i == n - 2
+                    and i + 1 < n
+                    and letters[i + 1] == _AR_TAA_MARBUTA):
+                skeleton.append('C')
+            elif (ch == _AR_WAW
+                    and i == n - 2
+                    and i + 1 < n
+                    and letters[i + 1] == _AR_TAA_MARBUTA):
+                skeleton.append('C')
+            elif is_first:
+                skeleton.append('C')
+            elif skeleton and skeleton[-1] == 'C':
+                skeleton.append('V')
+            else:
+                skeleton.append('C')
+        else:
+            skeleton.append('C')
+
+    v_positions = [i for i, x in enumerate(skeleton) if x == 'V']
+
+    if not v_positions:
+        return max(1, (len(skeleton) + 1) // 2)
+
+    syllables = len(v_positions)
+    syllables += v_positions[0] // 2
+
+    for k in range(1, len(v_positions)):
+        gap = v_positions[k] - v_positions[k - 1] - 1
+        syllables += gap // 2
+
+    post_c = len(skeleton) - v_positions[-1] - 1
+    if (post_c == 1
+            and len(v_positions) == 1
+            and v_positions[0] == 1
+            and len(skeleton) == 3):
+        syllables += 1
+    else:
+        syllables += post_c // 2
+
+    return max(1, syllables)
+
+
+def _arabic_word_syllables(word):
+    if not word:
+        return 0
+    if _AR_DIACRITICS_RE.search(word):
+        if _ar_is_fully_vocalized(word):
+            return _ar_vocalized_syllables(word)
+    return _ar_unvocalized_syllables(word)
+
+
+# ========== 日语音节计数（从原版保留并改进） ==========
+
+_DIGIT_TO_KANA = {
+    '0': 'ゼロ', '1': 'いち', '2': 'に', '3': 'さん', '4': 'よん',
+    '5': 'ご', '6': 'ろく', '7': 'なな', '8': 'はち', '9': 'きゅう'
+}
+
+# One Tagger per thread. MeCab keeps parse state on the Tagger, so sharing a
+# single instance across the evaluator's thread pool corrupts Japanese mora
+# counts nondeterministically -- only syllable_order reads them, so the symptom
+# was zh->ja instances flipping between runs at the default concurrency.
+_thread_state = threading.local()
+
+
+def _get_tagger():
+    tagger = getattr(_thread_state, "tagger", None)
+    if tagger is None:
+        tagger = fugashi.Tagger()
+        _thread_state.tagger = tagger
+    return tagger
+
+
+def _count_japanese_mora(token):
+    has_kana = any('぀' <= c <= 'ゟ' or '゠' <= c <= 'ヿ' for c in token)
+    if not has_kana:
+        return len(token)
+
+    mora_count = 0
+    i = 0
+    length = len(token)
+
+    while i < length:
+        char = token[i]
+        if i + 1 < length and token[i + 1] in 'ゃゅょャュョ':
+            mora_count += 1
+            i += 2
+        elif char in 'っッんンー':
+            mora_count += 1
+            i += 1
+        elif '぀' <= char <= 'ゟ' or '゠' <= char <= 'ヿ':
+            mora_count += 1
+            i += 1
+        else:
+            i += 1
+
+    return mora_count
+
+
+def _japanese_syllable_count(text):
+    total_mora = 0
+    parsed_nodes = _get_tagger()(text)
+    for word in parsed_nodes:
+        reading = getattr(word.feature, 'kana', None)
+        if reading is None:
+            reading = getattr(word.feature, 'pronBase', None)
+        if reading is None:
+            reading = word.surface
+
+        word_mora = _count_japanese_mora(reading)
+        total_mora += word_mora
+
+    return total_mora
+
+
+# ========== 各语言计算器 ==========
+
+
+# 西语常见词音节词典（pyphen 不准确的词）
+_SPANISH_SYLLABLES = {
+    'país': 2,      # pa-ís
+    'río': 2,       # rí-o
+    'pingüino': 3,  # pin-güi-no
+    'día': 2,       # dí-a
+    'María': 3,     # Ma-rí-a
+    'había': 3,     # ha-bí-a
+    'tenía': 3,     # te-ní-a
+    'podía': 3,     # po-dí-a
+    'decía': 3,     # de-cí-a
+    'hacía': 3,     # ha-cí-a
+    'raíz': 2,      # ra-íz
+    'maíz': 2,      # ma-íz
+    'baúl': 2,      # ba-úl
+    'Raúl': 2,      # Ra-úl
+}
+
+_PYPHEN_LANG_MAP = {
+    'en': 'en_US',
+    'de': 'de_DE',
+    'fr': 'fr_FR',
+    'es': 'es_ES',
+}
+
+
+def _count_european(text, lang):
+    """英、德、法、西等欧洲语言的音节计数"""
+    pyphen_lang = _PYPHEN_LANG_MAP.get(lang, 'en_US')
+
+    segments = _parse_mixed_content(text)
+    total = 0
+
+    for segment, script_type in segments:
+        if script_type == 'number':
+            expanded = _expand_number(segment, lang)
+            # 按空格和连字符分割
+            words = re.split(r'[\s\-]+', expanded)
+            for w in words:
+                clean_w = w.strip(',-')
+                if clean_w and clean_w.isalpha():
+                    total += _pyphen_syllable_count(clean_w, pyphen_lang)
+        elif script_type == 'latin':
+            words = segment.split()
+            for w in words:
+                abbr_count = _abbreviation_syllable_count(w, lang)
+                if abbr_count is not None:
+                    total += abbr_count
+                else:
+                    total += _pyphen_syllable_count(w, pyphen_lang)
+        elif script_type == 'han':
+            # 只计算汉字，不包括标点
+            han_chars = re.findall(r'[一-鿿]', segment)
+            total += len(han_chars)
+        elif script_type == 'arabic':
+            # 混合内容中的阿拉伯语
+            ar_words = _AR_LETTER_RE.findall(segment)
+            for w in ar_words:
+                total += _arabic_word_syllables(w)
+        elif script_type == 'kana':
+            # 混合内容中的日语假名
+            total += _japanese_syllable_count(segment)
+
+    return total
+
+
+
+
+def _expand_and_count_chinese(num_str):
+    """展开数字并计算中文音节数"""
+    # 处理小数
+    if '.' in num_str:
+        parts = num_str.split('.')
+        if len(parts) == 2 and parts[0].isdigit() and parts[1].isdigit():
+            count = 0
+            # 整数部分逐位读
+            for digit in parts[0]:
+                count += 1
+            # 小数点："点"
+            count += 1
+            # 小数部分逐位读
+            for digit in parts[1]:
+                count += 1
+            return count
+
+    # 其他数字格式：逐位读
+    digits = re.findall(r'\d', num_str)
+    return len(digits)
+
+
+def _count_chinese(text, lang='zh'):
+    """中文音节计数（改进版：处理数字和混合内容）"""
+    segments = _parse_mixed_content(text)
+    total = 0
+
+    for segment, script_type in segments:
+        if script_type == 'han':
+            # 只计算汉字，不包括标点
+            han_chars = re.findall(r'[一-鿿]', segment)
+            total += len(han_chars)
+        elif script_type == 'number':
+            # 统一使用 _expand_and_count_chinese 处理
+            total += _expand_and_count_chinese(segment)
+        elif script_type == 'latin':
+            words = segment.split()
+            for w in words:
+                abbr_count = _abbreviation_syllable_count(w, 'en')
+                if abbr_count is not None:
+                    total += abbr_count
+                else:
+                    total += _pyphen_syllable_count(w, 'en_US')
+        elif script_type == 'kana':
+            # 混合内容中的日语假名
+            total += _japanese_syllable_count(segment)
+        elif script_type == 'arabic':
+            # 混合内容中的阿拉伯语
+            ar_words = _AR_LETTER_RE.findall(segment)
+            for w in ar_words:
+                total += _arabic_word_syllables(w)
+
+    return total
+
+
+def _count_arabic(text, lang='ar'):
+    """阿拉伯语音节计数（改进版：处理混合内容）"""
+    segments = _parse_mixed_content(text)
+    total = 0
+
+    for segment, script_type in segments:
+        if script_type == 'arabic':
+            words = _AR_LETTER_RE.findall(segment)
+            for w in words:
+                total += _arabic_word_syllables(w)
+        elif script_type == 'number':
+            expanded = _expand_number(segment, 'ar')
+            ar_words = _AR_LETTER_RE.findall(expanded)
+            if ar_words:
+                for w in ar_words:
+                    total += _arabic_word_syllables(w)
+            else:
+                # num2words 可能返回拉丁字母，用英语计算
+                for w in expanded.split():
+                    if w.isalpha():
+                        total += _pyphen_syllable_count(w, 'en_US')
+        elif script_type == 'latin':
+            words = segment.split()
+            for w in words:
+                abbr_count = _abbreviation_syllable_count(w, 'en')
+                if abbr_count is not None:
+                    total += abbr_count
+                else:
+                    total += _pyphen_syllable_count(w, 'en_US')
+        elif script_type == 'han':
+            # 混合内容中的汉字
+            han_chars = re.findall(r'[一-鿿]', segment)
+            total += len(han_chars)
+        elif script_type == 'kana':
+            # 混合内容中的日语假名
+            total += _japanese_syllable_count(segment)
+
+    return total
+
+
+def _count_japanese_v2(text, lang='ja'):
+    """日语音节计数（改进版：处理混合内容）"""
+    segments = _parse_mixed_content(text)
+
+    # 合并连续的 han 和 kana 段落，让 fugashi 整体处理
+    merged_segments = []
+    i = 0
+    while i < len(segments):
+        segment, script_type = segments[i]
+
+        if script_type in ('han', 'kana'):
+            # 收集连续的 han/kana 段落
+            japanese_text = segment
+            j = i + 1
+            while j < len(segments) and segments[j][1] in ('han', 'kana'):
+                japanese_text += segments[j][0]
+                j += 1
+            merged_segments.append((japanese_text, 'japanese'))
+            i = j
+        else:
+            merged_segments.append((segment, script_type))
+            i += 1
+
+    # 计算音节
+    total = 0
+    for segment, script_type in merged_segments:
+        if script_type == 'japanese':
+            total += _japanese_syllable_count(segment)
+        elif script_type == 'number':
+            # 日语中数字通过 fugashi 处理更准确
+            total += _japanese_syllable_count(segment)
+        elif script_type == 'latin':
+            words = segment.split()
+            for w in words:
+                abbr_count = _abbreviation_syllable_count(w, 'en')
+                if abbr_count is not None:
+                    total += abbr_count
+                else:
+                    total += _pyphen_syllable_count(w, 'en_US')
+
+    return total
+
+
+# ========== 公共 API ==========
+
+def cal_syllable_count(text, lang='en'):
+    if not text or not text.strip():
+        return 0
+
+    text = text.strip()
+
+    if lang.lower() == 'zh':
+        return _count_chinese(text)
+    elif lang.lower() == 'ja':
+        return _count_japanese_v2(text)
+    elif lang.lower() == 'ar':
+        return _count_arabic(text)
+    else:
+        return _count_european(text, lang.lower())
+
+
+def cal_syllable_details(text, lang='en'):
+    """返回详细的音节分解信息"""
+    if not text or not text.strip():
+        return {
+            'total_syllables': 0,
+            'word_count': 0,
+            'syllables_per_word': 0,
+            'syllable_breakdown': []
+        }
+
+    text = text.strip()
+    total_syllables = cal_syllable_count(text, lang)
+
+    # 根据语言使用不同的分解策略
+    breakdown = []
+
+    if lang.lower() == 'zh':
+        # 中文：按混合内容分段
+        segments = _parse_mixed_content(text)
+        for segment, script_type in segments:
+            if script_type == 'han':
+                # 汉字逐个计数（只计算汉字，不包括标点）
+                han_chars = re.findall(r'[一-鿿]', segment)
+                for char in han_chars:
+                    breakdown.append({'word': char, 'syllables': 1})
+            elif script_type == 'number':
+                # 使用统一的计数逻辑
+                syllables = _expand_and_count_chinese(segment)
+                breakdown.append({
+                    'word': segment,
+                    'syllables': syllables,
+                })
+            elif script_type == 'latin':
+                words = segment.split()
+                for w in words:
+                    abbr_count = _abbreviation_syllable_count(w, 'en')
+                    if abbr_count is not None:
+                        syllables = abbr_count
+                    else:
+                        syllables = _pyphen_syllable_count(w, 'en_US')
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'kana':
+                # 混合内容中的日语假名
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+            elif script_type == 'arabic':
+                # 混合内容中的阿拉伯语
+                ar_words = _AR_LETTER_RE.findall(segment)
+                for w in ar_words:
+                    syllables = _arabic_word_syllables(w)
+                    breakdown.append({'word': w, 'syllables': syllables})
+
+    elif lang.lower() == 'ja':
+        # 日语：使用 fugashi 分词
+        segments = _parse_mixed_content(text)
+
+        # 合并连续的 han 和 kana 段落
+        merged_segments = []
+        i = 0
+        while i < len(segments):
+            segment, script_type = segments[i]
+            if script_type in ('han', 'kana'):
+                japanese_text = segment
+                j = i + 1
+                while j < len(segments) and segments[j][1] in ('han', 'kana'):
+                    japanese_text += segments[j][0]
+                    j += 1
+                merged_segments.append((japanese_text, 'japanese'))
+                i = j
+            else:
+                merged_segments.append((segment, script_type))
+                i += 1
+
+        # 对每个段落计算音节
+        for segment, script_type in merged_segments:
+            if script_type == 'japanese':
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+            elif script_type == 'number':
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+            elif script_type == 'latin':
+                words = segment.split()
+                for w in words:
+                    abbr_count = _abbreviation_syllable_count(w, 'en')
+                    if abbr_count is not None:
+                        syllables = abbr_count
+                    else:
+                        syllables = _pyphen_syllable_count(w, 'en_US')
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'han':
+                # 混合内容中的汉字
+                han_chars = re.findall(r'[一-鿿]', segment)
+                for char in han_chars:
+                    breakdown.append({'word': char, 'syllables': 1})
+            elif script_type == 'kana':
+                # 混合内容中的日语假名
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+
+    elif lang.lower() == 'ar':
+        # 阿拉伯语
+        segments = _parse_mixed_content(text)
+        for segment, script_type in segments:
+            if script_type == 'arabic':
+                words = _AR_LETTER_RE.findall(segment)
+                for w in words:
+                    syllables = _arabic_word_syllables(w)
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'number':
+                expanded = _expand_number(segment, 'ar')
+                ar_words = _AR_LETTER_RE.findall(expanded)
+                if ar_words:
+                    syllables = sum(_arabic_word_syllables(w) for w in ar_words)
+                else:
+                    # 英语展开
+                    syllables = sum(_pyphen_syllable_count(w, 'en_US') for w in expanded.split() if w.isalpha())
+                breakdown.append({
+                    'word': segment,
+                    'expanded': expanded,
+                    'syllables': syllables,
+                })
+            elif script_type == 'latin':
+                words = segment.split()
+                for w in words:
+                    abbr_count = _abbreviation_syllable_count(w, 'en')
+                    if abbr_count is not None:
+                        syllables = abbr_count
+                    else:
+                        syllables = _pyphen_syllable_count(w, 'en_US')
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'han':
+                # 混合内容中的汉字
+                han_chars = re.findall(r'[一-鿿]', segment)
+                for char in han_chars:
+                    breakdown.append({'word': char, 'syllables': 1})
+            elif script_type == 'kana':
+                # 混合内容中的日语假名
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+
+    else:
+        # 欧洲语言（英、德、法、西等）
+        pyphen_lang = _PYPHEN_LANG_MAP.get(lang.lower(), 'en_US')
+        segments = _parse_mixed_content(text)
+
+        for segment, script_type in segments:
+            if script_type == 'number':
+                expanded = _expand_number(segment, lang)
+                words = re.split(r'[\s\-]+', expanded)
+                syllables = 0
+                for w in words:
+                    clean_w = w.strip(',-')
+                    if clean_w and clean_w.isalpha():
+                        syllables += _pyphen_syllable_count(clean_w, pyphen_lang)
+                breakdown.append({
+                    'word': segment,
+                    'expanded': expanded,
+                    'syllables': syllables,
+                })
+            elif script_type == 'latin':
+                words = segment.split()
+                for w in words:
+                    abbr_count = _abbreviation_syllable_count(w, lang)
+                    if abbr_count is not None:
+                        syllables = abbr_count
+                    else:
+                        syllables = _pyphen_syllable_count(w, pyphen_lang)
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'han':
+                # 混合内容中的汉字
+                han_chars = re.findall(r'[一-鿿]', segment)
+                for char in han_chars:
+                    breakdown.append({'word': char, 'syllables': 1})
+            elif script_type == 'arabic':
+                # 混合内容中的阿拉伯语
+                ar_words = _AR_LETTER_RE.findall(segment)
+                for w in ar_words:
+                    syllables = _arabic_word_syllables(w)
+                    breakdown.append({'word': w, 'syllables': syllables})
+            elif script_type == 'kana':
+                # 混合内容中的日语假名
+                syllables = _japanese_syllable_count(segment)
+                breakdown.append({'word': segment, 'syllables': syllables})
+
+    word_count = len(breakdown)
+    avg_syllables = round(total_syllables / word_count, 2) if word_count > 0 else 0
+
+    return {
+        'total_syllables': total_syllables,
+        'word_count': word_count,
+        'syllables_per_word': avg_syllables,
+        'syllable_breakdown': breakdown,
+    }
+
+
+# ========== 测试入口 ==========
+
+if __name__ == "__main__":
+    # 基础测试用例（和原版一致）
+    test_cases = [
+        ("你好世界 Hello World", "zh"),
+        ("Hello World", "en"),
+        ("The quick brown fox jumps over the lazy dog", "en"),
+        ("Der schnelle braune Fuchs springt über den faulen Hund", "de"),
+        ("Le renard brun rapide saute par-dessus le chien paresseux", "fr"),
+        ("مرحبا بك في العالم", "ar"),
+    ]
+
+    # 数字展开测试
+    number_test_cases = [
+        ("2024", "en"),
+        ("100", "en"),
+        ("I have 3 cats", "en"),
+        ("2024年", "zh"),
+        ("我有100个苹果", "zh"),
+        ("123 مرحبا", "ar"),
+    ]
+
+    # 缩写测试
+    abbreviation_test_cases = [
+        ("USA", "en"),
+        ("BMW", "en"),
+        ("NASA", "en"),
+        ("iPhone", "en"),
+        ("The CEO of IBM", "en"),
+    ]
+
+    # 混合内容测试
+    mixed_test_cases = [
+        ("Hello世界2024年", "zh"),
+        ("iPhone 15 Pro Max", "en"),
+        ("مرحبا Hello 2024", "ar"),
+    ]
+
+    # 日语测试
+    japanese_test_cases = [
+        ("こんにちは", "ja"),
+        ("きょう", "ja"),
+        ("きっと", "ja"),
+        ("お母さん", "ja"),
+        ("コーヒー", "ja"),
+        ("東京", "ja"),
+        ("123", "ja"),
+        ("Hello世界", "ja"),
+    ]
+
+    print("=" * 70)
+    print("音节计数 V2 测试结果")
+    print("=" * 70)
+
+    for text, lang in test_cases:
+        count = cal_syllable_count(text, lang)
+        print(f"[{lang}] '{text}' → {count} 音节")
+
+    print("\n" + "=" * 70)
+    print("数字展开测试")
+    print("=" * 70)
+
+    for text, lang in number_test_cases:
+        count = cal_syllable_count(text, lang)
+        print(f"[{lang}] '{text}' → {count} 音节")
+
+    print("\n" + "=" * 70)
+    print("缩写识别测试")
+    print("=" * 70)
+
+    for text, lang in abbreviation_test_cases:
+        count = cal_syllable_count(text, lang)
+        print(f"[{lang}] '{text}' → {count} 音节")
+
+    print("\n" + "=" * 70)
+    print("混合内容测试")
+    print("=" * 70)
+
+    for text, lang in mixed_test_cases:
+        count = cal_syllable_count(text, lang)
+        details = cal_syllable_details(text, lang)
+        print(f"[{lang}] '{text}' → {count} 音节")
+        for item in details['syllable_breakdown']:
+            extra = f" (展开: {item['expanded']})" if 'expanded' in item else ""
+            print(f"    '{item['word']}': {item['syllables']} 音节{extra}")
+
+    print("\n" + "=" * 70)
+    print("日语测试")
+    print("=" * 70)
+
+    for text, lang in japanese_test_cases:
+        count = cal_syllable_count(text, lang)
+        print(f"[{lang}] '{text}' → {count} 音拍")
+
+    print("\n" + "=" * 70)

evaluate.py

@@ -0,0 +1,185 @@
+#!/usr/bin/env python3
+"""Score predictions for Instruction-Following Translation Bench.
+
+Reads a JSONL of {"case_id", "prediction"} rows, checks the five hard constraints
+with rules, scores the five soft constraints and translation quality with an LLM
+Judge, and writes per-instance scores plus aggregate metrics.
+"""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+from typing import Any
+
+from eval.constraints import (
+    SOFT_CONSTRAINT_IDS,
+    check_hard_constraints,
+    collect_soft_constraint_descs,
+)
+from eval.judge_client import JudgeClient, JudgeRequestError
+from eval.metrics import (
+    compute_if_score,
+    compute_summary,
+    parse_quality_score,
+    parse_soft_constraint_scores,
+)
+from eval.prompts import (
+    QUALITY_JUDGE_PROMPT_VERSION,
+    build_quality_prompt,
+    build_soft_constraint_prompt,
+)
+
+DEFAULT_DATA_FILE = Path(__file__).resolve().parent / "data/test.jsonl"
+DEFAULT_JUDGE_MODEL = "gpt-5.6-sol"
+DEFAULT_BASE_URL = "https://api.openai.com/v1"
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows = []
+    # split("\n"), not splitlines(): source text contains raw U+2028, which is
+    # legal inside a JSON string but is a line break to splitlines().
+    for line_number, line in enumerate(path.read_text(encoding="utf-8").split("\n"), 1):
+        if not line.strip():
+            continue
+        try:
+            rows.append(json.loads(line))
+        except json.JSONDecodeError as exc:
+            raise SystemExit(f"{path}:{line_number}: invalid JSON: {exc}") from exc
+    return rows
+
+
+def load_predictions(path: Path, valid_ids: set[str]) -> dict[str, str]:
+    predictions: dict[str, str] = {}
+    for row in read_jsonl(path):
+        case_id = row.get("case_id")
+        if case_id is None:
+            raise SystemExit(f"{path}: a prediction row is missing 'case_id'")
+        if case_id in predictions:
+            raise SystemExit(f"{path}: duplicate prediction for {case_id}")
+        if case_id not in valid_ids:
+            raise SystemExit(f"{path}: unknown case_id {case_id}")
+        prediction = row.get("prediction")
+        predictions[case_id] = prediction if isinstance(prediction, str) else ""
+    return predictions
+
+
+def score_row(
+    row: dict[str, Any], prediction: str, judge: JudgeClient | None
+) -> dict[str, Any]:
+    """Score one instance. Missing predictions score 0 without calling the Judge."""
+    present = bool(prediction.strip())
+
+    hard_results = check_hard_constraints(row, prediction) if present else {}
+
+    soft_results: dict[str, Any] = {}
+    soft_cids = [cid for cid in row["constraint_ids"] if cid in SOFT_CONSTRAINT_IDS]
+    if present and soft_cids and judge is not None:
+        soft_descs = collect_soft_constraint_descs(row["constraint_ids"], row["constraints"])
+        if soft_descs:
+            response, _ = judge.complete(
+                build_soft_constraint_prompt(row, prediction, soft_descs))
+            soft_results = parse_soft_constraint_scores(response, list(soft_descs))
+            if any(value["score"] is None for value in soft_results.values()):
+                raise ValueError("Judge returned incomplete or invalid soft-constraint scores")
+    elif present and soft_cids:
+        soft_results = {cid: {"score": None} for cid in soft_cids}
+
+    quality_score = None
+    if present and judge is not None:
+        response, _ = judge.complete(build_quality_prompt(row, prediction))
+        quality_score = parse_quality_score(response)
+        if quality_score is None:
+            raise ValueError("Judge quality response must be exactly 0, 0.5 or 1")
+
+    if_score = compute_if_score(hard_results, soft_results) if present else 0.0
+
+    return {
+        "case_id": row["case_id"],
+        "source_lang": row["source_lang"],
+        "target_lang": row["target_lang"],
+        "scenario": row["scenario"],
+        "domain": row["domain"],
+        "constraint_ids": row["constraint_ids"],
+        "prediction_status": "present" if present else "missing",
+        "if_score": if_score,
+        "quality_score": quality_score,
+        "hard_constraint_results": hard_results,
+        "soft_constraint_results": soft_results,
+    }
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--predictions", type=Path, required=True)
+    parser.add_argument("--output-dir", type=Path, required=True)
+    parser.add_argument("--data-file", type=Path, default=DEFAULT_DATA_FILE)
+    parser.add_argument("--judge-model", default=DEFAULT_JUDGE_MODEL)
+    parser.add_argument("--concurrency", type=int, default=8)
+    parser.add_argument("--limit", type=int, default=0,
+                        help="score only the first N instances (smoke check, not a formal result)")
+    parser.add_argument("--skip-judge", action="store_true",
+                        help="rule-only mode: hard constraints only, no Judge calls")
+    args = parser.parse_args()
+
+    rows = read_jsonl(args.data_file)
+    if args.limit:
+        rows = rows[: args.limit]
+
+    predictions = load_predictions(args.predictions, {row["case_id"] for row in rows})
+    missing = [row["case_id"] for row in rows if row["case_id"] not in predictions]
+    if missing and not args.limit:
+        print(f"warning: {len(missing)} instances have no prediction and will score 0",
+              file=sys.stderr)
+
+    judge = None
+    if not args.skip_judge:
+        judge = JudgeClient(
+            api_key=os.environ.get("JUDGE_API_KEY", ""),
+            base_url=os.environ.get("JUDGE_API_BASE", DEFAULT_BASE_URL),
+            model=args.judge_model,
+            prompt_version=QUALITY_JUDGE_PROMPT_VERSION,
+            cache_path=args.output_dir / "judge_cache.jsonl",
+        )
+
+    def work(row: dict[str, Any]) -> dict[str, Any]:
+        return score_row(row, predictions.get(row["case_id"], ""), judge)
+
+    try:
+        with ThreadPoolExecutor(max_workers=args.concurrency) as pool:
+            scored = list(pool.map(work, rows))
+    except JudgeRequestError as exc:
+        # Aborting beats silently turning provider failures into quality scores.
+        raise SystemExit(f"judge failure, aborting: {exc}") from exc
+
+    summary = compute_summary(scored)
+    summary["config"] = {
+        "judge_model": None if args.skip_judge else args.judge_model,
+        "quality_judge_prompt_version": QUALITY_JUDGE_PROMPT_VERSION,
+        "data_file": str(args.data_file),
+        "instances_scored": len(scored),
+        "formal_run": not args.limit and not args.skip_judge,
+    }
+
+    args.output_dir.mkdir(parents=True, exist_ok=True)
+    with (args.output_dir / "scores.jsonl").open("w", encoding="utf-8") as handle:
+        for row in scored:
+            handle.write(json.dumps(row, ensure_ascii=False) + "\n")
+    (args.output_dir / "summary.json").write_text(
+        json.dumps(summary, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
+
+    print(f"instances:        {summary['total']}")
+    print(f"coverage:         {summary['prediction_coverage']}/{summary['total']}")
+    print(f"IF_Score:         {summary['if_score']:.4f}")
+    if summary["translation_quality"] is not None:
+        print(f"quality:          {summary['translation_quality']:.4f}")
+    if not summary["config"]["formal_run"]:
+        print("note: subset or rule-only run, not a full-benchmark result")
+
+
+if __name__ == "__main__":
+    main()

manifest.json

@@ -0,0 +1,190 @@
+{
+  "schema_version": 1,
+  "name": "Instruction-Following Translation Bench",
+  "benchmark": "translation_instruction",
+  "benchmark_version": "v1",
+  "task": "translation",
+  "license": "cc-by-nc-4.0",
+  "splits": {
+    "test": 3000
+  },
+  "counts": {
+    "cases": 3000,
+    "source_languages": 21,
+    "target_languages": 22,
+    "language_pairs": 61,
+    "constraint_types": 10,
+    "constraint_annotations": 5402
+  },
+  "distributions": {
+    "constraint_id": {
+      "format_preserve": 2098,
+      "style_consistency": 633,
+      "syllable_order": 601,
+      "term_cross_sentence": 508,
+      "term_compliance": 502,
+      "academic_format_preserve": 412,
+      "social_preserve": 316,
+      "layout_break": 266,
+      "context_disambiguate": 42,
+      "coref_resolution": 24
+    },
+    "constraints_per_case": {
+      "1": 1307,
+      "2": 1138,
+      "3": 426,
+      "4": 104,
+      "5": 25
+    },
+    "scenario": {
+      "social": 922,
+      "doc_textbook": 575,
+      "novel": 303,
+      "pgc_subtitle": 302,
+      "column": 300,
+      "academic": 299,
+      "ugc_subtitle": 299
+    },
+    "domain": {
+      "B站动态": 320,
+      "小说": 303,
+      "ogv字幕": 302,
+      "弹幕": 302,
+      "评论": 300,
+      "专栏文章": 300,
+      "学术论文": 299,
+      "UGC字幕": 299,
+      "书籍": 293,
+      "网页文本": 282
+    },
+    "source_lang": {
+      "zh": 2419,
+      "en": 313,
+      "ja": 15,
+      "tr": 15,
+      "fil": 14,
+      "it": 14,
+      "nl": 14,
+      "hi": 14,
+      "de": 14,
+      "sv": 14,
+      "ar": 14,
+      "ko": 14,
+      "id": 14,
+      "fr": 14,
+      "es": 14,
+      "ro": 14,
+      "vi": 14,
+      "ru": 14,
+      "pl": 14,
+      "pt": 14,
+      "th": 14
+    },
+    "target_lang": {
+      "zh": 296,
+      "th": 132,
+      "pt": 132,
+      "tr": 131,
+      "it": 131,
+      "es": 130,
+      "ro": 130,
+      "vi": 130,
+      "ms": 130,
+      "de": 130,
+      "pl": 129,
+      "hi": 129,
+      "ru": 129,
+      "fr": 128,
+      "ko": 128,
+      "id": 128,
+      "sv": 128,
+      "ja": 128,
+      "nl": 128,
+      "fil": 128,
+      "ar": 127,
+      "en": 118
+    }
+  },
+  "constraint_taxonomy": {
+    "hard": [
+      "format_preserve",
+      "layout_break",
+      "term_compliance",
+      "syllable_order",
+      "social_preserve"
+    ],
+    "soft": [
+      "style_consistency",
+      "context_disambiguate",
+      "coref_resolution",
+      "term_cross_sentence",
+      "academic_format_preserve"
+    ]
+  },
+  "prompts": {
+    "model_prompt_version": "insttrans-inference-v1",
+    "quality_judge_prompt_version": "insttrans-quality-judge-v1",
+    "soft_constraint_judge_prompt_version": "insttrans-soft-constraint-judge-v1"
+  },
+  "files": {
+    "data/test.jsonl": {
+      "sha256": "fa47b65120a3c00e8c7e66bfdfe0dd75274de8d100dbd1ce0540d754bd5a4b63",
+      "rows": 3000
+    }
+  },
+  "redaction": {
+    "policy": "provenance identifiers and authorship removed; contact details in text masked with bare uppercase redaction tokens; everything the constraints score is left unchanged",
+    "removed_metadata_fields": [
+      "article_id",
+      "author",
+      "avid",
+      "batch_mode",
+      "book_name",
+      "book_title",
+      "category",
+      "chapter",
+      "chapter_name",
+      "cid",
+      "content_type",
+      "dynamic_id",
+      "dynm_url",
+      "file_path",
+      "language",
+      "mid",
+      "paper_title",
+      "pictures",
+      "pubtime_fans",
+      "raw",
+      "section_heading",
+      "section_index",
+      "summary",
+      "unique_key"
+    ],
+    "masked_in_text": {
+      "cases": 15,
+      "occurrences": {
+        "email": 12,
+        "phone": 40,
+        "qq_group": 3,
+        "wechat_id": 2
+      },
+      "placeholders": {
+        "phone": "PHONE_REDACTED",
+        "email": "EMAIL_REDACTED",
+        "qq_group": "QQ_GROUP_REDACTED",
+        "wechat_id": "WECHAT_ID_REDACTED"
+      },
+      "fields": [
+        "prompt",
+        "reference",
+        "source_text"
+      ]
+    },
+    "deliberately_kept": {
+      "mentions_and_hashtags": "scored by social_preserve; masking them would make the constraint unscoreable",
+      "urls": "inside the HTML that format_preserve scores; CDN filename digit runs were checked against source mid values, no overlap",
+      "bare_digit_runs": "timestamps, game ids and image dimensions are part of the text being translated",
+      "cases_with_mentions_in_source_text": 379
+    }
+  }
+}

prepare_inputs.py

@@ -0,0 +1,37 @@
+#!/usr/bin/env python3
+"""Export model inputs without exposing the reference translation to the model."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from eval.prompts import build_model_messages
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--data-file", type=Path,
+                        default=Path(__file__).resolve().parent / "data/test.jsonl")
+    parser.add_argument("--output", type=Path, required=True)
+    args = parser.parse_args()
+    if args.output.resolve() == args.data_file.resolve():
+        parser.error("--output must differ from --data-file")
+
+    # split("\n"), not splitlines(): source text contains raw U+2028, which is
+    # legal inside a JSON string but is a line break to splitlines().
+    rows = [json.loads(line) for line
+            in args.data_file.read_text(encoding="utf-8").split("\n") if line.strip()]
+    args.output.parent.mkdir(parents=True, exist_ok=True)
+    with args.output.open("w", encoding="utf-8") as handle:
+        for row in rows:
+            handle.write(json.dumps({
+                "case_id": row["case_id"],
+                "messages": build_model_messages(row),
+            }, ensure_ascii=False) + "\n")
+    print(f"Wrote {len(rows)} model inputs to {args.output}")
+
+
+if __name__ == "__main__":
+    main()

release_manifest.json

@@ -0,0 +1,71 @@
+{
+  "release_version": "public-v1",
+  "source_commit": "aa8b0b2473a712160d00c73460e065dbb93f2d78",
+  "changes": [
+    "Preserved data and model/Judge prompts",
+    "Rejected invalid quality and missing soft-constraint Judge verdicts",
+    "Corrected redaction-policy description"
+  ],
+  "files": {
+    ".gitignore": {
+      "size": 59,
+      "sha256": "b5c9e3ffb21c37794ca1a5be1feccf7c3bc647d32975dcd30e2cbd53d1342481"
+    },
+    "LICENSE": {
+      "size": 478,
+      "sha256": "b91bc996f6333ce709e87c822594cc869f7950089a2ea16034e213c465f27065"
+    },
+    "README.md": {
+      "size": 15750,
+      "sha256": "37f26b3e40781cd2256d2e74e0507d0bd5f21eae71dfdde5032d0cc2f10dc663"
+    },
+    "RELEASE_REVIEW.md": {
+      "size": 467,
+      "sha256": "5e6e41b5125d64af1fd4b31a2492e81b6ffa01374ff747bbef67418e32ab2e14"
+    },
+    "data/test.jsonl": {
+      "size": 28217329,
+      "sha256": "fa47b65120a3c00e8c7e66bfdfe0dd75274de8d100dbd1ce0540d754bd5a4b63"
+    },
+    "eval/__init__.py": {
+      "size": 70,
+      "sha256": "234ead7b864f2fa71729085b56bb7da890189d5b0e0735ae3a8e408c62ca693d"
+    },
+    "eval/constraints.py": {
+      "size": 13656,
+      "sha256": "00cd6f3bb140bfcfaebb1e281790331059aef9f9091b75213e33e67ecd3074e7"
+    },
+    "eval/judge_client.py": {
+      "size": 6974,
+      "sha256": "128a6e9d49059d9ccd184150a5b828857c401f4fa5c4ca6bb811a293d529cb8c"
+    },
+    "eval/metrics.py": {
+      "size": 5416,
+      "sha256": "0ea1a6f53161c5fe1e78dcd2185a9dc7dd1b486fbcfb37913b790e25efe114af"
+    },
+    "eval/prompts.py": {
+      "size": 5614,
+      "sha256": "31cb0335333c8a0bfebd2c12d078760468570a2548c03ef7296c307af24473a7"
+    },
+    "eval/syllable.py": {
+      "size": 40979,
+      "sha256": "aa0036d763fbce3db89225ab12f64f5f7dcdfb8fc5e40ab1d78ab5b4aea968f6"
+    },
+    "evaluate.py": {
+      "size": 7457,
+      "sha256": "519a021d16e2b42f8201f4f1e2a8d4782c568920573855eff8c58760f3d3e0f8"
+    },
+    "manifest.json": {
+      "size": 4414,
+      "sha256": "a96183a99e4b65b3dc7927262c65a18c2d9a69b298ecc1826264742e4b8196eb"
+    },
+    "prepare_inputs.py": {
+      "size": 1370,
+      "sha256": "3647aa8cec5442d645f5c6725ebda4bfcd51a16ab2135f5a898a2c190c909365"
+    },
+    "requirements.txt": {
+      "size": 148,
+      "sha256": "1331e4402ee21b315cda8a73a3d2f27a27c6fdf9def708f427cacdeeb95d78b4"
+    }
+  }
+}

requirements.txt

@@ -0,0 +1,6 @@
+datasets>=3.0,<5
+# >=1.66 for client.responses, which the Judge uses for reasoning models.
+openai>=1.66,<3
+pyphen>=0.14
+fugashi>=1.3
+num2words>=0.5