Add Math-Shepherd-614 test data and evaluation scripts

README.md

@@ -0,0 +1,74 @@
+---
+pretty_name: Math-Shepherd-614 (SOPO evaluation subset)
+task_categories:
+- text-classification
+tags:
+- math-shepherd
+- stepwise-verification
+- hallucination-detection
+data_files:
+- split: test
+  path: math_shepherd_614_test_20260327.parquet
+---
+
+# Math-Shepherd-614 evaluation subset
+
+This repository packages a **614-example** Math-Shepherd step-verification test subset and a runnable evaluation script. It is intended to document the evaluation data relevant to the [SOPO paper](https://arxiv.org/html/2610.32212) (Appendix F.4); the exact selection procedure and the authors' original Math-Shepherd scoring implementation have **not** been independently confirmed. The data file alone and the accompanying script should **not** be represented as independently reproducing the paper's 89.02 mean span-F1.
+
+## Dataset
+
+The Parquet file `math_shepherd_614_test_20260327.parquet` contains 614 rows with three columns:
+
+- `prompt`: the math problem.
+- `completions`: an ordered list of solution steps.
+- `labels`: one Boolean per step; `true` means correct and `false` means incorrect.
+
+The file has 1,794 correctly labeled and 1,395 incorrectly labeled steps. There are 334 examples with at least one incorrect step and 280 with no incorrect steps. Every row (including its step text and labels) was found as an exact match in the publicly available [`trl-lib/math_shepherd` test split](https://huggingface.co/datasets/trl-lib/math_shepherd). This demonstrates provenance at the *record* level; it does not prove how the original paper selected its subset. The Parquet file's SHA-256 is `e01fabbc80b99f01307aa9095b9e186f13cae392ed0bff983dcbdd61ee0d1087`.
+
+Load the dataset with `datasets` (install it separately with `python -m pip install datasets`), or read the Parquet file with `pyarrow`:
+
+```python
+from datasets import load_dataset
+
+test = load_dataset("OverwhelmingFit/SOPO-Math-Shepherd-614", split="test")
+print(len(test))  # 614
+```
+
+The repository is **private pending confirmation of the upstream data's redistribution terms**. Access requires authorization and a Hugging Face login (`hf auth login`); the code above works for authorized users. This release includes **test data only**; it is not a training split.
+
+## Evaluate using a local OpenAI-compatible vLLM endpoint
+
+Place `run_math_shepherd.py`, `sopo_eval_common.py`, the Parquet file, and `requirements.txt` in the **same directory**. Python 3.9+ is recommended.
+
+```bash
+python -m pip install -r requirements.txt
+python -m unittest discover -s . -p test_run_math_shepherd.py  # offline validation, no model server
+python run_math_shepherd.py \
+  --data-file math_shepherd_614_test_20260327.parquet \
+  --model-name YOUR_SERVED_MODEL_NAME \
+  --model-url http://localhost:7010/v1 \
+  --num-threads 32 \
+  --output-dir ./test_result
+```
+
+`--model-name` must match the model name exposed by your vLLM OpenAI-compatible server. The default endpoint is `http://localhost:7010/v1`, the default generation limit is 8,000 tokens, and a complete run should write 614 JSON Lines records plus a `_metric.json` file. The API client sends `api_key="EMPTY"` for local vLLM. Use `--max-samples N` only for a quick smoke test; it is **not** the full 614-example evaluation. You can recompute metrics from a saved run without contacting the model:
+
+```bash
+python run_math_shepherd.py --filepath ./test_result/YOUR_RUN.jsonl
+```
+
+The metric-only command writes a separate `_recomputed_metric.json` file and leaves the original `_metric.json` intact.
+
+The paper reports a mean over **10 inference runs**. To obtain comparable *run counts* with this script, invoke the full command 10 separate times, check each output's `test_data_size` is 614, and average the `metrics` entry for `All` → `span_level` → `f1` from the ten `_metric.json` files. This alone does **not** establish equivalence to the paper's unpublished prompt, decoding and scoring settings.
+
+### Exact scoring behavior of this implementation
+
+1. Concatenate `completions` with a **single newline** to form the evaluated response. Each step labeled `false` becomes a gold character span, including the separator newline following that step (except the last).
+2. Ask the model for a JSON `"hallucination list"` containing copied erroneous text spans; retry malformed responses up to three times (first attempt with temperature 0, retries at 0.4). Invalid model outputs abort the complete run rather than being silently scored as no hallucination.
+3. An empty list yields no predicted span. For a nonempty list, find the earliest successfully located text substring in the response. **Align this position using the starts of gold incorrect steps**, then predict the entire suffix from that aligned point to the response end. The overlap of predicted and gold character positions determines micro-aggregated span precision, recall, and F1. The script also reports case-level metrics.
+
+**Important limitation:** step 3 uses the gold annotations when constructing the predicted span. This is a *label-dependent scoring rule*, which can affect the resulting F1 and is not a standard gold-independent conversion of predictions to spans. We have not verified that this rule matches the SOPO authors' original Math-Shepherd protocol. Share results with the rule disclosed; do not label this implementation an exact reproduction of 89.02 without confirming the original protocol and running the original model.
+
+## Source and redistribution
+
+This subset's records match the `trl-lib/math_shepherd` test split, which attributes its processed format to the [Math-Shepherd project](https://huggingface.co/datasets/peiyi9979/Math-Shepherd). See the original dataset and paper for citations. The upstream TRL dataset card does not state a license; **confirm the applicable data terms before making a new public repository**. This dataset card does not assign a new license to third-party data.

math_shepherd_614_test_20260327.parquet

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

requirements.txt

@@ -0,0 +1,4 @@
+pyarrow>=14
+openai>=1.40,<1.60
+json-repair>=0.30
+tqdm>=4.66

run_math_shepherd.py

@@ -0,0 +1,531 @@
+"""
+Math-Shepherd 步进监督数据上的幻觉 span 评测。
+
+数据约定（见同目录 ``README.md``）：
+- ``prompt`` / ``pompt``：题目
+- ``completions``：与 ``labels`` **等长** 的逐步推理字符串列表
+- ``labels``：与逐步一一对应；**true = 该步正确（非幻觉）**，**false = 该步为幻觉**
+
+金标：将 ``completions`` 用 ``\\n`` 拼成整段 ``response``，对每个 ``labels[i] is False`` 的步骤，
+将该步在整段中的字符区间 ``[start, end)`` 记入金标 span。该实现的预测起点会
+参考金标错误步骤的起点；这是本脚本的评测规则，未证实与论文的原始实现一致。
+
+**预测解析（与本仓库其它 eval 不同）**：
+- ``parse_output`` 得到 ``hallucination list`` 后，若列表**为空** → 判为**无幻觉**；
+- 若**非空**：对每个元素在 ``response`` 中定位子串，取成功匹配中**最靠左的 start** ``P``，
+  再将 ``P`` **对齐**到金标 ``labels`` 各 span 的 ``start``：取满足 ``s <= P`` 的最大 ``s``；
+  若 ``P`` 早于所有金标步起点，则对齐为 ``min(金标 starts)``。最终预测幻觉区为
+  ``[aligned_start, len(steps_text))``，``steps_text`` 与输入拼接一致（``STEP_SEP.join(completions)``）。
+
+用法（与数据文件放在同一目录时）::
+
+  python run_math_shepherd.py --model-name /path/to/checkpoint --model-url http://localhost:7010/v1
+  python run_math_shepherd.py --filepath test_result/example.jsonl  # 仅重新计算指标
+"""
+
+from __future__ import annotations
+
+import argparse
+import collections
+import json
+import os
+import re
+import sys
+import traceback
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import datetime
+from glob import glob
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+import pyarrow.parquet as pq
+from tqdm import tqdm
+
+_EVAL_DIR = os.path.dirname(os.path.abspath(__file__))
+if _EVAL_DIR not in sys.path:
+    sys.path.insert(0, _EVAL_DIR)
+
+from sopo_eval_common import (  # noqa: E402
+    MODEL_URL,
+    _format_is_ok,
+    compute_multi_spans,
+    find_start_end_index,
+    labels_have_any_supervision,
+    parse_output,
+    print_metrics,
+    req_model_vllm,
+)
+# README「Data sample」中的案例，用作可选 few-shot
+FEWSHOT_README_EXAMPLE_JSON = {
+    "prompt": (
+        "Mr. Maxwell takes 1 hr to drive to work in the morning but 1 and half hours "
+        "to drive back home in the evening. If the morning and evening traffic is similar "
+        "and he drives at an average speed of 30mph in the morning, what is the average "
+        "speed of his return journey?"
+    ),
+    "completions": [
+        "Step 1: Mr. Maxwell takes 1 and half hour to drive back home in the evening so he takes 1+1/2 = <<1+1/2=90>>90 minutes to drive home.",
+        "Step 2: Mr. Maxwell takes 90 minutes to drive home and drives at an average speed of 30mph so he drives a distance of 90/30 = <<90/30=3>>3 miles.",
+        "Step 3: Mr. Maxwell drives 3 miles in the evening at an average speed of 30mph so his average speed for the return journey is 30+3 = <<30+3=33>>33mph. The answer is: 33",
+    ],
+    "labels": [True, False, False],
+}
+
+MATH_SHEPHERD_TASK = "QA"
+STEP_SEP = "\n"
+
+
+def _format_fewshot_block() -> str:
+    """README 案例，作为 few-shot 文本块。"""
+    ex = FEWSHOT_README_EXAMPLE_JSON
+    lines = [
+        "[Few-shot example]",
+        "Problem:",
+        ex["prompt"],
+        "",
+        "Step-by-step solution (each step may be correct or incorrect):",
+    ]
+    for i, (step, lab) in enumerate(zip(ex["completions"], ex["labels"]), 1):
+        tag = "CORRECT" if lab else "INCORRECT (hallucination in this step)"
+        lines.append(f"Step {i} [{tag}]: {step}")
+    lines.append("")
+    lines.append(
+        "(In the actual task below, you only output the JSON with hallucination list per instruction; "
+        "the above only illustrates step labels.)"
+    )
+    return "\n".join(lines)
+
+
+def row_prompt(row: Dict[str, Any]) -> str:
+    return str(row.get("prompt") or row.get("pompt") or "").strip()
+
+
+def row_completions(row: Dict[str, Any]) -> List[str]:
+    c = row.get("completions")
+    if c is None:
+        return []
+    if hasattr(c, "tolist"):
+        c = c.tolist()
+    if not isinstance(c, (list, tuple)):
+        return []
+    return [str(x) for x in c]
+
+
+def row_labels(row: Dict[str, Any]) -> List[bool]:
+    raw = row.get("labels")
+    if raw is None:
+        return []
+    if hasattr(raw, "tolist"):
+        raw = raw.tolist()
+    if not isinstance(raw, (list, tuple)):
+        return []
+    out: List[bool] = []
+    for x in raw:
+        if isinstance(x, bool):
+            out.append(x)
+        elif isinstance(x, (int, float)):
+            out.append(bool(int(x)))
+        elif isinstance(x, str):
+            out.append(x.strip().lower() in ("true", "1", "yes"))
+        else:
+            out.append(bool(x))
+    return out
+
+
+def completions_to_response_and_gold(
+    completions: List[str], labels: List[bool]
+) -> Tuple[str, List[Dict[str, int]]]:
+    """
+    将 steps 拼成 response；对每个 label==False 的步骤写入金标 span（字符级，与 STEP_SEP 一致）。
+    """
+    if len(completions) != len(labels):
+        raise ValueError(
+            f"completions 与 labels 须等长: {len(completions)} vs {len(labels)}"
+        )
+    gold: List[Dict[str, int]] = []
+    pos = 0
+    n = len(completions)
+    for i, step in enumerate(completions):
+        start = pos
+        end = pos + len(step) + (len(STEP_SEP) if i < n - 1 else 0)
+        if not labels[i]:
+            gold.append({"start": start, "end": end})
+        pos = end
+    response = STEP_SEP.join(completions)
+    if len(response) != pos and n > 0:
+        # 理论上应相等；防御
+        pass
+    return response, gold
+
+
+def build_math_shepherd_input_str(prompt: str, completions: List[str]) -> str:
+    steps_text = STEP_SEP.join(completions)
+    return (
+        f"Below is a question:\n{prompt}\n"
+        f"Below is an answer:\n{steps_text}\n"
+        """Your task is to identify logical inconsistencies, calculation errors, or hallucinations in the mathematical steps provided. First, perform a step-by-step verification of the reasoning process using the following format:
+
+Step 1: < verify the first mathematical transition/calculation >
+Step 2: < verify the subsequent logic and result >
+...(add as many steps as needed)
+
+Then, compile any identified incorrect segments into a JSON dict. The "hallucination list" must contain the specific text spans from the input that are mathematically invalid. If the steps are entirely correct, leave the value as an empty list: {"hallucination list": []}. Otherwise, use this format: {"hallucination list": ["wrong span 1", "wrong span 2"]}."""
+#         """Your task is to determine whether the answer contains errors or hallucinations. First, provide reasoning with the following format:
+# ## Step 1: < your first reasoning step >
+# ## Step 2: < your next reasoning step >
+# ...(add as many steps as needed)
+# Then, compile the labeled hallucinated spans or error spans into a JSON dict, with a key hallucination list and its value is a list of hallucinated spans or error spans. If there are potential hallucinations or errors, the output should be in the following JSON format: {"hallucination list": [error span1, error span2, ...]}. Otherwise, leave the value as an empty list as follows: {"hallucination list": []}."""
+)
+
+
+def build_user_instruction(
+    prompt: str,
+    completions: List[str],
+    reasoning: bool,
+    fewshot: bool,
+) -> str:
+    if fewshot:
+        ins_ori = _format_fewshot_block() + "\n\n---\n\n" + build_math_shepherd_input_str(
+            prompt, completions
+        )
+    else:
+        ins_ori = build_math_shepherd_input_str(prompt, completions)
+    if not reasoning:
+        ins_ori = ins_ori.rsplit("Your task", 1)[0] + (
+            'Your task is to identify mathematically incorrect steps in the answer. '
+            'Return only a JSON dict containing the exact erroneous text spans: '
+            '{"hallucination list": ["wrong span 1"]}. '
+            'If all steps are correct, return {"hallucination list": []}.'
+        )
+    return ins_ori
+
+
+def align_pred_start_to_gold_step_starts(
+    min_s: int, gold_labels: List[Dict[str, Any]]
+) -> int:
+    """
+    将模型子串匹配得到的最左 start ``min_s``，对齐到金标步边界：
+    在 ``gold_labels`` 中所有 ``start`` 里，取满足 ``s <= min_s`` 的**最大** ``s``
+   （即 ``min_s`` 左侧最近的步起点，含相等）；若 ``min_s`` 早于任一金标步起点，
+    则回退为 ``min(gold_starts)``。无金标时返回 ``min_s``。
+    """
+    if not gold_labels:
+        return min_s
+    gold_starts = sorted({int(l["start"]) for l in gold_labels})
+    left = [s for s in gold_starts if s <= min_s]
+    if left:
+        return max(left)
+    return gold_starts[0]
+
+
+def cal_metrics_math_shepherd(
+    response: str,
+    labels: List[Dict[str, Any]],
+    output_list: List[str],
+    completions: Optional[List[str]] = None,
+) -> Tuple[int, int, int, int, int, int, int]:
+    """
+    金标 spans 与通用 eval 相同；预测侧：空列表则无幻觉；否则取各子串最左 start，
+    再对齐到金标步 ``start``，最后预测幻觉区为 ``[aligned_start, len(steps_text))``，
+    其中 ``steps_text = STEP_SEP.join(completions)``（与 ``build_math_shepherd_input_str`` 一致）。
+    若未传 ``completions``（旧 jsonl），则右端退化为 ``len(response)``。
+    """
+    ground_truth_span: List[Tuple[int, int]] = [
+        (int(l["start"]), int(l["end"])) for l in labels
+    ]
+
+    predict_span: List[Tuple[int, int]] = []
+    if output_list:
+        starts: List[int] = []
+        for out in output_list:
+            if not isinstance(out, str):
+                continue
+            tup = find_start_end_index(response, out, strict=False)
+            if tup != (-1, -1):
+                starts.append(tup[0])
+        if starts:
+            min_s = min(starts)
+            aligned = align_pred_start_to_gold_step_starts(min_s, labels)
+
+            end_len = (
+                len(STEP_SEP.join(str(c) for c in completions))
+                if completions is not None
+                else len(response)
+            )
+            predict_span.append((aligned, end_len))
+    match_size, prediction, groud_truth = compute_multi_spans(
+        ground_truth_span, predict_span
+    )
+
+    pos_true_cnt, neg_true_cnt, neg_false_cnt, pos_false_cnt = 0, 0, 0, 0
+    if output_list != [] and labels != []:
+        pos_true_cnt += 1
+    elif output_list == [] and labels != []:
+        neg_true_cnt += 1
+    elif output_list == [] and labels == []:
+        neg_false_cnt += 1
+    elif output_list != [] and labels == []:
+        pos_false_cnt += 1
+    else:
+        raise RuntimeError(
+            f"unexpected case output_list={output_list!r} labels={labels!r}"
+        )
+
+    return (
+        match_size,
+        prediction,
+        groud_truth,
+        pos_true_cnt,
+        neg_true_cnt,
+        neg_false_cnt,
+        pos_false_cnt,
+    )
+
+
+def evaluate_math_shepherd_results(
+    results: List[Dict[str, Any]],
+    record: Dict[str, int],
+    filepath: str,
+) -> List[Dict[str, Any]]:
+    chosen: Sequence[str] = ["Math", "All"]
+    for sample in results:
+        response = sample["response"]
+        labels = sample["labels"]
+        output = sample["output"]
+        task = sample.get("task_type") or "Math"
+        res = cal_metrics_math_shepherd(
+            response, labels, output, sample.get("completions")
+        )
+        (
+            temp_tp,
+            temp_pred_len,
+            temp_gold_len,
+            pos_true_cnt,
+            neg_true_cnt,
+            neg_false_cnt,
+            pos_false_cnt,
+        ) = res
+        for task_cur in chosen:
+            if task_cur == task or task_cur == "All":
+                record["match_size_" + task_cur] += temp_tp
+                record["prediction_" + task_cur] += temp_pred_len
+                record["groud_truth_" + task_cur] += temp_gold_len
+                record["pos_true_cnt_" + task_cur] += pos_true_cnt
+                record["neg_true_cnt_" + task_cur] += neg_true_cnt
+                record["neg_false_cnt_" + task_cur] += neg_false_cnt
+                record["pos_false_cnt_" + task_cur] += pos_false_cnt
+    all_metrics: List[Dict[str, Any]] = []
+    for task_cur in chosen:
+        all_metrics.append(print_metrics(task_cur, record))
+    print("chosen task: {}".format(list(chosen)))
+    print("filepath: {}".format(filepath))
+    print("test_data_size: {}".format(len(results)))
+    return all_metrics
+
+
+def iter_parquet_rows(paths: List[str]):
+    idx = 0
+    for path in paths:
+        pf = pq.ParquetFile(path)
+        for batch in pf.iter_batches(batch_size=256):
+            d = batch.to_pydict()
+            if not d:
+                continue
+            keys = list(d.keys())
+            n = len(d[keys[0]])
+            for i in range(n):
+                row = {k: d[k][i] for k in keys}
+                yield idx, row
+                idx += 1
+
+
+def resolve_test_parquets(data_dir: str) -> List[str]:
+    paths = sorted(glob(os.path.join(data_dir, "test*.parquet")))
+    paths += sorted(glob(os.path.join(data_dir, "math_shepherd*.parquet")))
+    return sorted(set(paths))
+
+
+def process_single_item(
+    d: Dict[str, Any],
+    row_key: str,
+    model_name: str,
+    model_url: str,
+    max_tokens: int,
+    reasoning: bool,
+    fewshot: bool,
+) -> Optional[Dict[str, Any]]:
+    prompt = row_prompt(d)
+    completions = row_completions(d)
+    labels = row_labels(d)
+    if not prompt or not completions:
+        return None
+    if len(completions) != len(labels):
+        print(
+            f"skip {row_key}: completions/labels length mismatch "
+            f"{len(completions)} vs {len(labels)}",
+            file=sys.stderr,
+        )
+        return None
+    try:
+        response, gold_spans = completions_to_response_and_gold(completions, labels)
+        instruction = build_user_instruction(prompt, completions, reasoning, fewshot)
+        raw = req_model_vllm(
+            instruction, model_name=model_name, model_url=model_url, max_tokens=max_tokens
+        )
+        if not _format_is_ok(raw):
+            raise ValueError("model output could not be parsed after retries")
+        output_parsed = parse_output(raw)
+        if not isinstance(output_parsed, list) or not all(
+            isinstance(x, str) for x in output_parsed
+        ):
+            raise ValueError("hallucination list must be a list of strings")
+        return {
+            "id": row_key,
+            "response": response,
+            "labels": gold_spans,
+            "output": output_parsed,
+            "output_raw": raw,
+            "task_type": "Math",
+            "prompt": prompt,
+            "completions": completions,
+            "step_labels": labels,
+            "pred_rule": "empty_hallucination_list=>no_hallucination; "
+            "else min_matched_start_then_align_to_gold_step_start_then_suffix_to_eof",
+        }
+    except Exception as e:
+        print(f"Error {row_key}: {e}")
+        traceback.print_exc()
+        return None
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser()
+    input_group = parser.add_mutually_exclusive_group()
+    input_group.add_argument(
+        "--data-file",
+        default=os.path.join(_EVAL_DIR, "math_shepherd_614_test_20260327.parquet"),
+        help="Math-Shepherd Parquet file (default: file next to this script)",
+    )
+    input_group.add_argument(
+        "--data-dir",
+        help="Directory of test*.parquet / math_shepherd*.parquet files",
+    )
+    parser.add_argument("--filepath", default="", help="Existing JSONL; recompute metrics only")
+    parser.add_argument("--model-name", help="Model identifier served by the OpenAI-compatible API")
+    parser.add_argument("--model-url", default=MODEL_URL, help="OpenAI-compatible vLLM base URL")
+    parser.add_argument("--model-prefix", default="", help="Optional result filename prefix")
+    parser.add_argument("--output-dir", default=os.path.join(_EVAL_DIR, "test_result"))
+    parser.add_argument("--max-tokens", type=int, default=8000)
+    parser.add_argument("--num-threads", "--num_threads", type=int, default=32)
+    parser.add_argument(
+        "--max-samples", "--max_samples", type=int, default=0,
+        help=">0 processes first N rows only",
+    )
+    parser.add_argument(
+        "--no-reasoning",
+        action="store_true",
+        help="Omit the reasoning template; ask for JSON only",
+    )
+    parser.add_argument(
+        "--fewshot",
+        action="store_true",
+        help="在题目前拼接 README 中的案例作为 few-shot",
+    )
+    args = parser.parse_args()
+    metrics_only = bool(args.filepath)
+    reasoning = not args.no_reasoning
+    if not args.filepath and not args.model_name:
+        parser.error("--model-name is required for inference; use --filepath for metric-only mode")
+    if args.num_threads < 1 or args.max_tokens < 1 or args.max_samples < 0:
+        parser.error("--num-threads and --max-tokens must be positive; --max-samples must be nonnegative")
+
+    results: List[Dict[str, Any]] = []
+
+    if not args.filepath:
+        paths = resolve_test_parquets(args.data_dir) if args.data_dir else [args.data_file]
+        if not paths or not all(os.path.isfile(path) for path in paths):
+            parser.error(f"Parquet data not found: {paths}; specify --data-file or --data-dir")
+
+        rows: List[Tuple[str, Dict[str, Any]]] = []
+        for global_idx, d in iter_parquet_rows(paths):
+            if args.max_samples and len(rows) >= args.max_samples:
+                break
+            rows.append((str(global_idx), d))
+
+        total_items = len(rows)
+        with ThreadPoolExecutor(max_workers=args.num_threads) as ex:
+            futs = {
+                ex.submit(
+                    process_single_item,
+                    d,
+                    rk,
+                    args.model_name,
+                    args.model_url,
+                    args.max_tokens,
+                    reasoning,
+                    args.fewshot,
+                ): rk
+                for rk, d in rows
+            }
+            with tqdm(total=total_items, desc="math_shepherd") as pbar:
+                for fut in as_completed(futs):
+                    res = fut.result()
+                    if res is not None:
+                        results.append(res)
+                    pbar.update(1)
+        if len(results) != total_items:
+            raise RuntimeError(
+                f"Only {len(results)}/{total_items} rows evaluated; refusing incomplete metrics. "
+                "Check errors above and retry."
+            )
+        results.sort(key=lambda x: int(x["id"]))
+        _date = datetime.now().strftime("%Y%m%d_%H%M%S_%f")
+        out_dir = args.output_dir
+        os.makedirs(out_dir, exist_ok=True)
+        basename = re.sub(
+            r"[^a-zA-Z0-9_.-]+", "_", f"{args.model_prefix}_{args.model_name}"
+        ).strip("._")
+        output_path = os.path.join(
+            out_dir,
+            f"{basename}_math_shepherd_test_{_date}.jsonl",
+        )
+        with open(output_path, "w", encoding="utf-8") as f:
+            for res in results:
+                f.write(json.dumps(res, ensure_ascii=False) + "\n")
+        args.filepath = output_path
+    else:
+        with open(args.filepath, "r", encoding="utf-8") as f:
+            for line in f:
+                results.append(json.loads(line))
+
+    if not labels_have_any_supervision(results):
+        print("警告: 结果中无任何 gold labels，跳过指标计算。")
+        return
+
+    record: Dict[str, int] = collections.defaultdict(int)
+    all_metrics = evaluate_math_shepherd_results(results, record, args.filepath)
+
+    output_path_metric = os.path.splitext(args.filepath)[0] + (
+        "_recomputed_metric.json" if metrics_only else "_metric.json"
+    )
+    metrics_output = {
+        "filepath": args.filepath,
+        "data_files": paths if not metrics_only else None,
+        "test_data_size": len(results),
+        "model_name": args.model_name,
+        "model_url": args.model_url if not metrics_only else None,
+        "max_tokens": args.max_tokens if not metrics_only else None,
+        "num_threads": args.num_threads if not metrics_only else None,
+        "fewshot": args.fewshot if not metrics_only else None,
+        "reasoning_suffix": reasoning if not metrics_only else None,
+        "pred_rule": "empty_hallucination_list=>no_hallucination; "
+        "else min_matched_start_then_align_to_gold_step_start_then_suffix_to_eof",
+        "metrics": all_metrics,
+        "timestamp": datetime.now().strftime("%Y%m%d_%H%M%S"),
+    }
+    with open(output_path_metric, "w", encoding="utf-8") as f:
+        json.dump(metrics_output, f, ensure_ascii=False, indent=2)
+    print(f"\nMetrics saved to: {output_path_metric}")
+
+
+if __name__ == "__main__":
+    main()

sopo_eval_common.py

@@ -0,0 +1,476 @@
+"""与 run_ragtruth.py 对齐的幻觉 span 评估与解析逻辑（供 eval 脚本复用）。"""
+
+from __future__ import annotations
+
+import collections
+import json
+import re
+import traceback
+from typing import Any, Dict, List, Optional, Sequence, Tuple
+
+import json_repair
+from openai import OpenAI
+import threading
+
+_thread_local = threading.local()
+_client_lock = threading.Lock()
+_shared_clients = {}
+
+
+def _get_openai_client(model_url: str) -> OpenAI:
+    """Reuse OpenAI/httpx clients to avoid FD exhaustion under thread pools."""
+    with _client_lock:
+        client = _shared_clients.get(model_url)
+        if client is None:
+            client = OpenAI(api_key="EMPTY", base_url=model_url, timeout=None)
+            _shared_clients[model_url] = client
+        return client
+
+
+MODEL_URL = "http://localhost:7010/v1"
+
+TASK_TYPE_TO_INSTRUCTION = {
+    "QA": "answer",
+    "Data2txt": "article",
+    "Summary": "summary",
+}
+
+SAVE_DIR = "test_result_0506"
+
+extra_sft_prompt_reasoning = """Your task is to determine whether the <|task_word|> contains hallucinations. First, provide reasoning with the following format:
+## Step 1: < your first reasoning step >
+## Step 2: < your next reasoning step >
+...(add as many steps as needed)
+Then, compile the labeled hallucinated spans into a JSON dict, with a key hallucination list and its value is a list of hallucinated spans. If there are potential hallucinations, the output should be in the following JSON format: {"hallucination list": [hallucination span1, hallucination span2, ...]}. Otherwise, leave the value as an empty list as follows: {"hallucination list": []}."""
+
+extra_sft_prompt = """Your task is to determine whether the <|task_word|> contains hallucinations. Then, compile the labeled hallucinated spans into a JSON dict, with a key hallucination list and its value is a list of hallucinated spans. If there are potential hallucinations, the output should be in the following JSON format: {"hallucination list": [hallucination span1, hallucination span2, ...]}. Otherwise, leave the value as an empty list as follows: {"hallucination list": []}."""
+
+
+# 格式错误重试相关常量：首次 attempt 用 temperature=0（贪心、可复现），
+# 第 2/3 次重试切到 RETRY_TEMPERATURE 引入随机性以摆脱反复输出错误格式。
+MAX_GEN_ATTEMPTS = 3
+RETRY_TEMPERATURE = 0.4
+_HALLU_LIST_REGEX = re.compile(r"""{"hallucination list": \[.*?\]}""")
+
+
+def _format_is_ok(output_str: str) -> bool:
+    """
+    与 ``parse_output`` 等价的"格式校验"快速通道：
+    1) 至少要能匹配到一个 ``{"hallucination list": [...]}`` 片段；
+    2) 取最后一个片段经 ``json_repair`` 解析后，必须是含 ``hallucination list`` 键的 dict 或本身是 list。
+    任一条不满足则视为格式错误，调用方据此决定是否重试。
+    """
+    if not isinstance(output_str, str) or not output_str:
+        return False
+    matches = _HALLU_LIST_REGEX.findall(output_str)
+    if not matches:
+        return False
+    try:
+        parsed = json_repair.loads(matches[-1])
+    except Exception:
+        return False
+    if isinstance(parsed, dict) and "hallucination list" in parsed:
+        return True
+    if isinstance(parsed, list):
+        return True
+    return False
+
+
+def req_model_vllm_with_finish_reason(
+    query: str,
+    model_name: str,
+    model_url: str = MODEL_URL,
+    max_tokens: int = 4000,
+    temperature: float = 0.0,
+) -> Tuple[str, Optional[str]]:
+    """
+    与 ``req_model_vllm`` 相同请求，额外返回 vLLM/OpenAI 兼容的 ``finish_reason``（如 ``stop``、``length``）。
+    请求失败时返回 ``(错误信息字符串, None)``。``temperature`` 用于重试时切换采样温度。
+    """
+    try:
+        client = _get_openai_client(model_url)
+        chat_response = client.chat.completions.create(
+            model=model_name,
+            messages=[{"role": "user", "content": query}],
+            max_tokens=max_tokens,
+            temperature=temperature,
+            top_p=0.95,
+            extra_body={
+                "stop": ["<|im_end|>"],
+                "top_k": -1,
+                "repetition_penalty": 1.0,
+            },
+        )
+    except Exception as e:
+        traceback.print_exc()
+        return str(e), None
+    choice = chat_response.choices[0]
+    content = choice.message.content
+    if content is None:
+        content = ""
+    fr = getattr(choice, "finish_reason", None)
+    return content, fr
+
+
+def req_model_vllm(
+    query: str,
+    model_name: str,
+    model_url: str = MODEL_URL,
+    max_tokens: int = 4000,
+    max_attempts: int = MAX_GEN_ATTEMPTS,
+    retry_temperature: float = RETRY_TEMPERATURE,
+) -> str:
+    """
+    请求模型并在格式错误时重试：
+    - 第 1 次 attempt 使用 temperature=0；后续重试使用 ``retry_temperature``（默认 0.4）。
+    - 通过 ``_format_is_ok`` 检查是否包含可解析的 ``{"hallucination list": [...]}`` 片段。
+    - 至多尝��� ``max_attempts`` 次（含首次），仍失败则返回最后一次的原始内容（交由下游 ``parse_output`` 兜底为 ``[]``）。
+    """
+    last_content = ""
+    attempts = max(1, int(max_attempts))
+    for attempt in range(1, attempts + 1):
+        temperature = 0.0 if attempt == 1 else float(retry_temperature)
+        content, _ = req_model_vllm_with_finish_reason(
+            query,
+            model_name,
+            model_url,
+            max_tokens=max_tokens,
+            temperature=temperature,
+        )
+        last_content = content
+        if _format_is_ok(content):
+            return content
+        if attempt < attempts:
+            print(
+                f"[req_model_vllm] format invalid on attempt {attempt}/{attempts}, "
+                f"retrying with temperature={retry_temperature}."
+            )
+    return last_content
+
+
+def compute_multi_spans(
+    gold_spans: Sequence[Tuple[int, int]], pred_spans: Sequence[Tuple[int, int]]
+) -> Tuple[int, int, int]:
+    gold_sets = [set(range(int(start), int(end))) for start, end in gold_spans]
+    pred_sets = [set(range(int(start), int(end))) for start, end in pred_spans]
+    gold_union = set.union(*gold_sets) if gold_sets else set()
+    pred_union = set.union(*pred_sets) if pred_sets else set()
+    tp = len(gold_union.intersection(pred_union))
+    pred_len = len(pred_union)
+    gold_len = len(gold_union)
+    return tp, pred_len, gold_len
+
+
+def find_start_end_index(response: str, output: str, strict: bool = False) -> Tuple[int, int]:
+    response = response.lower()
+    sub_str = output.lower().strip()
+    start = response.find(sub_str)
+    if start == -1:
+        if len(sub_str) >= 10 and not strict:
+            match_length = 10
+            prefix_match = response.find(sub_str[:match_length])
+            suffix_match = response.find(sub_str[-match_length:])
+            new_start, new_end = prefix_match, suffix_match + match_length
+            if (
+                prefix_match != -1
+                and suffix_match != -1
+                and 0.7 < (new_end - new_start) / len(sub_str) < 1.3
+            ):
+                return new_start, new_end
+            sub_str = " ".join(sub_str.split())
+            start = response.find(sub_str)
+            if start == -1:
+                return -1, -1
+    end = start + len(sub_str)
+    return (start, end)
+
+
+def cal_metrics(
+    response: str,
+    labels: List[Dict[str, Any]],
+    output_list: List[str],
+) -> Tuple[int, int, int, int, int, int, int]:
+    predict_span = []
+    for output in output_list:
+        if not isinstance(output, str):
+            continue
+        tup = find_start_end_index(response, output, strict=False)
+        if tup != (-1, -1):
+            predict_span.append(tup)
+    ground_truth_span = []
+    for label in labels:
+        tup = (label["start"], label["end"])
+        ground_truth_span.append(tup)
+    if len(predict_span) == 0:
+        predict_span.append((0, 0))
+    if len(ground_truth_span) == 0:
+        ground_truth_span.append((0, 0))
+    match_size, prediction, groud_truth = compute_multi_spans(
+        ground_truth_span, predict_span
+    )
+    pos_true_cnt, neg_true_cnt, neg_false_cnt, pos_false_cnt = 0, 0, 0, 0
+    if output_list != [] and labels != []:
+        pos_true_cnt += 1
+    elif output_list == [] and labels != []:
+        neg_true_cnt += 1
+    elif output_list == [] and labels == []:
+        neg_false_cnt += 1
+    elif output_list != [] and labels == []:
+        pos_false_cnt += 1
+    else:
+        raise Exception("Error! output: {} labels: {}".format(output_list, labels))
+    return (
+        match_size,
+        prediction,
+        groud_truth,
+        pos_true_cnt,
+        neg_true_cnt,
+        neg_false_cnt,
+        pos_false_cnt,
+    )
+
+
+def print_metrics(task_cur: str, record: Dict[str, Any]) -> Dict[str, Any]:
+    record["recall" + task_cur] = (
+        record["match_size_" + task_cur] / record["groud_truth_" + task_cur]
+        if record["groud_truth_" + task_cur]
+        else 0
+    )
+    record["precision" + task_cur] = (
+        record["match_size_" + task_cur] / record["prediction_" + task_cur]
+        if record["prediction_" + task_cur]
+        else 0
+    )
+    record["f1" + task_cur] = (
+        2
+        * record["recall" + task_cur]
+        * record["precision" + task_cur]
+        / (record["recall" + task_cur] + record["precision" + task_cur])
+        if (record["recall" + task_cur] + record["precision" + task_cur]) > 0
+        else 0
+    )
+    char_res = "span_level:\nprecision: {:.4f}, recall: {:.4f}, f1: {:.4f}".format(
+        record["precision" + task_cur],
+        record["recall" + task_cur],
+        record["f1" + task_cur],
+    )
+    record["case_recall_" + task_cur] = (
+        record["pos_true_cnt_" + task_cur]
+        / (record["pos_true_cnt_" + task_cur] + record["neg_true_cnt_" + task_cur])
+        if (record["pos_true_cnt_" + task_cur] + record["neg_true_cnt_" + task_cur]) > 0
+        else 0
+    )
+    record["case_precision_" + task_cur] = (
+        record["pos_true_cnt_" + task_cur]
+        / (record["pos_true_cnt_" + task_cur] + record["pos_false_cnt_" + task_cur])
+        if (record["pos_true_cnt_" + task_cur] + record["pos_false_cnt_" + task_cur]) > 0
+        else 0
+    )
+    record["f1_" + task_cur] = (
+        2
+        * record["case_recall_" + task_cur]
+        * record["case_precision_" + task_cur]
+        / (record["case_recall_" + task_cur] + record["case_precision_" + task_cur])
+        if (record["case_recall_" + task_cur] + record["case_precision_" + task_cur]) > 0
+        else 0
+    )
+    case_res = "case_level:\nprecision: {:.4f}, recall: {:.4f}, f1: {:.4f}".format(
+        record["case_precision_" + task_cur],
+        record["case_recall_" + task_cur],
+        record["f1_" + task_cur],
+    )
+    print(case_res)
+    print(char_res)
+    return {
+        "task_type": task_cur,
+        "span_level": {
+            "precision": round(record["precision" + task_cur], 4),
+            "recall": round(record["recall" + task_cur], 4),
+            "f1": round(record["f1" + task_cur], 4),
+            "match_size": record["match_size_" + task_cur],
+            "prediction": record["prediction_" + task_cur],
+            "ground_truth": record["groud_truth_" + task_cur],
+        },
+        "case_level": {
+            "precision": round(record["case_precision_" + task_cur], 4),
+            "recall": round(record["case_recall_" + task_cur], 4),
+            "f1": round(record["f1_" + task_cur], 4),
+            "pos_true_cnt": record["pos_true_cnt_" + task_cur],
+            "neg_true_cnt": record["neg_true_cnt_" + task_cur],
+            "neg_false_cnt": record["neg_false_cnt_" + task_cur],
+            "pos_false_cnt": record["pos_false_cnt_" + task_cur],
+        },
+    }
+
+
+def evaluate_results(
+    results: List[Dict[str, Any]],
+    record: Dict[str, int],
+    chosen_task: Sequence[str],
+    filepath: str,
+) -> List[Dict[str, Any]]:
+    chosen = list(chosen_task) + ["All"]
+    for sample in results:
+        response = sample["response"]
+        labels = sample["labels"]
+        output = sample["output"]
+        task = sample["task_type"]
+        res = cal_metrics(response, labels, output)
+        (
+            temp_tp,
+            temp_pred_len,
+            temp_gold_len,
+            pos_true_cnt,
+            neg_true_cnt,
+            neg_false_cnt,
+            pos_false_cnt,
+        ) = res
+        for task_cur in chosen:
+            if task_cur == task or task_cur == "All":
+                record["match_size_" + task_cur] += temp_tp
+                record["prediction_" + task_cur] += temp_pred_len
+                record["groud_truth_" + task_cur] += temp_gold_len
+                record["pos_true_cnt_" + task_cur] += pos_true_cnt
+                record["neg_true_cnt_" + task_cur] += neg_true_cnt
+                record["neg_false_cnt_" + task_cur] += neg_false_cnt
+                record["pos_false_cnt_" + task_cur] += pos_false_cnt
+    all_metrics = []
+    for task_cur in chosen:
+        all_metrics.append(print_metrics(task_cur, record))
+    print("chosen task: {}".format(chosen))
+    print("filepath: {}".format(filepath))
+    print("test_data_size: {}".format(len(results)))
+    return all_metrics
+
+
+def average_precision_case_detection(results_subset: List[Dict[str, Any]]) -> float:
+    """
+    样本级检测 Average Precision：正类为金标存在幻觉 span（labels 非空），
+    预测分数与 cal_metrics 的 case 口径一致：``output`` 为非空 list 则为 1，否则 0。
+    无正样本时返回 0.0。
+    """
+    if not results_subset:
+        return 0.0
+    y_true: List[int] = []
+    y_score: List[float] = []
+    for s in results_subset:
+        y_true.append(1 if s.get("labels") else 0)
+        out = s.get("output")
+        y_score.append(1.0 if isinstance(out, list) and len(out) > 0 else 0.0)
+    n_pos = sum(y_true)
+    if n_pos == 0:
+        return 0.0
+    order = sorted(range(len(y_true)), key=lambda i: (-y_score[i], -i))
+    tp = 0
+    ap = 0.0
+    for rank, idx in enumerate(order, start=1):
+        if y_true[idx] == 1:
+            tp += 1
+            ap += tp / rank
+    return ap / n_pos
+
+
+def evaluate_results_by_group_key(
+    results: List[Dict[str, Any]],
+    filepath: str,
+    group_key: str = "lang",
+) -> List[Dict[str, Any]]:
+    """
+    按样本字段 group_key（如 PsiloQA 的 lang）分组累计 span/case 指标，并写入
+    case_level.average_precision；最后为汇总桶 All。
+    返回 dict 中以 group_key 为顶层字段名（如 lang），替代原 task_type。
+    """
+
+    def get_group(sample: Dict[str, Any]) -> str:
+        v = sample.get(group_key)
+        if v is None or v == "":
+            return "unknown"
+        return str(v)
+
+    groups = sorted({get_group(s) for s in results})
+    ordered = groups + ["All"]
+    records: Dict[str, Dict[str, Any]] = {b: collections.defaultdict(int) for b in ordered}
+    samples_per: Dict[str, List[Dict[str, Any]]] = {b: [] for b in groups}
+    samples_per["All"] = []
+
+    for sample in results:
+        samples_per[get_group(sample)].append(sample)
+        samples_per["All"].append(sample)
+
+        response = sample["response"]
+        labels = sample["labels"]
+        output = sample["output"]
+        res = cal_metrics(response, labels, output)
+        (
+            temp_tp,
+            temp_pred_len,
+            temp_gold_len,
+            pos_true_cnt,
+            neg_true_cnt,
+            neg_false_cnt,
+            pos_false_cnt,
+        ) = res
+        for b in (get_group(sample), "All"):
+            task_cur = b
+            rec = records[b]
+            rec["match_size_" + task_cur] += temp_tp
+            rec["prediction_" + task_cur] += temp_pred_len
+            rec["groud_truth_" + task_cur] += temp_gold_len
+            rec["pos_true_cnt_" + task_cur] += pos_true_cnt
+            rec["neg_true_cnt_" + task_cur] += neg_true_cnt
+            rec["neg_false_cnt_" + task_cur] += neg_false_cnt
+            rec["pos_false_cnt_" + task_cur] += pos_false_cnt
+
+    all_metrics: List[Dict[str, Any]] = []
+    for b in ordered:
+        m = print_metrics(b, records[b])
+        m[group_key] = m.pop("task_type")
+        ap = average_precision_case_detection(samples_per[b])
+        m["case_level"]["average_precision"] = round(ap, 4)
+        print("  average_precision (case-level, nonempty output list = 1): {:.4f}".format(ap))
+        all_metrics.append(m)
+    print("group_by {}: {}".format(group_key, ordered))
+    print("filepath: {}".format(filepath))
+    print("test_data_size: {}".format(len(results)))
+    return all_metrics
+
+
+def parse_output(output_str: str) -> List[str]:
+    output = re.findall(r"""{"hallucination list": \[.*?\]}""", output_str)
+    if not len(output):
+        return []
+    output = output[-1]
+    output = json_repair.loads(output)
+    if "hallucination list" in output:
+        return output["hallucination list"]
+    if isinstance(output, list):
+        return output
+    print("ERROR: hallucination list not found in output")
+    return []
+
+
+def trans_instruction(ins_ori: str, task_word: str) -> str:
+    if "Your task" not in ins_ori:
+        print("error")
+    ins_ori = ins_ori.rsplit("Your task", 1)[0]
+    ins = ins_ori.strip() + "\n" + extra_sft_prompt.replace("<|task_word|>", task_word)
+    return ins
+
+
+def trans_instruction_reasoning(ins_ori: str, task_word: str) -> str:
+    if "Your task" not in ins_ori:
+        print("error")
+    ins_ori = ins_ori.rsplit("Your task", 1)[0]
+    ins = (
+        ins_ori.strip()
+        + "\n"
+        + extra_sft_prompt_reasoning.replace("<|task_word|>", task_word)
+    )
+    return ins
+
+
+def labels_have_any_supervision(results: List[Dict[str, Any]]) -> bool:
+    for s in results:
+        if s.get("labels"):
+            return True
+    return False

test_run_math_shepherd.py

@@ -0,0 +1,107 @@
+"""Offline regression tests for the release's Math-Shepherd evaluator."""
+
+import contextlib
+import hashlib
+import io
+import json
+from pathlib import Path
+import sys
+import tempfile
+import unittest
+from unittest import mock
+
+import pyarrow as pa
+import pyarrow.parquet as pq
+
+import run_math_shepherd as evaluator
+
+
+class MathShepherdEvaluatorTests(unittest.TestCase):
+    def test_packaged_benchmark_has_614_rows_and_expected_hash(self):
+        path = Path(evaluator.__file__).with_name("math_shepherd_614_test_20260327.parquet")
+        self.assertEqual(pq.ParquetFile(path).metadata.num_rows, 614)
+        self.assertEqual(
+            hashlib.sha256(path.read_bytes()).hexdigest(),
+            "e01fabbc80b99f01307aa9095b9e186f13cae392ed0bff983dcbdd61ee0d1087",
+        )
+
+    def test_parquet_selection_includes_release_filename(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "math_shepherd_614_test_20260327.parquet"
+            path.touch()
+            self.assertEqual(evaluator.resolve_test_parquets(directory), [str(path)])
+
+    def test_gold_span_and_label_dependent_suffix(self):
+        steps = ["Correct", "Wrong", "Correct again"]
+        response, labels = evaluator.completions_to_response_and_gold(
+            steps, [True, False, True]
+        )
+        self.assertEqual(response, "Correct\nWrong\nCorrect again")
+        self.assertEqual(labels, [{"start": 8, "end": 14}])
+        tp, pred, gold, *_ = evaluator.cal_metrics_math_shepherd(
+            response, labels, ["Wrong"], steps
+        )
+        self.assertEqual((tp, pred, gold), (6, len(response) - 8, 6))
+
+    def test_metric_only_accepts_old_jsonl_without_completions(self):
+        with tempfile.TemporaryDirectory() as directory:
+            path = Path(directory) / "saved.jsonl"
+            path.write_text(json.dumps({
+                "response": "A\nB", "labels": [{"start": 2, "end": 3}],
+                "output": ["B"], "task_type": "Math",
+            }) + "\n", encoding="utf-8")
+            with mock.patch.object(sys, "argv", ["run_math_shepherd.py", "--filepath", str(path)]):
+                evaluator.main()
+            metrics = json.loads((Path(directory) / "saved_recomputed_metric.json").read_text(encoding="utf-8"))
+            self.assertEqual(metrics["test_data_size"], 1)
+            self.assertEqual(metrics["metrics"][1]["span_level"]["f1"], 1.0)
+
+    def test_full_mock_run_and_incomplete_run_detection(self):
+        with tempfile.TemporaryDirectory() as directory:
+            data_file = Path(directory) / "math_shepherd_614_test_20260327.parquet"
+            pq.write_table(pa.Table.from_pylist([
+                {"prompt": "Find x", "completions": ["A", "B"], "labels": [True, False]},
+                {"prompt": "Find y", "completions": ["C"], "labels": [True]},
+            ]), data_file)
+            output_dir = Path(directory) / "results"
+            argv = [
+                "run_math_shepherd.py", "--data-file", str(data_file),
+                "--model-name", "demo/model", "--model-url", "http://localhost:7010/v1",
+                "--num-threads", "1", "--output-dir", str(output_dir),
+            ]
+            fake_response = lambda prompt, **kwargs: (
+                '{"hallucination list": ["B"]}' if "Find x" in prompt
+                else '{"hallucination list": []}'
+            )
+            with mock.patch.object(sys, "argv", argv), mock.patch.object(
+                evaluator, "req_model_vllm", side_effect=fake_response
+            ):
+                evaluator.main()
+            result_files = list(output_dir.glob("*.jsonl"))
+            self.assertEqual(len(result_files), 1)
+            self.assertEqual(len(result_files[0].read_text(encoding="utf-8").splitlines()), 2)
+            metric_files = list(output_dir.glob("*_metric.json"))
+            self.assertEqual(len(metric_files), 1)
+            metrics = json.loads(metric_files[0].read_text(encoding="utf-8"))
+            self.assertEqual(metrics["test_data_size"], 2)
+            self.assertEqual(metrics["model_name"], "demo/model")
+            self.assertEqual(metrics["metrics"][1]["span_level"]["f1"], 1.0)
+
+            with mock.patch.object(sys, "argv", argv), mock.patch.object(
+                evaluator, "req_model_vllm", return_value="malformed response"
+            ), contextlib.redirect_stdout(io.StringIO()), contextlib.redirect_stderr(io.StringIO()):
+                with self.assertRaisesRegex(RuntimeError, "Only 0/2 rows evaluated"):
+                    evaluator.main()
+            self.assertEqual(len(list(output_dir.glob("*.jsonl"))), 1)
+
+    def test_no_reasoning_changes_instruction(self):
+        steps = ["Step 1: 2+2=5"]
+        ordinary = evaluator.build_user_instruction("Compute 2+2", steps, True, False)
+        compact = evaluator.build_user_instruction("Compute 2+2", steps, False, False)
+        self.assertIn("step-by-step verification", ordinary)
+        self.assertNotIn("step-by-step verification", compact)
+        self.assertIn('"hallucination list"', compact)
+
+
+if __name__ == "__main__":
+    unittest.main()