| |
| |
| |
| |
| |
|
|
| """Run the benchmark against a multimodal model behind an OpenAI-compatible API. |
| |
| For each question the model receives, as a multi-turn conversation, every session |
| before the one in which the question is asked, plus the turns of that session up to |
| the question's turn cutoff. The first user turn of each session carries the session's |
| clip: frames spread evenly across the ten seconds, then the audio. The question |
| follows with its four options in a fixed per-item shuffle, and the model is asked to |
| give its choice after the token <final_answer>. |
| |
| Results are appended to <out-dir>/<user_id>.jsonl after every item, so an interrupted |
| run resumes where it stopped. Score them with eval/score.py. |
| |
| Media comes from scripts/fetch_clips.py. A session whose clip could not be fetched |
| is given its date marker and dialogue without media. |
| |
| Requires the openai package and ffmpeg on PATH. |
| |
| Usage: |
| export OPENAI_API_KEY=... |
| python eval/run_eval.py --model <model> --data-dir data --media-dir media \\ |
| --out-dir results/<model> [--base-url https://...] [--users 001,002] |
| """ |
|
|
| from __future__ import annotations |
|
|
| import argparse |
| import base64 |
| import json |
| import os |
| import random |
| import re |
| import subprocess |
| import sys |
| import time |
| from pathlib import Path |
| from typing import Any |
|
|
| from openai import OpenAI |
|
|
| SYSTEM_PROMPT = ( |
| "You are a wearable hearing assistant worn by one user. You talk with the user in " |
| "separate sessions spread over several years. Each session begins with a 10-second " |
| "audio-visual clip of what you perceived at that moment: ordered frames sampled evenly " |
| "across the clip, followed " |
| "by the audio. That clip describes the environment for the whole session, until the " |
| "next clip appears. Each session is marked with its date." |
| ) |
|
|
| SYSTEM_PROMPT_NO_AUDIO = ( |
| "You are a wearable assistant worn by one user. You talk with the user in separate " |
| "sessions spread over several years. Each session begins with ordered frames of " |
| "what you saw at that moment. Those frames describe the environment for the whole " |
| "session, until the next set appears. Each session is marked with its date." |
| ) |
|
|
| ANSWER_INSTRUCTIONS = ( |
| "Find the most appropriate answer and give your final answer (a), (b), (c), or (d) " |
| "after the special token <final_answer>. Before that, in at most two sentences, " |
| "state your reasons." |
| ) |
|
|
| FRAME_WIDTH = 384 |
| AUDIO_RATE = 16000 |
| AUDIO_BITRATE = "64k" |
| |
| ANSWER_ATTEMPTS = 2 |
|
|
|
|
| def load_record(path: Path) -> dict[str, Any]: |
| data = json.loads(path.read_text()) |
| return data[0] if isinstance(data, list) else data |
|
|
|
|
| def prepare_clip(media_dir: Path, cache_dir: Path, asset_id: str) -> Path | None: |
| """Downscale a clip's frames and compress its audio once, so a long history fits |
| in one request. Returns None when the clip was not fetched.""" |
| source = media_dir / asset_id |
| if not (source / "audio.wav").exists(): |
| return None |
| target = cache_dir / asset_id |
| frames = sorted((source / "frames").glob("*.jpg")) |
| if (target / "audio.mp3").exists() and len(list((target / "frames").glob("*.jpg"))) == len(frames): |
| return target |
| (target / "frames").mkdir(parents=True, exist_ok=True) |
| for frame in frames: |
| subprocess.run( |
| ["ffmpeg", "-y", "-loglevel", "error", "-i", str(frame), |
| "-vf", f"scale={FRAME_WIDTH}:-2", "-q:v", "6", str(target / "frames" / frame.name)], |
| check=True, |
| ) |
| subprocess.run( |
| ["ffmpeg", "-y", "-loglevel", "error", "-i", str(source / "audio.wav"), |
| "-ac", "1", "-ar", str(AUDIO_RATE), "-b:a", AUDIO_BITRATE, str(target / "audio.mp3")], |
| check=True, |
| ) |
| return target |
|
|
|
|
| def spread(frames: list[Path], count: int) -> list[Path]: |
| """Pick ``count`` frames reaching from the first to the last.""" |
| if count >= len(frames): |
| return frames |
| if count <= 1: |
| return frames[:count] |
| last = len(frames) - 1 |
| return [frames[round(step * last / (count - 1))] for step in range(count)] |
|
|
|
|
| def clip_blocks(clip: Path | None, session: dict[str, Any], args: argparse.Namespace) -> list[dict]: |
| blocks: list[dict] = [{"type": "text", "text": f"[{session['session_id']} | {session['timestamp']}]"}] |
| if clip is None: |
| return blocks |
| for frame in spread(sorted((clip / "frames").glob("*.jpg")), args.frame_count): |
| encoded = base64.b64encode(frame.read_bytes()).decode() |
| blocks.append({"type": "image_url", |
| "image_url": {"url": f"data:image/jpeg;base64,{encoded}", "detail": args.image_detail}}) |
| if not args.no_audio: |
| encoded = base64.b64encode((clip / "audio.mp3").read_bytes()).decode() |
| blocks.append({"type": "input_audio", "input_audio": {"data": encoded, "format": "mp3"}}) |
| return blocks |
|
|
|
|
| def build_messages( |
| item: dict[str, Any], sessions: list[dict[str, Any]], clips: dict[str, Path | None], args: argparse.Namespace |
| ) -> tuple[list[dict], str, list[str]]: |
| order = [session["session_id"] for session in sessions] |
| location = item["question_location"] |
| stop = order.index(location["session_id"]) |
| messages: list[dict] = [{"role": "system", "content": SYSTEM_PROMPT_NO_AUDIO if args.no_audio else SYSTEM_PROMPT}] |
|
|
| def add_session(session: dict[str, Any], turns: list[dict]) -> list[dict] | None: |
| pending: list[dict] | None = clip_blocks(clips[session["selected_asset_id"]], session, args) |
| for turn in turns: |
| if turn["role"] == "user" and pending is not None: |
| messages.append({"role": "user", "content": pending + [{"type": "text", "text": turn["content"]}]}) |
| pending = None |
| else: |
| messages.append({"role": turn["role"], "content": turn["content"]}) |
| return pending |
|
|
| for index in range(stop): |
| add_session(sessions[index], sessions[index]["dialogue"]) |
| pending = add_session(sessions[stop], sessions[stop]["dialogue"][: location["turn_cutoff"]]) |
|
|
| correct = item["Correct_Answer"] |
| options = [correct] + list(item["Incorrect_Answers"]) |
| random.Random(f"{item['candidate_id']}:{args.seed}").shuffle(options) |
| gold = "abcd"[options.index(correct)] |
| labelled = [f"({'abcd'[i]}) {option}" for i, option in enumerate(options)] |
| text = f"{item['Question']}\n\n{ANSWER_INSTRUCTIONS}\n\n" + "\n".join(labelled) |
| messages.append({"role": "user", "content": pending + [{"type": "text", "text": text}] if pending else text}) |
| return messages, gold, labelled |
|
|
|
|
| def parse_choice(reply: str) -> set[str]: |
| """The choice after <final_answer>; only the parenthesised form counts, and only |
| when exactly one letter is named.""" |
| if "<final_answer>" not in reply: |
| return set() |
| found = set(re.findall(r"\(([a-d])\)", reply.rsplit("<final_answer>", 1)[1].lower())) |
| return found if len(found) == 1 else set() |
|
|
|
|
| def classify(picked: set[str], gold: str) -> str: |
| if not picked: |
| return "parse_failure" |
| return "correct" if picked == {gold} else "wrong" |
|
|
|
|
| def ask(client: OpenAI, messages: list[dict], args: argparse.Namespace) -> str: |
| for attempt in range(args.request_attempts): |
| try: |
| response = client.chat.completions.create( |
| model=args.model, messages=messages, max_tokens=args.max_tokens |
| ) |
| return (response.choices[0].message.content or "").strip() |
| except Exception as error: |
| if attempt + 1 == args.request_attempts: |
| raise |
| print(f"request failed ({error}); retrying", file=sys.stderr) |
| time.sleep(min(2 ** attempt * 2, 30)) |
| raise RuntimeError("unreachable") |
|
|
|
|
| def evaluate_user(client: OpenAI, user_dir: Path, args: argparse.Namespace) -> None: |
| user_id = user_dir.name |
| out_path = args.out_dir / f"{user_id}.jsonl" |
| done: set[str] = set() |
| if out_path.exists(): |
| for line in out_path.read_text().splitlines(): |
| record = json.loads(line) |
| if record["outcome"] != "error": |
| done.add(record["candidate_id"]) |
|
|
| sessions = load_record(user_dir / "7.1_dialogue_enhanced.json")["sessions"] |
| items = load_record(user_dir / "10_benchmark_qa.json")["qa"] |
| if args.limit: |
| items = items[: args.limit] |
| clips = {s["selected_asset_id"]: prepare_clip(args.media_dir, args.cache_dir, s["selected_asset_id"]) |
| for s in sessions} |
|
|
| with out_path.open("a") as out: |
| for number, item in enumerate(items, start=1): |
| if item["candidate_id"] in done: |
| continue |
| messages, gold, labelled = build_messages(item, sessions, clips, args) |
| record: dict[str, Any] = {"user_id": user_id, "candidate_id": item["candidate_id"], |
| "type": item["Type"], "options": labelled, "gold": gold} |
| started = time.time() |
| try: |
| reply, picked = "", set() |
| for _ in range(ANSWER_ATTEMPTS): |
| reply = ask(client, messages, args) |
| picked = parse_choice(reply) |
| if picked: |
| break |
| record.update(picked=sorted(picked), outcome=classify(picked, gold), reply=reply) |
| except Exception as error: |
| record.update(picked=[], outcome="error", error=f"{type(error).__name__}: {error}"[:500]) |
| record["latency_s"] = round(time.time() - started, 1) |
| out.write(json.dumps(record) + "\n") |
| out.flush() |
| print(f"{user_id} [{number}/{len(items)}] {record['outcome']}", file=sys.stderr) |
|
|
|
|
| def main() -> None: |
| parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) |
| parser.add_argument("--model", required=True) |
| parser.add_argument("--base-url", default=None, help="OpenAI-compatible endpoint (default: OpenAI)") |
| parser.add_argument("--data-dir", type=Path, default=Path("data")) |
| parser.add_argument("--media-dir", type=Path, default=Path("media")) |
| parser.add_argument("--cache-dir", type=Path, default=Path("media_cache")) |
| parser.add_argument("--out-dir", type=Path, required=True) |
| parser.add_argument("--users", default="", help="Comma-separated user IDs (default: all)") |
| parser.add_argument("--frame-count", type=int, default=10, help="Frames sent per clip") |
| parser.add_argument("--image-detail", choices=("low", "high", "auto"), default="high") |
| parser.add_argument("--no-audio", action="store_true", help="Frames only, for models without audio input") |
| parser.add_argument("--max-tokens", type=int, default=4096) |
| parser.add_argument("--request-attempts", type=int, default=3) |
| parser.add_argument("--seed", type=int, default=0, help="Seed for the option shuffle") |
| parser.add_argument("--limit", type=int, default=0, help="First N questions per user") |
| args = parser.parse_args() |
|
|
| client = OpenAI(base_url=args.base_url, api_key=os.environ.get("OPENAI_API_KEY")) |
| args.out_dir.mkdir(parents=True, exist_ok=True) |
| users = {u.strip() for u in args.users.split(",") if u.strip()} |
| for user_dir in sorted(p.parent for p in args.data_dir.glob("*/10_benchmark_qa.json")): |
| if not users or user_dir.name in users: |
| evaluate_user(client, user_dir, args) |
|
|
|
|
| if __name__ == "__main__": |
| main() |
|
|
