Initial commit

.gitattributes

@@ -1,60 +1,6 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.avro filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.lz4 filter=lfs diff=lfs merge=lfs -text
-*.mds filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
+*.mp4 filter=lfs diff=lfs merge=lfs -text
 *.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
-# Audio files - uncompressed
-*.pcm filter=lfs diff=lfs merge=lfs -text
-*.sam filter=lfs diff=lfs merge=lfs -text
-*.raw filter=lfs diff=lfs merge=lfs -text
-# Audio files - compressed
-*.aac filter=lfs diff=lfs merge=lfs -text
-*.flac filter=lfs diff=lfs merge=lfs -text
-*.mp3 filter=lfs diff=lfs merge=lfs -text
-*.ogg filter=lfs diff=lfs merge=lfs -text
-*.wav filter=lfs diff=lfs merge=lfs -text
-# Image files - uncompressed
-*.bmp filter=lfs diff=lfs merge=lfs -text
-*.gif filter=lfs diff=lfs merge=lfs -text
-*.png filter=lfs diff=lfs merge=lfs -text
-*.tiff filter=lfs diff=lfs merge=lfs -text
-# Image files - compressed
-*.jpg filter=lfs diff=lfs merge=lfs -text
-*.jpeg filter=lfs diff=lfs merge=lfs -text
-*.webp 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

README.md

@@ -0,0 +1,242 @@
+---
+license: cc-by-nc-4.0
+pretty_name: LabOS LSV Benchmark
+language:
+  - en
+task_categories:
+  - visual-question-answering
+  - video-text-to-text
+tags:
+  - video-language-model
+  - egocentric-video
+  - laboratory
+  - wet-lab
+  - procedural-monitoring
+  - error-detection
+  - benchmark
+size_categories:
+  - 1K<n<10K
+viewer: true
+configs:
+  - config_name: DJI
+    data_files:
+      - split: test
+        path: data/dji.parquet
+  - config_name: XMglass
+    data_files:
+      - split: test
+        path: data/xm.parquet
+  - config_name: Multiview
+    data_files:
+      - split: test
+        path: data/multiview.parquet
+  - config_name: PMD
+    data_files:
+      - split: test
+        path: data/pmd.parquet
+  - config_name: all
+    data_files:
+      - split: test
+        path: data/clips.parquet
+---
+
+# LabOS LSV Benchmark
+
+LabOS LSV is the benchmark for evaluating video-language models on wet-lab procedural supervision. It contains egocentric, third-person, and multiview laboratory videos paired with protocol-aligned evaluation manifests for monitoring what step is happening, whether the monitored procedure advances, and whether tool clips contain a certain type of error.
+
+The package includes the media, benchmark manifests, prompt loaders, inference runner, and report generator used for the LabOS LSV benchmark.
+
+## Benchmark Tasks
+
+1. **Step Prediction Accuracy**: identify the visible protocol step in a lab short video monitoring window.
+2. **Step Advanced Prediction Accuracy**: determine whether the monitored state advances to a new protocol step in a fine-tuning-style monitoring prompt and video window.
+3. **Error Detection**: detect whether a clip is correct usage of a pipette or contains an error.
+
+The PMD error-detection prompts preserve detailed answer options such as `ERROR_REUSE`, `ERROR_SURFACE`, `ERROR_RELEASE`, `ERROR_INSTALL`, and `ERROR_OTHER`. The public benchmark report collapses non-`CORRECT` predictions into `ERROR` for the reported Error Detection metric.
+
+## Repository Layout
+
+```text
+lsv/
+  README.md
+  requirements.txt
+  inference.py
+  generate_report.py
+  data/
+    clips.parquet
+    dji.parquet
+    xm.parquet
+    multiview.parquet
+    pmd.parquet
+    monitoring_step_eval.json
+    monitor_next_step.json
+  videos/                 # full-resolution LSV clips
+  videos640/              # 640px video mirrors for faster inference
+  pmd/
+    README.md
+    pmd.parquet
+    correct/              # correct pipette-use clips
+    incorrect/            # pipette-use clips with labeled mistakes
+  lsvbench/
+    io.py
+    parsing.py
+    metrics.py
+    prompts.py
+    plots.py
+    report.py
+    tasks/
+      monitoring_step.py
+      monitor_next_step.py
+      pmd.py
+      prompts/pmd.md
+```
+
+## Data Files
+
+- `data/clips.parquet`: master LSV clip manifest with relative paths to `videos/` and `videos640/`.
+- `data/dji.parquet`, `data/xm.parquet`, `data/multiview.parquet`: per-camera type manifests for DJI third-person, XM glasses egocentric, and synchronized multiview clips.
+- `data/monitoring_step_eval.json`: 255 step-identification examples using 640px videos.
+- `data/monitor_next_step.json`: 512 monitoring-delta examples matching the LabOS prompt style.
+- `pmd/pmd.parquet`: 246 short pipette-manipulation clips for correct-vs-error and mistake-type evaluation.
+
+The JSON manifests reference videos by relative path. The default benchmark loaders expect the media directories to remain at `videos640/`, `videos/`, `pmd/correct/`, and `pmd/incorrect/` relative to the repository root.
+
+## Example Prompts
+
+Monitoring examples pair a short video window with a protocol state JSON and ask the model to identify or update the current step. For example, `data/monitoring_step_eval.json` includes prompts like:
+
+```text
+You are a real-time lab assistant monitoring a scientist's wet-lab procedure from short video windows.
+
+The current protocol state/history is provided below. Watch the current window and update the state.
+
+Report protocol errors only when supported by the visible time window or state.
+
+Compare the protocol order, prior history, and watched window.
+
+Identify the main protocol step being performed in this watched video window.
+
+STATE:
+{"history":[{"step":"2","tas":0,"tds":0},{"step":"3","tas":30,"tds":30}],"on":"3","protocol":[{"desc":"Take HEK293T cells and culture them to ~70% confluency in a 10 cm dish.","order":1,"step":"1"},{"desc":"In a sterile 1.5 mL tube, mix 10 µg lentiviral backbone plasmid, 7.5 µg packaging plasmid, and 5 µg envelope plasmid.","order":2,"step":"2"},{"desc":"Add 60 µL of transfection reagent and bring the volume up to 300 µL with serum-free medium.","order":3,"step":"3"},{"desc":"Incubate the mixture at room temperature for 15 minutes.","order":4,"step":"4"},{"desc":"Add the transfection mix dropwise to the HEK293T cells.","order":5,"step":"5"},{"desc":"Gently swirl the dish to evenly distribute the complex.","order":6,"step":"6"}]}
+
+Return the visible protocol step ID for the watched video window.
+```
+
+PMD pipette mistake detection examples use a short clip and a fixed multiple-choice prompt:
+
+```text
+You are monitoring a scientist learning how to utilize tools in the wet-lab. You are in simple detection mode and are observing for common technique issues or misuse of tools. In the snippet of user practicing their pipette usage please select the closest option below that describes what happened in the video.
+
+## Options
+1. CORRECT: correct usage of pipette tip no mistakes
+2. ERROR_REUSE: reused tip on different media causing contamination
+3. ERROR_SURFACE: tip was contaminated by touching surface
+4. ERROR_RELEASE: tip was dropped or released unexpectedly
+5. ERROR_INSTALL: pipette tip installed (or attempted) was of wrong size/incorrectly fitted
+6. ERROR_OTHER: when you are sure its wrong but it does not fit above category label as other
+
+## Output format
+Strict SINGLE_WORD all cap option response no other symbols or description from the options above.
+```
+
+## Install
+
+```bash
+python -m pip install -r requirements.txt
+```
+
+For local model inference, install a CUDA-enabled PyTorch stack plus the dependencies in `requirements.txt`. The reference inference runner supports Qwen2.5-VL-compatible models.
+
+## Run Inference
+
+```bash
+python inference.py \
+  --model Qwen/Qwen2.5-VL-7B-Instruct \
+  --adapter cong-lab/labos-vlm-7b \
+  --output runs/labos_vlm_7b \
+  --gpus 0
+```
+
+Run the base model without an adapter:
+
+```bash
+python inference.py \
+  --model Qwen/Qwen2.5-VL-7B-Instruct \
+  --output runs/qwen25vl_7b \
+  --gpus 0
+```
+
+By default, `inference.py` runs `monitoring_step`, `monitor_next_step`, and `pmd`. To run a subset:
+
+```bash
+python inference.py \
+  --model Qwen/Qwen2.5-VL-7B-Instruct \
+  --tasks monitoring_step,pmd \
+  --output runs/subset
+```
+
+## Generate Report
+
+```bash
+python generate_report.py \
+  --output runs/qwen25vl_7b \
+  --report-dir runs/report
+```
+
+Compare multiple model outputs:
+
+```bash
+python generate_report.py \
+  --output runs/qwen25vl_7b \
+  --compare runs/labos_vlm_7b \
+  --report-dir runs/comparison_report
+```
+
+The report command writes `report.md`, `metrics.json`, `metrics.csv`, and plots. Metrics include balanced accuracy, F1, precision, recall, parse success, and confusion matrices. For PMD, these metrics are computed for Error Detection.
+
+## Loading Examples
+
+```python
+from pathlib import Path
+
+from lsvbench.tasks import get_task
+
+root = Path(".")
+task = get_task("monitoring_step")
+rows = task.load_examples(benchmark_root=root, video_root=root, limit=5)
+
+for row in rows:
+    print(row["eval_id"], row["video_path"], row["target_step_id"])
+```
+
+Load the table manifests directly with PyArrow:
+
+```python
+import pyarrow.parquet as pq
+
+clips = pq.read_table("data/clips.parquet").to_pandas()
+pmd = pq.read_table("pmd/pmd.parquet").to_pandas()
+```
+
+## Intended Use
+
+This benchmark is intended for research on video-language models that assist with laboratory procedure monitoring, procedural state tracking, and visible error detection. It is not intended for clinical decision-making, safety-critical automation, or replacing trained human supervision in a real lab.
+
+## Limitations
+
+- The benchmark measures prompt-following and video understanding for specific LSV tasks; it is not a complete measure of wet-lab competence.
+- Some tasks use 640px video mirrors for practical inference speed, which may omit fine visual details present in the original-resolution videos.
+- PMD labels are designed for pipette-manipulation error detection and should not be interpreted as exhaustive procedural-error coverage.
+- Model outputs are parsed from raw text responses, so formatting failures can affect reported metrics. If you notice very low scores on PMD error classification type or errors, please inspect outputs first to ensure it's not a parsing issue.
+
+## License
+
+This public package is released for non-commercial research use under the Creative Commons Attribution-NonCommercial 4.0 license (`CC-BY-NC-4.0`). Users are responsible for ensuring that their use of the videos, manifests, and derived model outputs complies with the license and applicable institutional policies.
+
+## Research Use Only
+
+This dataset is provided for research purposes only and for non-commercial use. It is not intended for clinical decision-making, autonomous laboratory operation, or replacing trained human supervision in real wet-lab procedures.
+
+## Citation
+
+If you use this benchmark, please cite the LabOS manuscript or dataset release associated with this repository.

data/clips.parquet

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

data/dji.parquet

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

data/multiview.parquet

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

data/pmd.parquet

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

data/xm.parquet

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

generate_report.py

@@ -0,0 +1,26 @@
+#!/usr/bin/env python3
+"""Generate Markdown, JSON, CSV, and plots from benchmark raw outputs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+from pathlib import Path
+
+from lsvbench.report import generate_report
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--output", type=Path, action="append", required=True, help="Benchmark output directory. Can be repeated.")
+    parser.add_argument("--compare", type=Path, action="append", default=[], help="Additional output directory to compare.")
+    parser.add_argument("--report-dir", type=Path, help="Where to write report.md, metrics, and plots. Defaults to first --output.")
+    args = parser.parse_args()
+
+    output_dirs = [*args.output, *args.compare]
+    result = generate_report(output_dirs, report_dir=args.report_dir)
+    print(json.dumps(result, indent=2, sort_keys=True))
+
+
+if __name__ == "__main__":
+    main()

inference.py

@@ -0,0 +1,378 @@
+#!/usr/bin/env python3
+"""Reference Qwen/LabOS inference runner for standardized benchmark outputs."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import subprocess
+import sys
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+import torch
+from peft import PeftModel
+from qwen_vl_utils import process_vision_info
+from transformers import AutoConfig, AutoProcessor, Qwen2_5_VLForConditionalGeneration
+
+from lsvbench.io import BENCHMARK_ROOT, OutputLayout, merge_shards, write_json, write_jsonl
+from lsvbench.tasks import get_task
+
+
+DEFAULT_LSV_ROOT = BENCHMARK_ROOT
+MODEL_ALIASES = {
+    "labos-vlm7b": "Qwen/Qwen2.5-VL-7B-Instruct",
+    "labos-vlm-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
+    "qwen25-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
+    "qwen2.5-7b": "Qwen/Qwen2.5-VL-7B-Instruct",
+}
+ADAPTER_ALIASES = {
+    "labos-vlm7b": "cong-lab/labos-vlm-7b",
+    "labos-vlm-7b": "cong-lab/labos-vlm-7b",
+}
+MODEL_FAMILY_ALIASES = {
+    "auto": "auto",
+    "qwen25": "qwen2.5-vl",
+    "qwen25-vl": "qwen2.5-vl",
+    "qwen2.5": "qwen2.5-vl",
+    "qwen2.5-vl": "qwen2.5-vl",
+}
+QWEN25_VL_MODEL_TYPES = {"qwen2_5_vl"}
+QWEN25_VL_ARCHITECTURES = {"Qwen2_5_VLForConditionalGeneration"}
+
+
+def parse_gpus(value: str) -> list[str]:
+    text = value.strip()
+    if not text:
+        return ["0"]
+    if "-" in text and "," not in text:
+        start, end = [int(part) for part in text.split("-", 1)]
+        return [str(idx) for idx in range(start, end + 1)]
+    return [part.strip() for part in text.split(",") if part.strip()]
+
+
+def resolve_model(value: str) -> str:
+    return MODEL_ALIASES.get(value, value)
+
+
+def normalize_model_family(value: str) -> str:
+    family = MODEL_FAMILY_ALIASES.get(value.strip().lower())
+    if family is None:
+        supported = ", ".join(sorted(MODEL_FAMILY_ALIASES))
+        raise ValueError(f"Unsupported --model-family {value!r}. Supported values: {supported}")
+    return family
+
+
+def detect_model_family(model_name: str) -> str:
+    config = AutoConfig.from_pretrained(model_name, trust_remote_code=True)
+    model_type = str(getattr(config, "model_type", "") or "")
+    architectures = {str(item) for item in (getattr(config, "architectures", None) or [])}
+    if model_type in QWEN25_VL_MODEL_TYPES or architectures & QWEN25_VL_ARCHITECTURES:
+        return "qwen2.5-vl"
+    detail = f"model_type={model_type!r}, architectures={sorted(architectures)!r}"
+    raise ValueError(
+        "Could not infer a supported model family from model config "
+        f"for {model_name!r} ({detail}). Only qwen2.5-vl is currently implemented. "
+        "Pass --model-family qwen2.5-vl if this is a compatible Qwen2.5-VL checkpoint."
+    )
+
+
+def resolve_model_family(value: str, model_name: str) -> str:
+    family = normalize_model_family(value)
+    return detect_model_family(model_name) if family == "auto" else family
+
+
+def adapter_value(value: str | None) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    return None if not text or text.lower() in {"none", "null", "base"} else text
+
+
+def resolve_adapter(model_arg: str, adapter_arg: str | None) -> str | None:
+    explicit = adapter_value(adapter_arg)
+    return explicit if explicit is not None else ADAPTER_ALIASES.get(model_arg)
+
+
+def load_model(args: argparse.Namespace) -> tuple[Any, Any]:
+    model_name = resolve_model(args.model)
+    model_family = resolve_model_family(args.model_family, model_name)
+    if model_family != "qwen2.5-vl":
+        raise ValueError(f"Unsupported model family {model_family!r}. Only qwen2.5-vl is currently implemented.")
+    processor = AutoProcessor.from_pretrained(model_name, trust_remote_code=True)
+    model = Qwen2_5_VLForConditionalGeneration.from_pretrained(
+        model_name,
+        torch_dtype=torch.bfloat16,
+        device_map={"": "cuda:0"},
+        attn_implementation=args.attn_impl,
+        trust_remote_code=True,
+    )
+    adapter = resolve_adapter(args.model, args.adapter)
+    if adapter is not None:
+        model = PeftModel.from_pretrained(model, adapter)
+    model.eval()
+    return model, processor
+
+
+def normalize_video_kwargs(video_kwargs: dict[str, Any], batch_size: int) -> dict[str, Any]:
+    out = dict(video_kwargs)
+    for key, value in list(out.items()):
+        if isinstance(value, list) and len(value) == 1 and batch_size == 1:
+            out[key] = value[0]
+    return out
+
+
+def video_settings_for_task(task_name: str, args: argparse.Namespace) -> dict[str, Any]:
+    if task_name == "pmd":
+        return {
+            "fps": args.pmd_fps,
+            "min_frames": args.min_frames,
+            "max_frames": args.pmd_max_frames,
+            "min_pixels": args.min_pixels,
+            "max_pixels": args.pmd_max_pixels,
+        }
+    return {
+        "fps": args.fps,
+        "min_frames": args.min_frames,
+        "max_frames": args.max_frames,
+        "min_pixels": args.min_pixels,
+        "max_pixels": args.max_pixels,
+    }
+
+
+def prompt_for_row(task_name: str, row: dict[str, Any], args: argparse.Namespace) -> str:
+    if task_name == "pmd":
+        return Path(args.pmd_prompt).read_text(encoding="utf-8").strip()
+    return str(row["prompt"])
+
+
+def build_messages(task_name: str, row: dict[str, Any], args: argparse.Namespace) -> list[dict[str, Any]]:
+    video = {
+        "type": "video",
+        "video": row["_video_abs"],
+        **video_settings_for_task(task_name, args),
+    }
+    if task_name != "pmd":
+        video["video_start"] = float(row["video_start"])
+        video["video_end"] = float(row["video_end"])
+    return [
+        {
+            "role": "user",
+            "content": [
+                video,
+                {"type": "text", "text": prompt_for_row(task_name, row, args)},
+            ],
+        }
+    ]
+
+
+def generate_batch(model: Any, processor: Any, task_name: str, rows: list[dict[str, Any]], args: argparse.Namespace) -> list[str]:
+    batch_messages = [build_messages(task_name, row, args) for row in rows]
+    texts = [processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True) for messages in batch_messages]
+    image_inputs, video_inputs, video_kwargs = process_vision_info(batch_messages, return_video_kwargs=True)
+    video_kwargs = normalize_video_kwargs(video_kwargs, len(rows))
+    inputs = processor(
+        text=texts,
+        images=image_inputs,
+        videos=video_inputs,
+        padding=True,
+        return_tensors="pt",
+        **video_kwargs,
+    ).to(model.device)
+    with torch.inference_mode():
+        generated = model.generate(
+            **inputs,
+            max_new_tokens=args.pmd_max_new_tokens if task_name == "pmd" else args.max_new_tokens,
+            do_sample=False,
+            temperature=None,
+            top_p=None,
+        )
+    prompt_lens = inputs["attention_mask"].sum(dim=1).tolist()
+    decoded: list[str] = []
+    for idx, prompt_len in enumerate(prompt_lens):
+        text = processor.decode(
+            generated[idx, int(prompt_len) :],
+            skip_special_tokens=True,
+            clean_up_tokenization_spaces=False,
+        )
+        decoded.append(text.strip())
+    return decoded
+
+
+def safe_generate_batch(model: Any, processor: Any, task_name: str, rows: list[dict[str, Any]], args: argparse.Namespace) -> list[tuple[str, str | None]]:
+    try:
+        return [(text, None) for text in generate_batch(model, processor, task_name, rows, args)]
+    except Exception as exc:
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        if len(rows) == 1:
+            return [("", f"{type(exc).__name__}: {exc}")]
+        outputs: list[tuple[str, str | None]] = []
+        for row in rows:
+            outputs.extend(safe_generate_batch(model, processor, task_name, [row], args))
+        return outputs
+
+
+def chunks(rows: list[dict[str, Any]], size: int) -> list[list[dict[str, Any]]]:
+    return [rows[idx : idx + size] for idx in range(0, len(rows), size)]
+
+
+def record_for_output(task_name: str, row: dict[str, Any], raw: str, error: str | None, args: argparse.Namespace) -> dict[str, Any]:
+    keep = {key: value for key, value in row.items() if not key.startswith("_")}
+    keep.update(
+        {
+            "task": task_name,
+            "raw_response": raw,
+            "error": error,
+            "shard_index": args.shard_index,
+            "num_shards": args.num_shards,
+        }
+    )
+    return keep
+
+
+def run_worker(args: argparse.Namespace) -> None:
+    os.environ.setdefault("FORCE_QWENVL_VIDEO_READER", "decord")
+    task = get_task(args.task)
+    video_root = BENCHMARK_ROOT if args.task == "pmd" else args.lsv_root
+    rows = task.load_examples(
+        benchmark_root=BENCHMARK_ROOT,
+        manifest_path=args.manifest,
+        video_root=video_root,
+        num_shards=args.num_shards,
+        shard_index=args.shard_index,
+        limit=args.limit,
+    )
+    model, processor = load_model(args)
+    layout = OutputLayout(args.output)
+    result_path = layout.shard_path(args.task, args.shard_index)
+    result_path.parent.mkdir(parents=True, exist_ok=True)
+    records: list[dict[str, Any]] = []
+    batch_size = args.pmd_batch_size if args.task == "pmd" else args.batch_size
+    for batch in chunks(rows, batch_size):
+        generated = safe_generate_batch(model, processor, args.task, batch, args)
+        for row, (raw, error) in zip(batch, generated, strict=True):
+            record = record_for_output(args.task, row, raw, error, args)
+            records.append(record)
+            print(json.dumps({"task": args.task, "id": row.get("eval_id") or row.get("video_id"), "error": error}), flush=True)
+    write_jsonl(result_path, records)
+
+
+def launch_workers(args: argparse.Namespace) -> None:
+    gpus = parse_gpus(args.gpus)
+    args.output.mkdir(parents=True, exist_ok=True)
+    write_json(
+        args.output / "run_config.json",
+        {
+            "model": resolve_model(args.model),
+            "model_arg": args.model,
+            "model_family": resolve_model_family(args.model_family, resolve_model(args.model)),
+            "adapter": resolve_adapter(args.model, args.adapter),
+            "tasks": args.tasks.split(","),
+            "created_at": datetime.now(timezone.utc).isoformat(),
+            "gpus": gpus,
+            "fps": args.fps,
+            "max_frames": args.max_frames,
+            "max_pixels": args.max_pixels,
+            "pmd_fps": args.pmd_fps,
+            "pmd_max_frames": args.pmd_max_frames,
+            "pmd_max_pixels": args.pmd_max_pixels,
+        },
+    )
+    for task_name in [task.strip() for task in args.tasks.split(",") if task.strip()]:
+        procs: list[subprocess.Popen[Any]] = []
+        for shard_index, gpu in enumerate(gpus):
+            cmd = [
+                sys.executable,
+                str(Path(__file__).resolve()),
+                "--worker",
+                "--task",
+                task_name,
+                "--model",
+                args.model,
+                "--model-family",
+                args.model_family,
+                "--output",
+                str(args.output),
+                "--gpus",
+                gpu,
+                "--num-shards",
+                str(len(gpus)),
+                "--shard-index",
+                str(shard_index),
+                "--batch-size",
+                str(args.batch_size),
+                "--pmd-batch-size",
+                str(args.pmd_batch_size),
+                "--max-new-tokens",
+                str(args.max_new_tokens),
+                "--pmd-max-new-tokens",
+                str(args.pmd_max_new_tokens),
+                "--attn-impl",
+                args.attn_impl,
+                "--lsv-root",
+                str(args.lsv_root),
+            ]
+            effective_adapter = resolve_adapter(args.model, args.adapter)
+            if effective_adapter:
+                cmd.extend(["--adapter", effective_adapter])
+            if args.limit is not None:
+                cmd.extend(["--limit", str(args.limit)])
+            env = os.environ.copy()
+            env["CUDA_VISIBLE_DEVICES"] = gpu
+            env.setdefault("PYTHONPATH", str(BENCHMARK_ROOT))
+            env["PYTHONPATH"] = f"{BENCHMARK_ROOT}:{env['PYTHONPATH']}"
+            procs.append(subprocess.Popen(cmd, cwd=str(BENCHMARK_ROOT), env=env))
+        failures = [proc.wait() for proc in procs]
+        if any(code != 0 for code in failures):
+            raise SystemExit(f"Task {task_name} failed with exit codes: {failures}")
+        merge_shards(OutputLayout(args.output).task_dir(task_name), sort_key=get_task(task_name).sort_key)
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description=__doc__)
+    parser.add_argument("--model", required=True, help="Base or merged model as a Hugging Face repo ID, local path, or alias such as qwen25-7b.")
+    parser.add_argument(
+        "--model-family",
+        default="auto",
+        help="Inference backend to use: auto or qwen2.5-vl. Auto reads the model config from a Hugging Face repo ID or local path.",
+    )
+    parser.add_argument("--adapter", help="Optional PEFT/LoRA adapter as a Hugging Face repo ID or local path.")
+    parser.add_argument("--output", type=Path, required=True)
+    parser.add_argument("--tasks", default="monitoring_step,monitor_next_step,pmd")
+    parser.add_argument("--task", choices=sorted(["monitoring_step", "monitor_next_step", "pmd"]))
+    parser.add_argument("--manifest", type=Path)
+    parser.add_argument("--gpus", default="0")
+    parser.add_argument("--worker", action="store_true")
+    parser.add_argument("--num-shards", type=int, default=1)
+    parser.add_argument("--shard-index", type=int, default=0)
+    parser.add_argument("--limit", type=int)
+    parser.add_argument("--lsv-root", type=Path, default=DEFAULT_LSV_ROOT)
+    parser.add_argument("--batch-size", type=int, default=4)
+    parser.add_argument("--pmd-batch-size", type=int, default=4)
+    parser.add_argument("--fps", type=float, default=2.0)
+    parser.add_argument("--pmd-fps", type=float, default=8.0)
+    parser.add_argument("--min-frames", type=int, default=4)
+    parser.add_argument("--max-frames", type=int, default=128)
+    parser.add_argument("--pmd-max-frames", type=int, default=512)
+    parser.add_argument("--min-pixels", type=int, default=50176)
+    parser.add_argument("--max-pixels", type=int, default=100352)
+    parser.add_argument("--pmd-max-pixels", type=int, default=200704)
+    parser.add_argument("--max-new-tokens", type=int, default=2048)
+    parser.add_argument("--pmd-max-new-tokens", type=int, default=64)
+    parser.add_argument("--attn-impl", default="flash_attention_3")
+    parser.add_argument("--pmd-prompt", type=Path, default=BENCHMARK_ROOT / "lsvbench" / "tasks" / "prompts" / "pmd.md")
+    args = parser.parse_args()
+
+    if args.worker:
+        if not args.task:
+            raise SystemExit("--worker requires --task")
+        run_worker(args)
+    else:
+        launch_workers(args)
+
+
+if __name__ == "__main__":
+    main()

lsvbench/__init__.py

@@ -0,0 +1,8 @@
+"""Modular benchmark helpers for lab VLM evaluation."""
+
+from __future__ import annotations
+
+from .io import BENCHMARK_ROOT, OutputLayout
+from .tasks import TASK_REGISTRY, get_task
+
+__all__ = ["BENCHMARK_ROOT", "OutputLayout", "TASK_REGISTRY", "get_task"]

lsvbench/io.py

@@ -0,0 +1,135 @@
+"""I/O helpers and standard output layout for LSV benchmarks."""
+
+from __future__ import annotations
+
+import json
+import shutil
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any, Iterable
+
+
+BENCHMARK_ROOT = Path(__file__).resolve().parents[1]
+DATA_DIR = BENCHMARK_ROOT / "data"
+
+
+@dataclass(frozen=True)
+class OutputLayout:
+    root: Path
+
+    @property
+    def run_config_path(self) -> Path:
+        return self.root / "run_config.json"
+
+    def task_dir(self, task_name: str) -> Path:
+        return self.root / task_name
+
+    def predictions_path(self, task_name: str) -> Path:
+        return self.task_dir(task_name) / "predictions.jsonl"
+
+    def legacy_predictions_path(self, task_name: str) -> Path:
+        return self.task_dir(task_name) / "per_video_results.jsonl"
+
+    def shard_path(self, task_name: str, shard_index: int) -> Path:
+        return self.task_dir(task_name) / f"predictions_shard_{shard_index:02d}.jsonl"
+
+
+def read_json(path: Path) -> dict[str, Any]:
+    return json.loads(path.read_text(encoding="utf-8"))
+
+
+def write_json(path: Path, value: Any) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(value, indent=2, sort_keys=True, ensure_ascii=False) + "\n", encoding="utf-8")
+
+
+def read_jsonl(path: Path) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    if not path.exists():
+        return rows
+    with path.open("r", encoding="utf-8") as fh:
+        for line in fh:
+            line = line.strip()
+            if not line:
+                continue
+            try:
+                rows.append(json.loads(line))
+            except json.JSONDecodeError:
+                continue
+    return rows
+
+
+def write_jsonl(path: Path, rows: Iterable[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("w", encoding="utf-8") as fh:
+        for row in rows:
+            fh.write(json.dumps(row, ensure_ascii=False, sort_keys=True) + "\n")
+
+
+def append_jsonl(path: Path, row: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with path.open("a", encoding="utf-8") as fh:
+        fh.write(json.dumps(row, ensure_ascii=False) + "\n")
+
+
+def load_json_manifest(path: Path) -> dict[str, Any]:
+    return read_json(path)
+
+
+def manifest_examples(path: Path) -> list[dict[str, Any]]:
+    payload = load_json_manifest(path)
+    rows = payload.get("examples")
+    if not isinstance(rows, list):
+        raise ValueError(f"Manifest has no examples list: {path}")
+    return [dict(row) for row in rows if isinstance(row, dict)]
+
+
+def read_parquet(path: Path) -> list[dict[str, Any]]:
+    import pyarrow.parquet as pq
+
+    return pq.read_table(path).to_pylist()
+
+
+def select_shard(rows: list[dict[str, Any]], num_shards: int, shard_index: int) -> list[dict[str, Any]]:
+    if num_shards < 1:
+        raise ValueError("num_shards must be >= 1")
+    if not (0 <= shard_index < num_shards):
+        raise ValueError("shard_index must satisfy 0 <= shard_index < num_shards")
+    if num_shards == 1:
+        return rows
+    return [row for idx, row in enumerate(rows) if idx % num_shards == shard_index]
+
+
+def candidate_prediction_files(task_dir: Path) -> list[Path]:
+    paths = sorted(task_dir.glob("predictions_shard_*.jsonl"))
+    if paths:
+        return paths
+    paths = sorted(task_dir.glob("per_video_results_shard_*.jsonl"))
+    if paths:
+        return paths
+    for name in ("predictions.jsonl", "per_video_results.jsonl"):
+        path = task_dir / name
+        if path.exists():
+            return [path]
+    return []
+
+
+def load_prediction_rows(task_dir: Path, *, sort_key: str = "eval_id") -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for path in candidate_prediction_files(task_dir):
+        rows.extend(read_jsonl(path))
+    return sorted(rows, key=lambda row: str(row.get(sort_key) or row.get("video_id") or row.get("eval_id") or ""))
+
+
+def merge_shards(task_dir: Path, *, sort_key: str = "eval_id") -> list[dict[str, Any]]:
+    rows = load_prediction_rows(task_dir, sort_key=sort_key)
+    if rows:
+        write_jsonl(task_dir / "predictions.jsonl", rows)
+    return rows
+
+
+def copy_legacy_predictions(task_dir: Path) -> None:
+    predictions = task_dir / "predictions.jsonl"
+    legacy = task_dir / "per_video_results.jsonl"
+    if predictions.exists() and not legacy.exists():
+        shutil.copyfile(predictions, legacy)

lsvbench/metrics.py

@@ -0,0 +1,107 @@
+"""Generic metric helpers for benchmark tasks."""
+
+from __future__ import annotations
+
+import random
+import statistics
+from collections import Counter
+from typing import Any, Callable, Iterable
+
+
+def safe_div(num: float, denom: float) -> float | None:
+    return num / denom if denom else None
+
+
+def mean(values: Iterable[float | None]) -> float | None:
+    clean = [value for value in values if value is not None]
+    return sum(clean) / len(clean) if clean else None
+
+
+def classification_scores(
+    pairs: Iterable[tuple[Any, Any]],
+    *,
+    labels: Iterable[Any] | None = None,
+    none_is_wrong: bool = True,
+) -> dict[str, Any]:
+    """Compute accuracy, balanced accuracy, F1, precision, recall, and confusion."""
+    pair_list = list(pairs)
+    if labels is None:
+        label_values = sorted(
+            {
+                str(value)
+                for target, pred in pair_list
+                for value in (target, pred)
+                if value is not None
+            }
+        )
+    else:
+        label_values = [str(label) for label in labels]
+    total = len(pair_list)
+    correct = sum(1 for target, pred in pair_list if pred is not None and str(target) == str(pred))
+    target_total: Counter[str] = Counter()
+    pred_total: Counter[str] = Counter()
+    class_correct: Counter[str] = Counter()
+    confusion: Counter[str] = Counter()
+    for target, pred in pair_list:
+        target_s = str(target)
+        pred_s = "UNPARSED" if pred is None and none_is_wrong else str(pred)
+        target_total[target_s] += 1
+        pred_total[pred_s] += 1
+        confusion[f"{target_s}->{pred_s}"] += 1
+        if target_s == pred_s:
+            class_correct[target_s] += 1
+
+    recall: dict[str, float] = {}
+    precision: dict[str, float] = {}
+    f1: dict[str, float] = {}
+    for label in label_values:
+        recall[label] = class_correct[label] / target_total[label] if target_total[label] else 0.0
+        precision[label] = class_correct[label] / pred_total[label] if pred_total[label] else 0.0
+        denom = precision[label] + recall[label]
+        f1[label] = 2 * precision[label] * recall[label] / denom if denom else 0.0
+    return {
+        "accuracy": correct / total if total else None,
+        "balanced_accuracy": mean(recall.values()) if total and label_values else None,
+        "macro_f1": mean(f1.values()) if total and label_values else None,
+        "macro_precision": mean(precision.values()) if total and label_values else None,
+        "macro_recall": mean(recall.values()) if total and label_values else None,
+        "precision": precision,
+        "recall": recall,
+        "f1": f1,
+        "confusion": dict(confusion),
+        "target_counts": dict(target_total),
+        "pred_counts": dict(pred_total),
+    }
+
+
+def parse_success_rate(rows: list[dict[str, Any]], field: str = "pred_parse_ok") -> float | None:
+    if not rows:
+        return None
+    return sum(1 for row in rows if row.get(field)) / len(rows)
+
+
+def metric_value(summary: dict[str, Any], metric: str) -> float | None:
+    value = summary.get(metric)
+    return value if isinstance(value, (int, float)) else None
+
+
+def bootstrap_sem(
+    rows: list[dict[str, Any]],
+    metric: str,
+    summarize_fn: Callable[[list[dict[str, Any]]], dict[str, Any]],
+    *,
+    iterations: int = 500,
+    seed: int = 17,
+) -> float | None:
+    if not rows:
+        return None
+    rng = random.Random(f"{seed}:{metric}:{len(rows)}")
+    values: list[float] = []
+    for _ in range(iterations):
+        sample = [rows[rng.randrange(len(rows))] for _ in rows]
+        value = metric_value(summarize_fn(sample), metric)
+        if value is not None:
+            values.append(value)
+    if not values:
+        return None
+    return statistics.stdev(values) if len(values) > 1 else 0.0

lsvbench/parsing.py

@@ -0,0 +1,204 @@
+"""Pure parsing helpers for benchmark model outputs."""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any, Iterable, Mapping
+
+
+FENCED_JSON_RE = re.compile(r"^\s*```(?:json|JSON)?\s*(.*?)\s*```\s*$", re.DOTALL)
+
+
+def strip_markdown_json_fence(text: str) -> str:
+    cleaned = str(text or "").strip()
+    match = FENCED_JSON_RE.match(cleaned)
+    return match.group(1).strip() if match else cleaned
+
+
+def extract_json_text(text: str) -> str | None:
+    cleaned = strip_markdown_json_fence(text)
+    if not cleaned:
+        return None
+    start = cleaned.find("{")
+    if start < 0:
+        return None
+    depth = 0
+    in_string = False
+    escape = False
+    for idx, char in enumerate(cleaned[start:], start=start):
+        if in_string:
+            if escape:
+                escape = False
+            elif char == "\\":
+                escape = True
+            elif char == '"':
+                in_string = False
+            continue
+        if char == '"':
+            in_string = True
+        elif char == "{":
+            depth += 1
+        elif char == "}":
+            depth -= 1
+            if depth == 0:
+                return cleaned[start : idx + 1]
+    return None
+
+
+def extract_json_payload(text: str) -> dict[str, Any] | None:
+    payload_text = extract_json_text(text)
+    if not payload_text:
+        return None
+    try:
+        payload = json.loads(payload_text)
+    except Exception:
+        return None
+    return payload if isinstance(payload, dict) else None
+
+
+def normalize_step_id(value: Any) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text or text.lower() == "null":
+        return None
+    match = re.fullmatch(r"(?:step|s)[_\-\s]*(\d+)", text, flags=re.IGNORECASE)
+    if match:
+        return match.group(1)
+    digits = re.sub(r"\D+", "", text)
+    return digits or None
+
+
+def parse_bool_field(value: Any) -> bool | None:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    if text in {"true", "yes", "y", "1", "correct"}:
+        return True
+    if text in {"false", "no", "n", "0", "incorrect"}:
+        return False
+    return None
+
+
+def parse_step_field(value: Any) -> str | None:
+    return normalize_step_id(value)
+
+
+def _normalize_option(value: Any) -> str:
+    return re.sub(r"[\s\-]+", "_", str(value or "").strip().upper())
+
+
+def strip_answer_tag(text: str) -> str:
+    cleaned = str(text or "").strip()
+    match = re.fullmatch(r"<answer>\s*(.*?)\s*</answer>", cleaned, flags=re.IGNORECASE | re.DOTALL)
+    return match.group(1).strip() if match else cleaned
+
+
+def parse_choice_option(
+    text: str,
+    options: Iterable[str],
+    *,
+    json_keys: Iterable[str] = ("option", "answer", "prediction", "pred_option", "choice", "label", "mistake_type"),
+    number_map: Mapping[str, str] | None = None,
+) -> str | None:
+    option_list = [_normalize_option(option) for option in options]
+    option_set = set(option_list)
+    normalized_number_map = {
+        str(key): _normalize_option(value)
+        for key, value in (number_map or {}).items()
+    }
+
+    payload = extract_json_payload(text)
+    if payload is not None:
+        for key in json_keys:
+            if key not in payload:
+                continue
+            parsed = parse_choice_option(
+                str(payload[key]),
+                option_list,
+                json_keys=(),
+                number_map=normalized_number_map,
+            )
+            if parsed is not None:
+                return parsed
+
+    cleaned = strip_answer_tag(strip_markdown_json_fence(text))
+    upper = _normalize_option(cleaned)
+    if upper in option_set:
+        return upper
+    if upper in normalized_number_map:
+        return normalized_number_map[upper]
+
+    first_line = cleaned.splitlines()[0].strip() if cleaned else ""
+    first_token = re.split(r"[\s:.)\-\]]+", first_line, maxsplit=1)[0].strip().upper()
+    if first_token in normalized_number_map:
+        return normalized_number_map[first_token]
+    if first_token in option_set:
+        return first_token
+
+    pattern = r"\b(" + "|".join(re.escape(option) for option in sorted(option_set, key=len, reverse=True)) + r")\b"
+    matches = re.findall(pattern, _normalize_option(cleaned))
+    unique = sorted(set(matches))
+    return unique[0] if len(unique) == 1 else None
+
+
+def parse_monitoring_response(text: str) -> tuple[bool | None, str | None]:
+    cleaned = strip_markdown_json_fence(text)
+    payload = extract_json_payload(cleaned)
+    if payload is not None:
+        candidate = parse_bool_field(payload.get("candidate_matches_visible_step"))
+        step_id = payload.get("observed_step_id")
+        step_value = None if step_id in (None, "", "null") else str(step_id)
+        return candidate, step_value
+
+    upper = cleaned.upper()
+    if re.search(r"\b(TRUE|YES)\b", upper):
+        return True, None
+    if re.search(r"\b(FALSE|NO)\b", upper):
+        return False, None
+    return None, None
+
+
+def parse_next_step_delta_response(text: str) -> dict[str, Any]:
+    payload = extract_json_payload(text)
+    if payload is None:
+        return {
+            "pred_current_step_id": None,
+            "pred_has_error": None,
+            "pred_has_step_skipped": None,
+            "pred_error_type": None,
+            "pred_error_step_id": None,
+            "pred_parse_ok": False,
+        }
+    current = payload.get("current_step")
+    if current in (None, "", "null"):
+        current = None
+    errors = payload.get("errors")
+    if not isinstance(errors, list):
+        errors = []
+    parsed_errors = [item for item in errors if isinstance(item, dict)]
+    error_types = [
+        str(item.get("error_type") or "").strip()
+        for item in parsed_errors
+        if str(item.get("error_type") or "").strip()
+    ]
+    non_none_error_types = [kind for kind in error_types if kind.lower() != "none"]
+    skipped = any(kind.lower() == "step_skipped" for kind in error_types)
+    step_ref = None
+    for item in parsed_errors:
+        if str(item.get("error_type") or "").strip().lower() == "step_skipped":
+            step_ref = item.get("step_ref")
+            break
+    if step_ref in (None, "", "null"):
+        step_ref = None
+    return {
+        "pred_current_step_id": None if current is None else str(current),
+        "pred_has_error": bool(non_none_error_types),
+        "pred_has_step_skipped": skipped,
+        "pred_error_type": non_none_error_types[0] if non_none_error_types else None,
+        "pred_error_step_id": None if step_ref is None else str(step_ref),
+        "pred_parse_ok": True,
+    }

lsvbench/plots.py

@@ -0,0 +1,300 @@
+"""Standard matplotlib plots for benchmark reports."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import matplotlib.pyplot as plt
+
+
+TASK_METRICS = {
+    "monitoring_step": {
+        "source_task": "monitoring_step",
+        "label": "Step Prediction",
+        "balanced_accuracy": "step_balanced_accuracy",
+        "f1": "step_macro_f1",
+        "precision": "step_macro_precision",
+        "recall": "step_macro_recall",
+        "accuracy": "step_identification_accuracy",
+        "parse_success": "parse_success_rate",
+    },
+    "monitor_next_step": {
+        "source_task": "monitor_next_step",
+        "label": "Advance Prediction",
+        "balanced_accuracy": "advance_step_balanced_accuracy",
+        "f1": "advance_step_macro_f1",
+        "precision": "advance_step_macro_precision",
+        "recall": "advance_step_macro_recall",
+        "accuracy": "advance_step_accuracy",
+        "parse_success": "parse_success_rate",
+    },
+    "pmd_detection": {
+        "source_task": "pmd",
+        "label": "Error Detection",
+        "balanced_accuracy": "binary_balanced_accuracy",
+        "f1": "binary_macro_f1",
+        "precision": "binary_macro_precision",
+        "recall": "binary_macro_recall",
+        "accuracy": "binary_accuracy",
+        "parse_success": "parse_success_rate",
+    },
+}
+
+
+TASK_LABELS = {
+    "monitoring_step": "Step Prediction",
+    "monitor_next_step": "Advance Prediction",
+    "pmd": "Error Detection",
+    "pmd_detection": "Error Detection",
+}
+
+
+LSV_BALANCED_PANELS = [
+    ("monitoring_step", "step_balanced_accuracy", "Protocol Monitoring Step\nPrediction Accuracy"),
+    ("monitor_next_step", "advance_step_balanced_accuracy", "Protocol Monitoring Step\nAdvanced Prediction Accuracy"),
+    ("pmd", "binary_balanced_accuracy", "Error Detection"),
+]
+
+
+MODEL_STYLE = {
+    "cosmos_reason": ("Cosmos\nReason", "#6B7280"),
+    "qwen25vl_7b": ("Qwen2.5\n7B", "#8C6D31"),
+    "labos7b_lora750": ("LabOS\nVLM 7B", "#2A7F62"),
+    "qwen25vl_32b": ("Qwen2.5\n32B", "#B08A3C"),
+    "labos32b_lora750": ("LabOS\nVLM 32B", "#1F6B53"),
+    "labos7b_lora750_hf": ("LabOS\nVLM 7B HF", "#2A7F62"),
+}
+
+
+def _value(summary: dict[str, Any], metric: str) -> float:
+    value = summary.get(metric)
+    return float(value) * 100.0 if isinstance(value, (int, float)) else 0.0
+
+
+def _sem(summary: dict[str, Any], metric: str) -> float:
+    value = summary.get(f"{metric}_sem")
+    return float(value) * 100.0 if isinstance(value, (int, float)) else 0.0
+
+
+def _model_style(row: dict[str, Any]) -> tuple[str, str]:
+    key = str(row.get("model_key") or row.get("model_label") or "")
+    label = str(row.get("model_label") or key)
+    if key in MODEL_STYLE:
+        return MODEL_STYLE[key]
+    if label in MODEL_STYLE:
+        return MODEL_STYLE[label]
+    pretty = label.replace("_", "\n")
+    return pretty, "#4F9B7B"
+
+
+def _paper_x_positions(labels: list[str]) -> list[float]:
+    positions: list[float] = []
+    current = 0.0
+    previous = ""
+    for idx, label in enumerate(labels):
+        flat_label = label.replace("\n", " ")
+        if idx == 0:
+            current = 0.0
+        elif "Cosmos" in previous:
+            current += 1.25
+        elif "32B" in flat_label and "32B" not in previous:
+            current += 1.02
+        else:
+            current += 0.68
+        positions.append(current)
+        previous = flat_label
+    return positions
+
+
+def _paper_group_separators(labels: list[str], x: list[float]) -> list[float]:
+    separators: list[float] = []
+    for idx in range(len(labels) - 1):
+        left = labels[idx].replace("\n", " ")
+        right = labels[idx + 1].replace("\n", " ")
+        if "Cosmos" in left or ("32B" in right and "32B" not in left):
+            separators.append((x[idx] + x[idx + 1]) / 2.0)
+    return separators
+
+
+def plot_lsv_balanced_accuracy(model_results: list[dict[str, Any]], output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    labels: list[str] = []
+    colors: list[str] = []
+    for row in model_results:
+        label, color = _model_style(row)
+        labels.append(label)
+        colors.append(color)
+    x = _paper_x_positions(labels)
+    fig, axes = plt.subplots(1, 3, figsize=(9.4, 3.25), sharey=True)
+    for ax, (task_name, metric, title) in zip(axes, LSV_BALANCED_PANELS, strict=True):
+        values = []
+        errors = []
+        for row in model_results:
+            summary = row["tasks"].get(task_name, {})
+            values.append(_value(summary, metric))
+            errors.append(_sem(summary, metric))
+        bars = ax.bar(
+            x,
+            values,
+            width=0.66,
+            color=colors,
+            edgecolor="#2F2F2F",
+            linewidth=0.5,
+            yerr=errors,
+            capsize=2.5,
+            error_kw={"elinewidth": 0.8, "capthick": 0.8, "ecolor": "#333333"},
+        )
+        for bar, value, error in zip(bars, values, errors, strict=True):
+            ax.text(
+                bar.get_x() + bar.get_width() / 2,
+                value + error + 1.2,
+                f"{value:.0f}",
+                ha="center",
+                va="bottom",
+                fontsize=7,
+                clip_on=False,
+            )
+        ax.set_title(title, fontsize=10)
+        ax.set_ylim(0, 80)
+        ax.set_xticks(x)
+        ax.set_xticklabels(labels, fontsize=7)
+        for tick in ax.get_xticklabels():
+            if "LabOS" in tick.get_text():
+                tick.set_fontweight("bold")
+        for separator in _paper_group_separators(labels, x):
+            ax.axvline(separator, color="#6B7280", linewidth=0.6, alpha=0.35)
+        ax.spines["top"].set_visible(False)
+        ax.spines["right"].set_visible(False)
+    axes[0].set_ylabel(r"Accuracy (%) $\pm$ SEM")
+    fig.suptitle("LSV Benchmark v1", y=0.98, fontsize=11)
+    fig.tight_layout(pad=0.7, rect=(0, 0, 1, 0.95))
+    fig.savefig(output_path, dpi=220, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_grouped_metric(
+    model_results: list[dict[str, Any]],
+    *,
+    metric_kind: str,
+    output_path: Path,
+    ylabel: str,
+) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    models = [row["model_label"] for row in model_results]
+    tasks = [
+        task
+        for task, metrics in TASK_METRICS.items()
+        if any(metrics["source_task"] in row["tasks"] for row in model_results)
+    ]
+    x = list(range(len(tasks)))
+    width = min(0.8 / max(len(models), 1), 0.22)
+    fig, ax = plt.subplots(figsize=(max(6.5, 1.2 * len(tasks) + 0.8 * len(models)), 3.8))
+    for model_idx, row in enumerate(model_results):
+        offsets = [pos + (model_idx - (len(models) - 1) / 2) * width for pos in x]
+        values = []
+        errors = []
+        for task in tasks:
+            task_metrics = TASK_METRICS[task]
+            summary = row["tasks"].get(task_metrics["source_task"], {})
+            metric = TASK_METRICS[task][metric_kind]
+            values.append(_value(summary, metric))
+            errors.append(_sem(summary, metric))
+        ax.bar(offsets, values, width=width, label=row["model_label"], yerr=errors, capsize=2)
+    ax.set_title(f"{metric_kind.replace('_', ' ').title()} Across Tasks")
+    ax.set_ylabel(ylabel)
+    ax.set_ylim(0, 105)
+    ax.set_xticks(x)
+    ax.set_xticklabels([TASK_METRICS[task]["label"] for task in tasks])
+    ax.legend(fontsize=7)
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=220, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_composite(model_results: list[dict[str, Any]], output_path: Path) -> None:
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    labels = [row["model_label"] for row in model_results]
+    values = []
+    for row in model_results:
+        task_values = []
+        for _, metrics in TASK_METRICS.items():
+            source_task = metrics["source_task"]
+            if source_task in row["tasks"]:
+                value = row["tasks"][source_task].get(metrics["balanced_accuracy"])
+                if isinstance(value, (int, float)):
+                    task_values.append(float(value))
+        values.append((sum(task_values) / len(task_values) * 100.0) if task_values else 0.0)
+    fig, ax = plt.subplots(figsize=(max(5.5, 0.8 * len(labels)), 3.4))
+    bars = ax.bar(range(len(labels)), values, color="#4F9B7B", edgecolor="#2F2F2F", linewidth=0.5)
+    for bar, value in zip(bars, values, strict=True):
+        ax.text(bar.get_x() + bar.get_width() / 2, value + 1, f"{value:.0f}", ha="center", va="bottom", fontsize=8)
+    ax.set_title("Composite Balanced Accuracy")
+    ax.set_ylabel("Score (%)")
+    ax.set_ylim(0, 105)
+    ax.set_xticks(range(len(labels)))
+    ax.set_xticklabels(labels, rotation=25, ha="right")
+    ax.spines["top"].set_visible(False)
+    ax.spines["right"].set_visible(False)
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=220, bbox_inches="tight")
+    plt.close(fig)
+
+
+def plot_confusion(confusion: dict[str, int], output_path: Path, title: str) -> None:
+    if not confusion:
+        return
+    labels = sorted({part for key in confusion for part in key.split("->", 1)})
+    matrix = [[confusion.get(f"{target}->{pred}", 0) for pred in labels] for target in labels]
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    fig, ax = plt.subplots(figsize=(max(4.2, 0.55 * len(labels)), max(3.8, 0.45 * len(labels))))
+    image = ax.imshow(matrix, cmap="Blues")
+    ax.set_title(title)
+    ax.set_xlabel("Predicted")
+    ax.set_ylabel("Target")
+    ax.set_xticks(range(len(labels)))
+    ax.set_xticklabels(labels, rotation=45, ha="right", fontsize=7)
+    ax.set_yticks(range(len(labels)))
+    ax.set_yticklabels(labels, fontsize=7)
+    for row_idx, row in enumerate(matrix):
+        for col_idx, value in enumerate(row):
+            ax.text(col_idx, row_idx, str(value), ha="center", va="center", fontsize=7)
+    fig.colorbar(image, ax=ax, fraction=0.046, pad=0.04)
+    fig.tight_layout()
+    fig.savefig(output_path, dpi=220, bbox_inches="tight")
+    plt.close(fig)
+
+
+def write_standard_plots(model_results: list[dict[str, Any]], output_dir: Path) -> list[Path]:
+    plots_dir = output_dir / "plots"
+    paths: list[Path] = []
+    plot_composite(model_results, plots_dir / "composite_balanced_accuracy.png")
+    paths.append(plots_dir / "composite_balanced_accuracy.png")
+    plot_lsv_balanced_accuracy(model_results, plots_dir / "lsv_benchmark_v1_balanced_accuracy.png")
+    paths.append(plots_dir / "lsv_benchmark_v1_balanced_accuracy.png")
+    for metric_kind, ylabel in (
+        ("balanced_accuracy", "Balanced Accuracy (%)"),
+        ("f1", "F1 (%)"),
+        ("precision", "Macro Precision (%)"),
+        ("recall", "Macro Recall (%)"),
+        ("parse_success", "Parse Success (%)"),
+    ):
+        path = plots_dir / f"{metric_kind}.png"
+        plot_grouped_metric(model_results, metric_kind=metric_kind, output_path=path, ylabel=ylabel)
+        paths.append(path)
+    for row in model_results:
+        safe_model = row["model_label"].replace("/", "_")
+        for task, summary in row["tasks"].items():
+            confusion = (
+                summary.get("step_confusion")
+                or summary.get("advance_step_confusion")
+                or summary.get("binary_confusion")
+                or {}
+            )
+            path = plots_dir / f"{safe_model}_{task}_confusion.png"
+            plot_confusion(confusion, path, f"{row['model_label']} - {TASK_LABELS.get(task, task)} Confusion")
+            if path.exists():
+                paths.append(path)
+    return paths

lsvbench/prompts.py

@@ -0,0 +1,211 @@
+"""Reusable prompt builders for LSV benchmark tasks."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Literal
+
+ProtocolStyle = Literal["json", "flat_numbered", "substeps", "substeps_with_details"]
+
+MONITORING_DELTA_SCHEMA: dict[str, Any] = {
+    "current_step": "step_id string or null",
+    "new_notes": [
+        {
+            "t": "number  # start time of the action in seconds",
+            "note": "string  # concise natural-language observation",
+        }
+    ],
+    "errors": [
+        {
+            "t": "number",
+            "error_type": (
+                "step_skipped | step_reordered | reagent_wrong | volume_wrong | "
+                "technique_error | contamination_risk | timing_error | none"
+            ),
+            "step_ref": "step_id string or null",
+            "description": "string",
+        }
+    ],
+    "suggestion": "string or null  # brief next-action hint for the user",
+}
+
+
+def compact_json(value: Any) -> str:
+    return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
+
+
+def response_format_block(skeleton: Any) -> str:
+    rendered = skeleton.strip() if isinstance(skeleton, str) else json.dumps(skeleton, ensure_ascii=False, sort_keys=True, indent=2)
+    return f"Return strict JSON only.\n\n## Response Format\n{rendered}"
+
+
+def render_monitoring_delta_prompt(state: dict[str, Any]) -> str:
+    instructions = [
+        "You are a real-time lab assistant monitoring a scientist's wet-lab procedure from short video windows.",
+        "The current protocol state/history is provided below. Watch the current window and update the state.",
+        "Report protocol errors only when supported by the visible time window or state.",
+        "Ignore irrelevant unknown keys in the state JSON.",
+        "Given the protocol being followed, the history of completed steps, and a new video window, update the monitoring state by returning a delta JSON.",
+    ]
+    return "\n\n".join(
+        [
+            *instructions,
+            f"STATE:\n{compact_json(state)}",
+            response_format_block(MONITORING_DELTA_SCHEMA),
+            "Return a delta JSON for only the watched lab video window.",
+        ]
+    )
+
+
+def _load_protocol(protocol: dict[str, Any] | str) -> dict[str, Any]:
+    return json.loads(protocol) if isinstance(protocol, str) and protocol.strip() else (protocol if isinstance(protocol, dict) else {})
+
+
+def executable_steps(protocol: dict[str, Any] | str) -> list[dict[str, Any]]:
+    payload = _load_protocol(protocol)
+    return [
+        step
+        for step in list(payload.get("steps") or [])
+        if isinstance(step, dict) and str(step.get("text") or "").strip()
+    ]
+
+
+def protocol_to_text(protocol: dict[str, Any] | str, style: ProtocolStyle = "flat_numbered") -> str:
+    payload = _load_protocol(protocol)
+    if style == "json":
+        return compact_json(payload)
+    if style == "flat_numbered":
+        return "\n".join(
+            f"{idx}. {step.get('text', '')}"
+            for idx, step in enumerate(executable_steps(payload), start=1)
+        )
+    title = str(payload.get("title") or "Demonstrated procedure").strip()
+    lines = [f"1. {title}"]
+    include_details = style == "substeps_with_details"
+    for idx, step in enumerate(executable_steps(payload), start=1):
+        suffix = ""
+        if include_details:
+            details = []
+            if step.get("demonstrated") is not None:
+                details.append(f"demonstrated={bool(step.get('demonstrated'))}")
+            if step.get("t_start") is not None and step.get("t_end") is not None:
+                details.append(f"time={float(step['t_start']):.1f}-{float(step['t_end']):.1f}s")
+            suffix = f" ({'; '.join(details)})" if details else ""
+        lines.append(f"  1.{idx}. {step.get('text', '')}{suffix}")
+    return "\n".join(lines)
+
+
+def protocol_response_format(output_style: ProtocolStyle = "flat_numbered", include_flat_lists: bool = False) -> str:
+    if output_style == "json":
+        return response_format_block(
+            {
+                "title": "string",
+                "summary": "string or null",
+                "steps": [
+                    {
+                        "step_id": "string",
+                        "order": "number or null",
+                        "text": "string",
+                        "reagents": ["string"],
+                        "equipment": ["string"],
+                        "objects": ["string"],
+                    }
+                ],
+            }
+        )
+    if output_style == "flat_numbered":
+        lists = "\n\nReagent List:\n1. <observed reagent or material>\n\nTools Used:\n1. <observed tool or equipment>" if include_flat_lists else ""
+        return "\n".join(
+            [
+                "Please respond with the following format:",
+                "",
+                "## Response Format",
+                "1. <observed action step with no substeps>",
+                "2. <observed action step with no substeps>",
+                lists,
+                "",
+                "Use simple flat numbered protocol steps. Do not include step IDs, substeps, bullets, or JSON.",
+                "",
+                "## Question",
+            ]
+        )
+    return "\n".join(
+        [
+            "Please respond with the following format:",
+            "",
+            "## Response Format",
+            "1. <section or procedure title>",
+            "  1.1. <observed action>",
+            "  1.2. <observed action>",
+            "",
+            "Use numbered sections and substeps. Do not include JSON.",
+            "",
+            "## Question",
+        ]
+    )
+
+
+def _timed_steps(protocol: dict[str, Any] | str) -> list[dict[str, Any]]:
+    rows = [
+        step
+        for step in executable_steps(protocol)
+        if step.get("t_start") is not None and step.get("t_end") is not None
+    ]
+    return sorted(rows, key=lambda row: (float(row["t_start"]), float(row["t_end"])))
+
+
+def step_timeline_text(protocol: dict[str, Any] | str) -> str:
+    """Render demonstrated protocol steps as timestamped timeline lines."""
+    lines = []
+    for step in _timed_steps(protocol):
+        start = float(step["t_start"])
+        end = float(step["t_end"])
+        step_id = str(step.get("step_id") or "?")
+        text = str(step.get("text") or "")
+        lines.append(f"[{start:.1f}-{end:.1f}s] step {step_id}: {text}")
+    return "\n".join(lines)
+
+
+def monitoring_state(protocol: dict[str, Any] | str, t: float) -> dict[str, Any]:
+    """Return completed/current/remaining timed protocol steps at timestamp ``t``."""
+    completed: list[dict[str, Any]] = []
+    current: list[dict[str, Any]] = []
+    remaining: list[dict[str, Any]] = []
+    for step in _timed_steps(protocol):
+        start = float(step["t_start"])
+        end = float(step["t_end"])
+        item = {
+            "step_id": str(step.get("step_id") or "?"),
+            "text": str(step.get("text") or ""),
+            "t_start": start,
+            "t_end": end,
+        }
+        if end <= t:
+            completed.append(item)
+        elif start <= t <= end:
+            current.append(item)
+        else:
+            remaining.append(item)
+    return {"t": float(t), "completed": completed, "current": current, "remaining": remaining}
+
+
+def error_summary(row: dict[str, Any]) -> str:
+    """Summarize the flat benchmark error fields from a parquet row."""
+    if not row.get("has_error"):
+        return "No annotated procedural error."
+    error = str(row.get("error") or "").strip()
+    return f"Error: {error}" if error else "Annotated procedural error present."
+
+
+def row_video_context(row: dict[str, Any], include_timeline: bool = True) -> str:
+    operation = str(row.get("operation") or row.get("protocol_title") or "the demonstrated wet-lab procedure").strip()
+    lines = [f"Reconstruct the demonstrated protocol for {operation}."]
+    if row.get("error"):
+        lines.append("If an error is visible, include only the observed action sequence; do not add diagnostic commentary.")
+    if include_timeline and row.get("protocol_json"):
+        timeline = step_timeline_text(row["protocol_json"])
+        if timeline:
+            lines.extend(["", "Visible timeline:", timeline])
+    return "\n".join(line for line in lines if str(line).strip())
+
+

lsvbench/report.py

@@ -0,0 +1,151 @@
+"""Markdown report generation for standardized benchmark outputs."""
+
+from __future__ import annotations
+
+import csv
+from pathlib import Path
+from typing import Any
+
+from .io import OutputLayout, load_prediction_rows, read_json, write_json
+from .plots import TASK_LABELS, TASK_METRICS, write_standard_plots
+from .tasks import TASK_REGISTRY
+
+
+def _model_key(output_dir: Path) -> str:
+    config_path = output_dir / "run_config.json"
+    if config_path.exists():
+        config = read_json(config_path)
+        return str(config.get("model") or config.get("model_path") or output_dir.name)
+    return output_dir.name
+
+
+def _model_label(output_dir: Path) -> str:
+    key = _model_key(output_dir)
+    return output_dir.name if output_dir.name not in {"output", "outputs"} else key
+
+
+def score_output_dir(output_dir: Path) -> dict[str, Any]:
+    layout = OutputLayout(output_dir)
+    tasks: dict[str, Any] = {}
+    for task_name, task in TASK_REGISTRY.items():
+        task_dir = layout.task_dir(task_name)
+        rows = load_prediction_rows(task_dir, sort_key=task.sort_key)
+        if not rows:
+            continue
+        parsed_rows = task.parse_rows(rows)
+        # Materialize normalized predictions for easier auditing.
+        from .io import write_jsonl
+
+        write_jsonl(task_dir / "predictions_scored.jsonl", parsed_rows)
+        tasks[task_name] = task.score(parsed_rows)
+    return {
+        "model_key": _model_key(output_dir),
+        "model_label": _model_label(output_dir),
+        "output_dir": str(output_dir),
+        "tasks": tasks,
+    }
+
+
+def flatten_metrics(model_results: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    rows: list[dict[str, Any]] = []
+    for model in model_results:
+        for task_name, metric_map in TASK_METRICS.items():
+            source_task = metric_map["source_task"]
+            summary = model["tasks"].get(source_task)
+            if not summary:
+                continue
+            rows.append(
+                {
+                    "model": model["model_key"],
+                    "model_label": model["model_label"],
+                    "task": task_name,
+                    "task_label": metric_map["label"],
+                    "rows": summary.get("rows"),
+                    "scored": summary.get("scored"),
+                    "errors": summary.get("errors"),
+                    "parse_errors": summary.get("parse_errors"),
+                    "parse_success_rate": summary.get("parse_success_rate"),
+                    "accuracy": summary.get(metric_map.get("accuracy", "")),
+                    "balanced_accuracy": summary.get(metric_map.get("balanced_accuracy", "")),
+                    "f1": summary.get(metric_map.get("f1", "")),
+                    "precision": summary.get(metric_map.get("precision", "")),
+                    "recall": summary.get(metric_map.get("recall", "")),
+                }
+            )
+    return rows
+
+
+def write_metrics_csv(path: Path, rows: list[dict[str, Any]]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    if not rows:
+        path.write_text("", encoding="utf-8")
+        return
+    with path.open("w", encoding="utf-8", newline="") as fh:
+        writer = csv.DictWriter(fh, fieldnames=list(rows[0]))
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def _pct(value: Any) -> str:
+    return f"{float(value) * 100:.1f}%" if isinstance(value, (int, float)) else "n/a"
+
+
+def write_report_md(report_dir: Path, model_results: list[dict[str, Any]], metric_rows: list[dict[str, Any]], plot_paths: list[Path]) -> None:
+    lines = [
+        "# Benchmark Report",
+        "",
+        "This report is generated from raw model outputs. Responses are parsed and scored at report time.",
+        "",
+        "## Summary Metrics",
+        "",
+        "| Model | Task | Balanced Accuracy | F1 | Precision | Recall | Parse Success |",
+        "|---|---|---:|---:|---:|---:|---:|",
+    ]
+    for row in metric_rows:
+        lines.append(
+            "| {model_label} | {task_label} | {balanced_accuracy} | {f1} | {precision} | {recall} | {parse_success_rate} |".format(
+                model_label=row["model_label"],
+                task_label=row["task_label"],
+                balanced_accuracy=_pct(row["balanced_accuracy"]),
+                f1=_pct(row["f1"]),
+                precision=_pct(row["precision"]),
+                recall=_pct(row["recall"]),
+                parse_success_rate=_pct(row["parse_success_rate"]),
+            )
+        )
+    lines.extend(["", "## Plots", ""])
+    for path in plot_paths:
+        rel = path.relative_to(report_dir)
+        title = path.stem.replace("_", " ").title()
+        lines.extend([f"### {title}", "", f"![{title}]({rel.as_posix()})", ""])
+    lines.extend(["## Task Details", ""])
+    for model in model_results:
+        lines.extend([f"### {model['model_label']}", ""])
+        for task_name, summary in model["tasks"].items():
+            lines.extend(
+                [
+                    f"#### {TASK_LABELS.get(task_name, task_name)}",
+                    "",
+                    f"- Rows: `{summary.get('rows')}`",
+                    f"- Scored: `{summary.get('scored')}`",
+                    f"- Errors: `{summary.get('errors')}`",
+                    f"- Parse errors: `{summary.get('parse_errors')}`",
+                    f"- Parse success: `{_pct(summary.get('parse_success_rate'))}`",
+                    "",
+                ]
+            )
+    (report_dir / "report.md").write_text("\n".join(lines), encoding="utf-8")
+
+
+def generate_report(output_dirs: list[Path], report_dir: Path | None = None) -> dict[str, Any]:
+    if not output_dirs:
+        raise ValueError("Provide at least one output directory.")
+    report_dir = report_dir or output_dirs[0]
+    report_dir.mkdir(parents=True, exist_ok=True)
+    model_results = [score_output_dir(path) for path in output_dirs]
+    metric_rows = flatten_metrics(model_results)
+    write_json(report_dir / "metrics.json", {"models": model_results, "rows": metric_rows})
+    write_metrics_csv(report_dir / "metrics.csv", metric_rows)
+    plot_paths = write_standard_plots(model_results, report_dir)
+    write_report_md(report_dir, model_results, metric_rows, plot_paths)
+    return {"report_dir": str(report_dir), "models": [row["model_key"] for row in model_results], "plots": [str(path) for path in plot_paths]}

lsvbench/tasks/__init__.py

@@ -0,0 +1,23 @@
+"""Built-in benchmark task registry."""
+
+from __future__ import annotations
+
+from .base import BenchmarkTask
+from .monitor_next_step import MonitorNextStepTask
+from .monitoring_step import MonitoringStepTask
+from .pmd import PmdTask
+
+
+TASK_REGISTRY: dict[str, BenchmarkTask] = {
+    "monitoring_step": MonitoringStepTask(),
+    "monitor_next_step": MonitorNextStepTask(),
+    "pmd": PmdTask(),
+}
+
+
+def get_task(name: str) -> BenchmarkTask:
+    try:
+        return TASK_REGISTRY[name]
+    except KeyError as exc:
+        known = ", ".join(sorted(TASK_REGISTRY))
+        raise KeyError(f"Unknown task {name!r}. Known tasks: {known}") from exc

lsvbench/tasks/base.py

@@ -0,0 +1,56 @@
+"""Task interface for modular benchmark parsing and scoring."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from ..io import BENCHMARK_ROOT
+
+
+@dataclass(frozen=True)
+class TaskSpec:
+    name: str
+    display_name: str
+    default_manifest: Path | None
+    sort_key: str = "eval_id"
+
+
+class BenchmarkTask:
+    spec: TaskSpec
+    primary_metric: str
+
+    @property
+    def name(self) -> str:
+        return self.spec.name
+
+    @property
+    def display_name(self) -> str:
+        return self.spec.display_name
+
+    @property
+    def default_manifest(self) -> Path | None:
+        return self.spec.default_manifest
+
+    @property
+    def sort_key(self) -> str:
+        return self.spec.sort_key
+
+    def load_examples(
+        self,
+        *,
+        benchmark_root: Path = BENCHMARK_ROOT,
+        manifest_path: Path | None = None,
+        video_root: Path | None = None,
+    ) -> list[dict[str, Any]]:
+        raise NotImplementedError
+
+    def parse_record(self, row: dict[str, Any]) -> dict[str, Any]:
+        raise NotImplementedError
+
+    def parse_rows(self, rows: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        return [self.parse_record(dict(row)) for row in rows]
+
+    def score(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        raise NotImplementedError

lsvbench/tasks/monitor_next_step.py

@@ -0,0 +1,140 @@
+"""Finetune-style monitor-next delta task."""
+
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from ..io import BENCHMARK_ROOT, DATA_DIR, manifest_examples, select_shard
+from ..metrics import bootstrap_sem, classification_scores
+from ..parsing import normalize_step_id, parse_next_step_delta_response
+from .base import BenchmarkTask, TaskSpec
+
+
+class MonitorNextStepTask(BenchmarkTask):
+    spec = TaskSpec(
+        name="monitor_next_step",
+        display_name="Protocol Monitoring Advance Prediction",
+        default_manifest=DATA_DIR / "monitor_next_step.json",
+    )
+    primary_metric = "advance_step_balanced_accuracy"
+
+    def load_examples(
+        self,
+        *,
+        benchmark_root: Path = BENCHMARK_ROOT,
+        manifest_path: Path | None = None,
+        video_root: Path | None = None,
+        num_shards: int = 1,
+        shard_index: int = 0,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        rows = manifest_examples(manifest_path or self.default_manifest)
+        root = video_root or benchmark_root
+        for row in rows:
+            row["task"] = self.name
+            row["_video_abs"] = str(root / str(row["video_path"]))
+        rows = sorted(rows, key=lambda row: str(row.get("eval_id")))
+        if limit is not None:
+            rows = rows[:limit]
+        return select_shard(rows, num_shards, shard_index)
+
+    def parse_record(self, row: dict[str, Any]) -> dict[str, Any]:
+        if row.get("error"):
+            return row
+        parsed = parse_next_step_delta_response(str(row.get("raw_response") or ""))
+        pred_current_norm = normalize_step_id(parsed.get("pred_current_step_id"))
+        target_current_norm = normalize_step_id(row.get("target_current_step_id"))
+        target_start_norm = normalize_step_id(row.get("target_start_step_id"))
+        pred_advances = None
+        if pred_current_norm is not None and target_start_norm is not None:
+            pred_advances = pred_current_norm != target_start_norm
+        row.update(
+            {
+                **parsed,
+                "pred_current_step_id_normalized": pred_current_norm,
+                "target_current_step_id_normalized": target_current_norm,
+                "pred_advances_step": pred_advances,
+                "current_step_correct": pred_current_norm is not None and pred_current_norm == target_current_norm,
+            }
+        )
+        return row
+
+    def _summary(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        scored = [row for row in parsed if not row.get("error")]
+        current_correct = 0
+        current_parsed = 0
+        advance_pairs: list[tuple[str, str | None]] = []
+        skipped_pairs: list[tuple[str, str | None]] = []
+        skipped_step_ref_correct = 0
+        skipped_step_ref_total = 0
+        for row in scored:
+            pred_current = normalize_step_id(row.get("pred_current_step_id"))
+            target_current = normalize_step_id(row.get("target_current_step_id"))
+            target_start = normalize_step_id(row.get("target_start_step_id"))
+            if pred_current is not None:
+                current_parsed += 1
+            current_correct += int(pred_current is not None and pred_current == target_current)
+            pred_advances = None
+            if pred_current is not None and target_start is not None:
+                pred_advances = pred_current != target_start
+            advance_pairs.append((str(bool(row.get("target_advances_step"))), None if pred_advances is None else str(bool(pred_advances))))
+            skipped_pred = row.get("pred_has_step_skipped")
+            skipped_pairs.append((str(bool(row.get("target_has_error"))), None if skipped_pred is None else str(bool(skipped_pred))))
+            if row.get("target_has_error"):
+                skipped_step_ref_total += 1
+                pred_ref = normalize_step_id(row.get("pred_error_step_id"))
+                target_ref = normalize_step_id(row.get("target_error_step_id"))
+                skipped_step_ref_correct += int(pred_ref is not None and pred_ref == target_ref)
+        advance = classification_scores(advance_pairs, labels=["False", "True"])
+        skipped = classification_scores(skipped_pairs, labels=["False", "True"])
+        n = len(scored)
+        parse_errors = sum(1 for row in scored if not row.get("pred_parse_ok"))
+        return {
+            "task": self.name,
+            "display_name": self.display_name,
+            "rows": len(rows),
+            "scored": n,
+            "errors": sum(1 for row in rows if row.get("error")),
+            "parse_errors": parse_errors,
+            "parse_success_rate": (n - parse_errors) / n if n else None,
+            "current_step_accuracy": current_correct / n if n else None,
+            "current_step_accuracy_parsed_only": current_correct / current_parsed if current_parsed else None,
+            "advance_step_accuracy": advance["accuracy"],
+            "advance_step_balanced_accuracy": advance["balanced_accuracy"],
+            "advance_step_macro_f1": advance["macro_f1"],
+            "advance_step_macro_precision": advance["macro_precision"],
+            "advance_step_macro_recall": advance["macro_recall"],
+            "advance_step_precision": advance["precision"],
+            "advance_step_recall": advance["recall"],
+            "advance_step_f1": advance["f1"],
+            "advance_step_confusion": advance["confusion"],
+            "skipped_step_accuracy": skipped["accuracy"],
+            "skipped_step_balanced_accuracy": skipped["balanced_accuracy"],
+            "skipped_step_macro_f1": skipped["macro_f1"],
+            "skipped_step_macro_precision": skipped["macro_precision"],
+            "skipped_step_macro_recall": skipped["macro_recall"],
+            "skipped_step_confusion": skipped["confusion"],
+            "skipped_step_ref_accuracy": skipped_step_ref_correct / skipped_step_ref_total if skipped_step_ref_total else None,
+            "task_counts": dict(Counter(str(row.get("task_type")) for row in scored)),
+            "history_variant_counts": dict(Counter(str(row.get("history_variant")) for row in scored)),
+            "window_kind_counts": dict(Counter(str(row.get("window_kind")) for row in scored)),
+        }
+
+    def score(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        summary = self._summary(parsed)
+        for metric in (
+            "advance_step_accuracy",
+            "advance_step_balanced_accuracy",
+            "advance_step_macro_f1",
+            "advance_step_macro_precision",
+            "advance_step_macro_recall",
+            "skipped_step_accuracy",
+            "skipped_step_balanced_accuracy",
+            "skipped_step_macro_f1",
+        ):
+            summary[f"{metric}_sem"] = bootstrap_sem(parsed, metric, self._summary, iterations=200)
+        return summary

lsvbench/tasks/monitoring_step.py

@@ -0,0 +1,121 @@
+"""Monitoring step-identification task."""
+
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from ..io import BENCHMARK_ROOT, DATA_DIR, manifest_examples, select_shard
+from ..metrics import bootstrap_sem, classification_scores
+from ..parsing import normalize_step_id, parse_monitoring_response
+from .base import BenchmarkTask, TaskSpec
+
+
+class MonitoringStepTask(BenchmarkTask):
+    spec = TaskSpec(
+        name="monitoring_step",
+        display_name="Protocol Monitoring Step Prediction",
+        default_manifest=DATA_DIR / "monitoring_step_eval.json",
+    )
+    primary_metric = "step_balanced_accuracy"
+
+    def load_examples(
+        self,
+        *,
+        benchmark_root: Path = BENCHMARK_ROOT,
+        manifest_path: Path | None = None,
+        video_root: Path | None = None,
+        num_shards: int = 1,
+        shard_index: int = 0,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        rows = manifest_examples(manifest_path or self.default_manifest)
+        root = video_root or benchmark_root
+        for row in rows:
+            row["task"] = self.name
+            row["_video_abs"] = str(root / str(row["video_path"]))
+        rows = sorted(rows, key=lambda row: str(row.get("eval_id")))
+        if limit is not None:
+            rows = rows[:limit]
+        return select_shard(rows, num_shards, shard_index)
+
+    def parse_record(self, row: dict[str, Any]) -> dict[str, Any]:
+        if row.get("error"):
+            return row
+        raw = str(row.get("raw_response") or "")
+        pred_candidate, pred_step = parse_monitoring_response(raw) if raw else (None, None)
+        pred_step_normalized = normalize_step_id(pred_step)
+        target_step_normalized = normalize_step_id(row.get("target_step_id"))
+        row.update(
+            {
+                "pred_candidate_matches": pred_candidate,
+                "pred_observed_step_id": pred_step,
+                "pred_observed_step_id_normalized": pred_step_normalized,
+                "target_step_id_normalized": target_step_normalized,
+                "pred_parse_ok": pred_step_normalized is not None,
+                "candidate_correct": (
+                    pred_candidate is not None
+                    and bool(pred_candidate) == bool(row.get("target_candidate_matches"))
+                )
+                if row.get("target_candidate_matches") is not None
+                else None,
+                "observed_step_correct": pred_step_normalized is not None
+                and pred_step_normalized == target_step_normalized,
+            }
+        )
+        return row
+
+    def _summary(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        scored = [row for row in parsed if not row.get("error")]
+        step_rows = [row for row in scored if str(row.get("task_type") or "step_identification") == "step_identification"]
+        pairs = [
+            (normalize_step_id(row.get("target_step_id")), normalize_step_id(row.get("pred_observed_step_id")))
+            for row in step_rows
+            if normalize_step_id(row.get("target_step_id")) is not None
+        ]
+        labels = sorted({str(target) for target, _ in pairs})
+        scores = classification_scores(pairs, labels=labels)
+        candidate_rows = [row for row in scored if row.get("target_candidate_matches") is not None]
+        candidate_correct = sum(1 for row in candidate_rows if row.get("candidate_correct"))
+        parse_errors = sum(1 for row in scored if not row.get("pred_parse_ok"))
+        return {
+            "task": self.name,
+            "display_name": self.display_name,
+            "rows": len(rows),
+            "scored": len(scored),
+            "errors": sum(1 for row in rows if row.get("error")),
+            "parse_errors": parse_errors,
+            "parse_success_rate": (len(scored) - parse_errors) / len(scored) if scored else None,
+            "candidate_match_rows": len(candidate_rows),
+            "candidate_match_accuracy": candidate_correct / len(candidate_rows) if candidate_rows else None,
+            "step_identification_rows": len(step_rows),
+            "step_identification_accuracy": scores["accuracy"],
+            "observed_step_id_accuracy": scores["accuracy"],
+            "step_parse_success_rate": (len(step_rows) - parse_errors) / len(step_rows) if step_rows else None,
+            "step_balanced_accuracy": scores["balanced_accuracy"],
+            "step_macro_f1": scores["macro_f1"],
+            "step_macro_precision": scores["macro_precision"],
+            "step_macro_recall": scores["macro_recall"],
+            "step_precision_by_id": scores["precision"],
+            "step_recall_by_id": scores["recall"],
+            "step_f1_by_id": scores["f1"],
+            "step_confusion": scores["confusion"],
+            "task_counts": dict(Counter(str(row.get("task_type")) for row in scored)),
+            "target_counts": scores["target_counts"],
+            "pred_counts": scores["pred_counts"],
+        }
+
+    def score(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        summary = self._summary(parsed)
+        for metric in (
+            "step_identification_accuracy",
+            "step_balanced_accuracy",
+            "step_macro_f1",
+            "step_macro_precision",
+            "step_macro_recall",
+        ):
+            summary[f"{metric}_sem"] = bootstrap_sem(parsed, metric, self._summary, iterations=200)
+        return summary

lsvbench/tasks/pmd.py

@@ -0,0 +1,180 @@
+"""Pipette mistake / error detection task."""
+
+from __future__ import annotations
+
+from collections import Counter
+from pathlib import Path
+from typing import Any
+
+from ..io import BENCHMARK_ROOT, read_parquet, select_shard
+from ..metrics import bootstrap_sem, classification_scores
+from ..parsing import parse_choice_option
+from .base import BenchmarkTask, TaskSpec
+
+
+PMD_OPTIONS = {
+    "CORRECT",
+    "ERROR_REUSE",
+    "ERROR_SURFACE",
+    "ERROR_RELEASE",
+    "ERROR_INSTALL",
+    "ERROR_OTHER",
+}
+PMD_MISTAKE_TO_OPTION = {
+    "none": "CORRECT",
+    "reuse_tip": "ERROR_REUSE",
+    "reuse_same_media": "ERROR_REUSE",
+    "reuse_same_tip": "ERROR_REUSE",
+    "surface_contamination": "ERROR_SURFACE",
+    "early_release": "ERROR_RELEASE",
+    "wrong_tip_for_pipette": "ERROR_INSTALL",
+}
+PMD_NUMBER_TO_OPTION = {
+    "1": "CORRECT",
+    "2": "ERROR_REUSE",
+    "3": "ERROR_SURFACE",
+    "4": "ERROR_RELEASE",
+    "5": "ERROR_INSTALL",
+    "6": "ERROR_OTHER",
+}
+
+
+def pmd_target_option(label: str, mistake_type: str) -> str:
+    return "CORRECT" if label == "correct" else PMD_MISTAKE_TO_OPTION.get(mistake_type, "ERROR_OTHER")
+
+
+class PmdTask(BenchmarkTask):
+    spec = TaskSpec(
+        name="pmd",
+        display_name="Error Detection",
+        default_manifest=BENCHMARK_ROOT / "pmd" / "pmd.parquet",
+        sort_key="video_id",
+    )
+    primary_metric = "binary_balanced_accuracy"
+
+    def load_examples(
+        self,
+        *,
+        benchmark_root: Path = BENCHMARK_ROOT,
+        manifest_path: Path | None = None,
+        video_root: Path | None = None,
+        num_shards: int = 1,
+        shard_index: int = 0,
+        limit: int | None = None,
+    ) -> list[dict[str, Any]]:
+        rows = read_parquet(manifest_path or self.default_manifest)
+        selected: list[dict[str, Any]] = []
+        root = video_root or benchmark_root
+        for row in rows:
+            rel_video = str(row.get("video_path") or "")
+            if not rel_video:
+                continue
+            video_path = root / rel_video
+            target = pmd_target_option(str(row.get("label")), str(row.get("mistake_type")))
+            selected.append(
+                {
+                    **row,
+                    "task": self.name,
+                    "_video_abs": str(video_path),
+                    "target_option": target,
+                    "target_binary": "CORRECT" if target == "CORRECT" else "ERROR",
+                }
+            )
+        selected = sorted(selected, key=lambda row: str(row.get("video_id") or ""))
+        if limit is not None:
+            selected = selected[:limit]
+        return select_shard(selected, num_shards, shard_index)
+
+    def parse_record(self, row: dict[str, Any]) -> dict[str, Any]:
+        if row.get("error"):
+            return row
+        pred = parse_choice_option(str(row.get("raw_response") or ""), PMD_OPTIONS, number_map=PMD_NUMBER_TO_OPTION)
+        pred_binary = None if pred is None else ("CORRECT" if pred == "CORRECT" else "ERROR")
+        target = str(row.get("target_option") or pmd_target_option(str(row.get("label")), str(row.get("mistake_type"))))
+        target_binary = "CORRECT" if target == "CORRECT" else "ERROR"
+        row.update(
+            {
+                "target_option": target,
+                "target_binary": target_binary,
+                "pred_option": pred,
+                "pred_binary": pred_binary,
+                "pred_parse_ok": pred is not None,
+                "binary_correct": pred_binary == target_binary if pred_binary is not None else False,
+                "option_correct": pred == target if pred is not None else False,
+            }
+        )
+        return row
+
+    def _summary(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        scored = [row for row in parsed if not row.get("error")]
+        binary_pairs: list[tuple[str, str | None]] = []
+        option_pairs: list[tuple[str, str | None]] = []
+        error_type_pairs: list[tuple[str, str | None]] = []
+        for row in scored:
+            target = str(row.get("target_option"))
+            pred = row.get("pred_option")
+            target_binary = "CORRECT" if target == "CORRECT" else "ERROR"
+            pred_binary = None if pred is None else ("CORRECT" if pred == "CORRECT" else "ERROR")
+            binary_pairs.append((target_binary, pred_binary))
+            option_pairs.append((target, None if pred is None else str(pred)))
+            if target != "CORRECT":
+                error_type_pairs.append((target, None if pred in (None, "CORRECT") else str(pred)))
+        binary = classification_scores(binary_pairs, labels=["CORRECT", "ERROR"])
+        option = classification_scores(option_pairs, labels=sorted(PMD_OPTIONS))
+        error_type = classification_scores(
+            error_type_pairs,
+            labels=sorted(option for option in PMD_OPTIONS if option != "CORRECT"),
+        )
+        parse_errors = sum(1 for row in scored if row.get("pred_option") is None)
+        return {
+            "task": self.name,
+            "display_name": self.display_name,
+            "rows": len(rows),
+            "scored": len(scored),
+            "errors": sum(1 for row in rows if row.get("error")),
+            "parse_errors": parse_errors,
+            "parse_success_rate": (len(scored) - parse_errors) / len(scored) if scored else None,
+            "binary_accuracy": binary["accuracy"],
+            "binary_balanced_accuracy": binary["balanced_accuracy"],
+            "binary_macro_f1": binary["macro_f1"],
+            "binary_macro_precision": binary["macro_precision"],
+            "binary_macro_recall": binary["macro_recall"],
+            "binary_precision": binary["precision"],
+            "binary_recall": binary["recall"],
+            "binary_f1": binary["f1"],
+            "binary_confusion": binary["confusion"],
+            "option_accuracy": option["accuracy"],
+            "option_balanced_accuracy": option["balanced_accuracy"],
+            "option_macro_f1": option["macro_f1"],
+            "option_confusion": option["confusion"],
+            "error_type_accuracy": error_type["accuracy"],
+            "error_type_balanced_accuracy": error_type["balanced_accuracy"],
+            "error_type_macro_f1": error_type["macro_f1"],
+            "error_type_macro_precision": error_type["macro_precision"],
+            "error_type_macro_recall": error_type["macro_recall"],
+            "error_type_precision": error_type["precision"],
+            "error_type_recall": error_type["recall"],
+            "error_type_f1": error_type["f1"],
+            "error_type_confusion": error_type["confusion"],
+            "target_counts": dict(Counter(str(row.get("target_option")) for row in scored)),
+            "pred_counts": dict(Counter(str(row.get("pred_option")) for row in scored)),
+        }
+
+    def score(self, rows: list[dict[str, Any]]) -> dict[str, Any]:
+        parsed = self.parse_rows(rows)
+        summary = self._summary(parsed)
+        for metric in (
+            "binary_accuracy",
+            "binary_balanced_accuracy",
+            "binary_macro_f1",
+            "binary_macro_precision",
+            "binary_macro_recall",
+            "error_type_accuracy",
+            "error_type_balanced_accuracy",
+            "error_type_macro_f1",
+            "error_type_macro_precision",
+            "error_type_macro_recall",
+        ):
+            summary[f"{metric}_sem"] = bootstrap_sem(parsed, metric, self._summary, iterations=200)
+        return summary

lsvbench/tasks/prompts/pmd.md

@@ -0,0 +1,14 @@
+You are monitoring a scientist learning how to utilize tools in the wet-lab. You are in simple detection mode and are observing for common technique issues or misuse of tools. In the snippet of user practicing their pipette usage please select the closest option below that describes what happened in the video.
+
+
+## Options
+1. CORRECT: correct usage of pipette tip no mistakes
+2. ERROR_REUSE: reused tip on different media causing contamination
+3. ERROR_SURFACE: tip was contaminated by touching surface
+4. ERROR_RELEASE: tip was dropped or released unexpectedly
+5. ERROR_INSTALL: pipette tip installed (or attempted) was of wrong size/incorrectly fitted
+6. ERROR_OTHER: when you are sure its wrong but it does not fit above cateogory label as other
+
+
+## Output format
+Strict SINGLE_WORD all cap option response no other symbols or description from the options above.

pmd/README.md

@@ -0,0 +1,27 @@
+# LSV PMD Split Benchmark Dataset
+
+PMD split clips provide short pipetting examples for correct-vs-mistake and mistake-type evaluation.
+
+## Layout
+
+- `correct/`: split correct demonstration clips
+- `incorrect/`: split mistake demonstration clips
+- `pmd.parquet`: split-clip benchmark manifest
+
+## Counts
+
+- split clips: `246`
+- by label: `{'correct': 15, 'incorrect': 231}`
+- by mistake_type: `{'early_release': 45, 'none': 15, 'reuse_same_media': 27, 'reuse_same_tip': 4, 'reuse_tip': 53, 'surface_contamination': 44, 'wrong_tip_for_pipette': 58}`
+
+## Review Flags
+
+- needs_review clips: `6`
+
+The `needs_review` and `notes` columns preserve human review notes for a small number of clips whose source labels required normalization.
+
+## Evaluation
+
+Use `pmd/pmd.parquet` with `lsvbench/tasks/prompts/pmd.md` or the `pmd` task in `lsvbench`.
+
+The prompt preserves detailed answer options (`ERROR_REUSE`, `ERROR_SURFACE`, `ERROR_RELEASE`, `ERROR_INSTALL`, `ERROR_OTHER`) for compatibility with existing model outputs. The public benchmark report collapses all non-`CORRECT` options into binary `ERROR` and reports only **Error Detection** metrics.

pmd/correct/pmd_correct_01.mp4

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

pmd/correct/pmd_correct_02.mp4

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

pmd/correct/pmd_correct_03.mp4

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

pmd/correct/pmd_correct_04.mp4

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

pmd/correct/pmd_correct_05.mp4

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

pmd/correct/pmd_correct_06.mp4

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

pmd/correct/pmd_correct_07.mp4

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

pmd/correct/pmd_correct_08.mp4

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

pmd/correct/pmd_correct_09.mp4

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

pmd/correct/pmd_correct_10.mp4

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

pmd/correct/pmd_correct_11.mp4

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

pmd/correct/pmd_correct_12.mp4

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

pmd/correct/pmd_correct_13.mp4

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

pmd/correct/pmd_correct_14.mp4

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