[Benchmark][MiniCPM-o] Add Omni-DuplexEval support (#6634)

Signed-off-by: Zhanshenzhui <99891002+zyforsure@users.noreply.github.com>
Co-authored-by: amy-why-3459 <wuhaiyan17@huawei.com>

tests/benchmarks/duplex/test_omni_duplex_eval.py

@@ -0,0 +1,143 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import hashlib
+import json
+import sys
+from types import SimpleNamespace
+
+import pytest
+
+from vllm_omni.benchmarks.duplex import omni_duplex_eval_eval as eval_module
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_clock import (
+    extract_timed_sentences,
+    normalize_response_items,
+    split_text,
+    validate_clock,
+)
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import (
+    DuplexSample,
+    canonical_task_type,
+    family_for_split,
+    load_samples,
+    task_type_for_split,
+)
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_metrics import (
+    PROTOCOL_PIN,
+    build_content_prompt,
+    build_reminder_prompt,
+    build_temporal_prompt,
+    parse_judge_json,
+    reminder_window,
+    summarize_pr_results,
+    temporal_window,
+)
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu]
+
+
+def test_dataset_mapping_and_manifest(tmp_path):
+    manifest = tmp_path / "samples.json"
+    manifest.write_text(json.dumps([{"id": "a", "split": "RTD_OCR", "video": "clip.mp4"}]), encoding="utf-8")
+    sample = load_samples(manifest, media_root=tmp_path)[0]
+    assert sample.family == "rtd"
+    assert sample.video == str(tmp_path / "clip.mp4")
+    assert family_for_split("PR_event_reminder") == "pr"
+    assert canonical_task_type("post-event-reminder") == "post_event_reminder"
+    assert task_type_for_split("PR_correction") == "correction"
+    assert load_samples([{"id": "pr", "split": "PR_correction"}])[0].task_type == "correction"
+
+
+def test_hugging_face_subset_names_are_splits(monkeypatch):
+    calls = []
+
+    def fake_load_dataset(name, **kwargs):
+        calls.append((name, kwargs))
+        return [{"id": "pr", "question_text": "Correct this."}]
+
+    monkeypatch.setitem(sys.modules, "datasets", SimpleNamespace(load_dataset=fake_load_dataset))
+    sample = load_samples("Hothan/Omni-DuplexEval", split="PR_correction")[0]
+    assert calls == [("Hothan/Omni-DuplexEval", {"split": "PR_correction"})]
+    assert sample.split == "PR_correction"
+    assert sample.task_type == "correction"
+
+
+def test_response_aliases_and_clock_guard():
+    assert split_text("One. Two!") == ["One.", "Two!"]
+    assert normalize_response_items({"chunks": [{"text": "x", "current_time": 800}]}) == [
+        {"sentence": "x", "start": 800.0, "end": 800.0}
+    ]
+    with pytest.raises(ValueError, match="clock=invalid"):
+        validate_clock({"clock": "invalid"})
+    validate_clock({"clock": "invalid"}, allow_invalid=True)
+    timed = extract_timed_sentences([{"type": "response.output_text.delta", "delta": "Done.", "_media_clock_ms": 800}])
+    assert [item.as_dict() for item in timed] == [{"sentence": "Done.", "start": 0.8, "end": 0.8}]
+    with pytest.raises(ValueError, match="only clock=media"):
+        extract_timed_sentences([], clock="wall")
+
+
+def test_protocol_windows_and_parsing():
+    assert PROTOCOL_PIN == "ca3c122b4d4bf67afd6b18ea5e724b4561bdde48"
+    assert temporal_window(4, 5, 10) == (2.0, 3.0)
+    assert temporal_window(1, 1.2, 10) == (0.0, 0.5)
+    assert reminder_window(5) == (5.0, 15.0)
+    assert parse_judge_json('noise {"content_score": 2.345, "is_relevant": 1}') == {
+        "content_score": 2.35,
+        "is_relevant": 1,
+    }
+    assert parse_judge_json('noise "success_score": 1') == {"success_score": 1}
+    assert summarize_pr_results([{"task_type": "correction", "all_success": 1}])["mean_all_success"] == 1.0
+
+
+def test_protocol_prompt_wording_is_pinned():
+    prompts = [
+        build_temporal_prompt(1, 2, "response", "question"),
+        build_content_prompt("response", "question", ["one", "two"]),
+        build_reminder_prompt("instruction", "response", "proactive_reminder"),
+        build_reminder_prompt("instruction", "response", "post_event_reminder"),
+        build_reminder_prompt("instruction", "response", "correction", "answer"),
+    ]
+    assert [hashlib.sha256(prompt.encode()).hexdigest() for prompt in prompts] == [
+        "5f7f5fcb4a37e4d2eea8ba23beabf74630e6fc2fb5b2661ceb94403254bb04d5",
+        "1fccbed6c1ed8ea1c76d5564d7289ed6adca3678f6a0da2cc735942123d64457",
+        "d0a0e3a9d873d2f368c5c99b9fe46681f683cc36a9fe0e09b99d6cbca1d6dd0c",
+        "08f9951243c859d271f82ee53da22cd0bdab1fe93c6ca04f4870d3b959c0803a",
+        "3de131a7e36cb4b8ac369bb05e87ede518be20221e214df3644211c179131a73",
+    ]
+
+
+def test_frame_sample_content_passes_frames(tmp_path, monkeypatch):
+    response = tmp_path / "response.json"
+    response.write_text(json.dumps([{"sentence": "A person moves.", "start": 1, "end": 2}]), encoding="utf-8")
+    response.with_name("response.meta.json").write_text(json.dumps({"clock": "media"}), encoding="utf-8")
+    video = tmp_path / "video.mp4"
+    video.write_bytes(b"video")
+    monkeypatch.setattr(eval_module, "extract_jpeg", lambda *args, **kwargs: b"\xff\xd8jpeg")
+
+    class Judge:
+        def temporal(self, *args, **kwargs):
+            return '{"temporal_score": 3, "is_relevant": 1}'
+
+        def content(self, prompt, video, frames=None, *, mode="video_url"):
+            assert mode == "frame-sample"
+            assert frames == [b"\xff\xd8jpeg", b"\xff\xd8jpeg"]
+            return '{"content_score": 3}'
+
+    sample = DuplexSample(
+        id="rtd",
+        split="RTD_OCR",
+        family="rtd",
+        task_type=None,
+        video=video,
+        video_duration=4,
+    )
+    score = eval_module.evaluate_sample(
+        sample,
+        response,
+        tmp_path / "score.json",
+        Judge(),
+        judge_video_mode="frame-sample",
+    )
+    assert score["content"]["frame_count"] == 2

tests/e2e/features/fullduplex/test_omni_duplex_eval_cli.py

@@ -0,0 +1,194 @@
+# SPDX-License-Identifier: Apache-2.0
+# SPDX-FileCopyrightText: Copyright contributors to the vLLM-Omni project
+
+from __future__ import annotations
+
+import argparse
+import base64
+import json
+import threading
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+from pathlib import Path
+
+import pytest
+
+from vllm_omni.benchmarks.duplex import omni_duplex_eval_runner as runner
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_dataset import DuplexSample
+from vllm_omni.benchmarks.duplex.omni_duplex_eval_judge import DuplexJudge
+from vllm_omni.entrypoints.cli.benchmark import omni_duplex_eval as cli
+from vllm_omni.entrypoints.cli.benchmark.omni_duplex_eval import OmniDuplexEvalSubcommand
+
+pytestmark = [pytest.mark.core_model, pytest.mark.cpu, pytest.mark.benchmark]
+
+
+def test_cli_generate_evaluate_summarize_flow(tmp_path: Path, monkeypatch: pytest.MonkeyPatch, capsys):
+    manifest = tmp_path / "manifest.json"
+    manifest.write_text(
+        json.dumps(
+            [
+                {
+                    "id": "sample-1",
+                    "split": "PR_correction",
+                    "question_text": "What changed?",
+                    "answer1": "The object moved.",
+                }
+            ]
+        ),
+        encoding="utf-8",
+    )
+    response_root = tmp_path / "responses"
+    score_root = tmp_path / "scores"
+
+    async def fake_generate(sample, *, output_root, **kwargs):
+        output = Path(output_root) / sample.split / f"{sample.id}.json"
+        output.parent.mkdir(parents=True, exist_ok=True)
+        output.write_text(json.dumps([{"sentence": "It moved.", "start": 0, "end": 1}]), encoding="utf-8")
+        output.with_name(output.stem + ".meta.json").write_text(json.dumps({"clock": "media"}), encoding="utf-8")
+        return output
+
+    class FakeJudge:
+        def __init__(self, *args, **kwargs):
+            pass
+
+        def chat(self, *args, **kwargs):
+            return '{"success_score": 1, "is_relevant": 1}'
+
+    monkeypatch.setattr(cli, "generate_sample", fake_generate)
+    monkeypatch.setattr(cli, "DuplexJudge", FakeJudge)
+
+    parser = argparse.ArgumentParser()
+    OmniDuplexEvalSubcommand.add_cli_args(parser)
+
+    common = ["--dataset", str(manifest), "--family", "pr"]
+    generate = parser.parse_args(
+        [
+            "generate",
+            *common,
+            "--model",
+            "mock",
+            "--ref-audio",
+            str(manifest),
+            "--response-root",
+            str(response_root),
+            "--concurrency",
+            "2",
+        ]
+    )
+    OmniDuplexEvalSubcommand.cmd(generate)
+    evaluate = parser.parse_args(
+        [
+            "evaluate",
+            *common,
+            "--response-root",
+            str(response_root),
+            "--score-root",
+            str(score_root),
+            "--judge-model",
+            "mock-judge",
+            "--eval-workers",
+            "2",
+        ]
+    )
+    OmniDuplexEvalSubcommand.cmd(evaluate)
+    OmniDuplexEvalSubcommand.cmd(parser.parse_args(["summarize", "--score-root", str(score_root)]))
+
+    summary = json.loads(capsys.readouterr().out)
+    assert summary["samples"] == 1
+    assert summary["pr"]["mean_all_success"] == 1.0
+
+
+@pytest.mark.asyncio
+async def test_generate_exercises_realtime_socket_and_media_clock(tmp_path: Path, monkeypatch: pytest.MonkeyPatch):
+    import websockets
+
+    received = []
+
+    async def handler(websocket):
+        response_started = False
+        async for raw in websocket:
+            event = json.loads(raw)
+            received.append(event)
+            if event["type"] == "session.update":
+                await websocket.send(json.dumps({"type": "session.created"}))
+            elif event["type"] == "input_audio_buffer.append" and not response_started:
+                response_started = True
+                await websocket.send(json.dumps({"type": "response.created", "response": {"id": "r1"}}))
+                await websocket.send(
+                    json.dumps({"type": "response.output_text.delta", "response_id": "r1", "delta": "Done."})
+                )
+                await websocket.send(
+                    json.dumps(
+                        {
+                            "type": "response.audio.delta",
+                            "response_id": "r1",
+                            "delta": base64.b64encode(b"\0\0" * 240).decode(),
+                            "sample_rate_hz": 24_000,
+                        }
+                    )
+                )
+            elif event["type"] == "input_audio_buffer.commit":
+                await websocket.send(json.dumps({"type": "response.done", "response": {"id": "r1"}}))
+            elif event["type"] == "session.close":
+                await websocket.send(json.dumps({"type": "session.closed"}))
+                return
+
+    monkeypatch.setattr(runner, "read_audio_pcm16", lambda path: b"\0\0" * (16_000 * 8 // 10))
+    monkeypatch.setattr(runner, "video_duration", lambda path: 0.8)
+    monkeypatch.setattr(runner, "iter_jpegs", lambda *args, **kwargs: iter([(0.0, b"jpeg")]))
+    audio = tmp_path / "question.wav"
+    video = tmp_path / "video.mp4"
+    ref = tmp_path / "ref.wav"
+    for path in (audio, video, ref):
+        path.write_bytes(b"data")
+    sample = DuplexSample("sample", "PR_correction", "pr", "correction", video, audio)
+
+    async with websockets.serve(handler, "127.0.0.1", 0) as server:
+        port = server.sockets[0].getsockname()[1]
+        output = await runner.generate_sample(
+            sample,
+            url=f"ws://127.0.0.1:{port}/v1/realtime?duplex=1",
+            model="mock",
+            ref_audio=ref,
+            output_root=tmp_path / "responses",
+        )
+
+    assert json.loads(output.read_text(encoding="utf-8")) == [{"sentence": "Done.", "start": 0.8, "end": 0.8}]
+    meta = json.loads(output.with_name("sample.meta.json").read_text(encoding="utf-8"))
+    assert meta["response_done"] is True
+    assert meta["drain_timeout"] is None
+    assert any(event["type"] == "playback.ack" for event in received)
+
+
+def test_judge_exercises_openai_http_schema():
+    requests = []
+
+    class Handler(BaseHTTPRequestHandler):
+        def do_POST(self):
+            length = int(self.headers["Content-Length"])
+            requests.append((self.path, self.headers["Authorization"], json.loads(self.rfile.read(length))))
+            payload = json.dumps({"choices": [{"message": {"content": '{"success_score": 1}'}}]}).encode()
+            self.send_response(200)
+            self.send_header("Content-Type", "application/json")
+            self.send_header("Content-Length", str(len(payload)))
+            self.end_headers()
+            self.wfile.write(payload)
+
+        def log_message(self, *args):
+            pass
+
+    server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+    thread = threading.Thread(target=server.serve_forever, daemon=True)
+    thread.start()
+    try:
+        judge = DuplexJudge(f"http://127.0.0.1:{server.server_port}", "judge", api_key="token")
+        assert judge.chat("prompt") == '{"success_score": 1}'
+    finally:
+        server.shutdown()
+        thread.join()
+        server.server_close()
+
+    path, authorization, payload = requests[0]
+    assert path == "/v1/chat/completions"
+    assert authorization == "Bearer token"
+    assert payload["model"] == "judge"
+    assert payload["messages"] == [{"role": "user", "content": "prompt"}]