playground/inference/eval.py

"""
Evaluate a Qwen3-VL checkpoint on the full training dataset.

Design:
- One process per GPU; each GPU handles a shard of parquet files
- Supports resume: skips already-completed samples on restart
- Saves per-shard JSON incrementally every SAVE_INTERVAL samples

Usage (single GPU, full data):
  CUDA_VISIBLE_DEVICES=0 python -u eval.py --shard-id 0 --num-shards 1

Usage (8-GPU parallel via launcher):
  bash run_parallel.sh
"""

import argparse
import base64
import glob
import io
import json
import os
import time
from concurrent.futures import ThreadPoolExecutor
from pathlib import Path
from queue import Queue
from threading import Thread

import pyarrow.parquet as pq
from PIL import Image


# ── defaults ──────────────────────────────────────────────────────────────────

DEFAULT_MODEL    = "/mnt/bn/bohanzhainas1/jiashuo/exp/new_policy7w_v2_reformat/checkpoint-1700/hf_model"
DEFAULT_DATA_DIR = "/mnt/hdfs/byte_tt_data_cu_vagcp/haogeng.liu/new_policy7w_v2_reformat"
DEFAULT_OUTPUT   = "/mnt/bn/bohanzhainas1/jiashuo/exp/eval_ckpt1700_full"

FRAMES_PER_VIDEO = 4          # 4 frames/video × 2 videos = 8 images total
MAX_PIXELS       = 336 * 336  # 336×336 → ~144 visual tokens/img vs 256 at 448×448 (44% less)
MAX_NEW_TOKENS   = 96         # label JSON ~50 tokens; 96 gives comfortable margin
SAVE_INTERVAL    = 50         # flush to disk every N samples


# ── data loading ──────────────────────────────────────────────────────────────

def get_shard_files(data_dir: str, shard_id: int, num_shards: int) -> list[str]:
    """Assign parquet files to this shard (round-robin by file index)."""
    all_files = sorted(glob.glob(f"{data_dir}/*.parquet"))
    if not all_files:
        raise FileNotFoundError(f"No parquet files in {data_dir}")
    return all_files[shard_id::num_shards]


def iter_file(parquet_path: str):
    """Yield (file_idx, row_idx, messages, extra_info) for each row in a parquet file."""
    table = pq.read_table(parquet_path, columns=["messages", "extra_info"])
    for i in range(len(table)):
        row = table.slice(i, 1).to_pydict()
        yield json.loads(row["messages"][0]), json.loads(row["extra_info"][0])


# ── sample parsing ────────────────────────────────────────────────────────────

def b64_to_pil(b64_str: str) -> Image.Image:
    img = Image.open(io.BytesIO(base64.b64decode(b64_str))).convert("RGB")
    # Downscale if needed to respect MAX_PIXELS
    w, h = img.size
    if w * h > MAX_PIXELS:
        scale = (MAX_PIXELS / (w * h)) ** 0.5
        img = img.resize((int(w * scale), int(h * scale)), Image.BILINEAR)
    return img


def parse_sample(msgs: list) -> tuple[list, str]:
    """Returns (content_items for model input, ground_truth_text)."""
    user_content = msgs[0]["content"]
    ground_truth = msgs[1]["content"][0]["text"]

    content_items = []
    for item in user_content:
        if item["type"] == "video":
            frames = item["video"]
            step = max(1, len(frames) // FRAMES_PER_VIDEO)
            for b64 in frames[::step][:FRAMES_PER_VIDEO]:
                content_items.append({"type": "image", "image": b64_to_pil(b64)})
        elif item["type"] == "text":
            content_items.append({"type": "text", "text": item["text"]})
        elif item["type"] == "image":
            content_items.append({"type": "image", "image": b64_to_pil(item["image"])})

    return content_items, ground_truth


def extract_label(text: str) -> int | None:
    import re
    try:
        stripped = text.strip()
        if "```" in stripped:
            m = re.search(r"```(?:json)?\s*([\s\S]+?)```", stripped)
            if m:
                stripped = m.group(1).strip()
        return int(json.loads(stripped)["label"])
    except Exception:
        m = re.search(r'"label"\s*:\s*([01])', text)
        return int(m.group(1)) if m else None


# ── model ─────────────────────────────────────────────────────────────────────

def load_model(model_path: str):
    import torch
    from transformers import Qwen3VLForConditionalGeneration, AutoProcessor

    print(f"Loading model → cuda:0  ({model_path})", flush=True)
    model = Qwen3VLForConditionalGeneration.from_pretrained(
        model_path,
        dtype=torch.bfloat16,
        attn_implementation="flash_attention_2",
        device_map="cuda:0",
        trust_remote_code=True,
    )
    model.eval()
    processor = AutoProcessor.from_pretrained(model_path, trust_remote_code=True)
    print("Model loaded.", flush=True)
    return model, processor


def run_inference(model, processor, content_items: list) -> str:
    import torch
    from qwen_vl_utils import process_vision_info

    messages = [{"role": "user", "content": content_items}]
    text = processor.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
    image_inputs, _ = process_vision_info(messages)

    inputs = processor(
        text=[text],
        images=image_inputs,
        return_tensors="pt",
    ).to("cuda:0")

    with torch.no_grad():
        output_ids = model.generate(
            **inputs,
            max_new_tokens=MAX_NEW_TOKENS,
            do_sample=False,
            pad_token_id=processor.tokenizer.eos_token_id,
        )

    prompt_len = inputs["input_ids"].shape[1]
    return processor.decode(output_ids[0, prompt_len:], skip_special_tokens=True)


# ── stats helpers ─────────────────────────────────────────────────────────────

def compute_stats(results: list[dict]) -> dict:
    from collections import defaultdict
    label_stats = defaultdict(lambda: {"tp": 0, "fp": 0, "fn": 0, "tn": 0})
    correct = 0
    evaluated = 0
    parse_fail = 0

    for r in results:
        if "error" in r:
            continue
        if r["pred_label"] is None:
            parse_fail += 1
            continue
        gt, pred = r["gt_label"], r["pred_label"]
        if gt is None:
            continue
        evaluated += 1
        if gt == pred:
            correct += 1
        for label in [0, 1]:
            if gt == label and pred == label:
                label_stats[label]["tp"] += 1
            elif gt != label and pred == label:
                label_stats[label]["fp"] += 1
            elif gt == label and pred != label:
                label_stats[label]["fn"] += 1
            else:
                label_stats[label]["tn"] += 1

    per_class = {}
    for label, s in label_stats.items():
        tp, fp, fn = s["tp"], s["fp"], s["fn"]
        prec = tp / (tp + fp) if (tp + fp) > 0 else 0.0
        rec  = tp / (tp + fn) if (tp + fn) > 0 else 0.0
        f1   = 2 * prec * rec / (prec + rec) if (prec + rec) > 0 else 0.0
        per_class[str(label)] = {"precision": prec, "recall": rec, "f1": f1,
                                  "support": tp + fn}

    return {
        "accuracy":      correct / evaluated if evaluated else 0.0,
        "correct":       correct,
        "evaluated":     evaluated,
        "parse_failures": parse_fail,
        "per_class":     per_class,
    }


# ── main ──────────────────────────────────────────────────────────────────────

def main():
    parser = argparse.ArgumentParser()
    parser.add_argument("--model-path", default=DEFAULT_MODEL)
    parser.add_argument("--data-dir",   default=DEFAULT_DATA_DIR)
    parser.add_argument("--gpu-id",     type=int, default=0)
    parser.add_argument("--shard-id",   type=int, default=0)
    parser.add_argument("--num-shards", type=int, default=8)
    parser.add_argument("--output",     default=DEFAULT_OUTPUT)
    args = parser.parse_args()

    os.environ["CUDA_VISIBLE_DEVICES"] = str(args.gpu_id)
    gpu_tag = f"GPU{args.gpu_id}"

    # Output file for this shard
    out_path = Path(f"{args.output}_shard{args.shard_id:02d}.json")
    out_path.parent.mkdir(parents=True, exist_ok=True)

    # Resume: load already-completed results
    done_keys: set[str] = set()
    results: list[dict] = []
    if out_path.exists():
        try:
            saved = json.loads(out_path.read_text())
            results = saved.get("results", [])
            done_keys = {r["key"] for r in results if "key" in r}
            print(f"[{gpu_tag}] Resuming: {len(done_keys)} already done", flush=True)
        except Exception:
            pass

    # Assign parquet files to this shard
    shard_files = get_shard_files(args.data_dir, args.shard_id, args.num_shards)
    total_rows = len(shard_files) * 128  # each file has 128 rows
    print(f"[{gpu_tag}] Shard {args.shard_id}/{args.num_shards}: "
          f"{len(shard_files)} files, ~{total_rows} samples", flush=True)

    # Load model
    model, processor = load_model(args.model_path)

    # Build iterator of all (key, msgs, extra) for this shard, skipping done
    def sample_iter():
        for pf in shard_files:
            fname = Path(pf).stem
            for row_idx, (msgs, extra) in enumerate(iter_file(pf)):
                key = f"{fname}:{row_idx}"
                if key not in done_keys:
                    yield key, fname, row_idx, msgs

    # Async prefetch: parse_sample (CPU: base64 decode + image resize) runs in a
    # background thread so CPU work overlaps with GPU inference.
    PREFETCH = 2
    prefetch_q: Queue = Queue(maxsize=PREFETCH)
    _SENTINEL = object()

    def prefetch_worker():
        for key, fname, row_idx, msgs in sample_iter():
            try:
                content_items, ground_truth = parse_sample(msgs)
                prefetch_q.put((key, fname, row_idx, content_items, ground_truth, None))
            except Exception as e:
                prefetch_q.put((key, fname, row_idx, None, None, str(e)))
        prefetch_q.put(_SENTINEL)

    prefetch_thread = Thread(target=prefetch_worker, daemon=True)
    prefetch_thread.start()

    # Inference loop
    t0 = time.time()
    processed = 0
    last_save = time.time()

    while True:
        item = prefetch_q.get()
        if item is _SENTINEL:
            break

        key, fname, row_idx, content_items, ground_truth, parse_err = item
        result = {"key": key, "file": fname, "row": row_idx}

        try:
            if parse_err:
                raise RuntimeError(parse_err)

            gt_label  = extract_label(ground_truth)
            pred_text = run_inference(model, processor, content_items)
            pred_label = extract_label(pred_text)

            result.update({
                "gt_label":     gt_label,
                "pred_label":   pred_label,
                "match":        (pred_label == gt_label) if (pred_label is not None and gt_label is not None) else None,
                "prediction":   pred_text,
                "ground_truth": ground_truth,
            })
        except Exception as e:
            result["error"] = str(e)

        results.append(result)
        done_keys.add(key)
        processed += 1

        # Progress log
        elapsed = time.time() - t0
        speed = processed / elapsed
        stats = compute_stats(results)
        eta_s = (total_rows - len(done_keys)) / speed if speed > 0 else 0
        eta_h = eta_s / 3600
        print(
            f"[{gpu_tag}] [{len(done_keys)}/{total_rows}] "
            f"acc={stats['accuracy']:.3f} "
            f"p0={stats['per_class'].get('0',{}).get('precision',0):.2f}/"
            f"r0={stats['per_class'].get('0',{}).get('recall',0):.2f} "
            f"p1={stats['per_class'].get('1',{}).get('precision',0):.2f}/"
            f"r1={stats['per_class'].get('1',{}).get('recall',0):.2f} "
            f"| {speed:.3f} samp/s  ETA {eta_h:.1f}h",
            flush=True,
        )

        # Periodic save
        if time.time() - last_save > 60 or processed % SAVE_INTERVAL == 0:
            _save(out_path, args, results, stats)
            last_save = time.time()

    prefetch_thread.join()

    # Final save
    stats = compute_stats(results)
    _save(out_path, args, results, stats)

    elapsed = time.time() - t0
    print(f"\n{'='*60}", flush=True)
    print(f"[{gpu_tag}] DONE  acc={stats['accuracy']:.4f} "
          f"({stats['correct']}/{stats['evaluated']})", flush=True)
    print(f"[{gpu_tag}] Per-class: {json.dumps(stats['per_class'], indent=2)}", flush=True)
    print(f"[{gpu_tag}] Parse failures: {stats['parse_failures']}/{len(results)}", flush=True)
    print(f"[{gpu_tag}] Time: {elapsed/3600:.2f}h  ({len(results)/elapsed:.3f} samp/s)", flush=True)
    print(f"[{gpu_tag}] Saved → {out_path}", flush=True)


def _save(path: Path, args, results: list, stats: dict):
    path.write_text(json.dumps({
        "model_path":  args.model_path,
        "shard_id":    args.shard_id,
        "num_shards":  args.num_shards,
        "frames_per_video": FRAMES_PER_VIDEO,
        "max_pixels":  MAX_PIXELS,
        "max_new_tokens": MAX_NEW_TOKENS,
        **stats,
        "results": results,
    }, ensure_ascii=False, indent=2))


if __name__ == "__main__":
    main()