other_transfer/src/physics_model/eval.py

"""Greedy generation + answer/unit/axiom metrics for base or LoRA checkpoints."""

from __future__ import annotations

import argparse
import json
import logging
import math
import os
import sys
from collections import defaultdict
from pathlib import Path

_SRC = Path(__file__).resolve().parents[1]
if str(_SRC) not in sys.path:
    sys.path.insert(0, str(_SRC))

import torch
from tqdm import tqdm

from physics_sft.metrics import format_eval_table, score_prediction
from physics_model.collator import PhysicsVLCollator, tensors_for_generate
from physics_model.load import load_model, load_processor
from physics_sft.io import JsonlDataset
from physics_sft.prepare_data import repo_root_from_here

logger = logging.getLogger(__name__)


def _setup_logging() -> None:
    logging.basicConfig(
        format="%(asctime)s - %(levelname)s - %(name)s - %(message)s",
        datefmt="%Y-%m-%d %H:%M:%S",
        handlers=[logging.StreamHandler(sys.stdout)],
        level=logging.INFO,
    )


def _maybe_load_adapter(model, adapter_dir: Path | None):
    if adapter_dir is None:
        return model
    from peft import PeftModel

    logger.info("loading adapter from %s", adapter_dir)
    return PeftModel.from_pretrained(model, str(adapter_dir))


def _slice_name(row: dict) -> str:
    kind = "image" if row.get("has_image") else "text"
    has_ax = "axiom" if row.get("axiom_ids") else "free"
    return f"{kind}/{has_ax}"


def _mean(values: list[float]) -> float:
    finite = [v for v in values if not math.isnan(v)]
    if not finite:
        return float("nan")
    return sum(finite) / len(finite)


def summarize(rows: list[dict]) -> dict:
    groups: dict[str, list[dict]] = defaultdict(list)
    groups["all"] = rows
    for row in rows:
        groups["text" if not row["has_image"] else "image"].append(row)
        groups["axiom" if row["gold_axiom_ids"] else "free"].append(row)
        groups[_slice_name({"has_image": row["has_image"], "axiom_ids": row["gold_axiom_ids"]})].append(row)

    out = {}
    for name, items in groups.items():
        if not items:
            continue
        axiom_items = [r for r in items if r["gold_axiom_ids"]]
        out[name] = {
            "n": len(items),
            "answer_em": _mean([float(r["answer_em"]) for r in items]),
            "numeric_match": _mean([float(r["numeric_match"]) for r in items]),
            "unit_match": _mean([float(r["unit_match"]) for r in items]),
            "axiom_precision": _mean([r["axiom_precision"] for r in axiom_items]) if axiom_items else float("nan"),
            "axiom_recall": _mean([r["axiom_recall"] for r in axiom_items]) if axiom_items else float("nan"),
            "n_axiom": len(axiom_items),
        }
    return out


def _generate_kwargs(processor, max_new_tokens: int, *, synced_gpus: bool = False) -> dict:
    pad_id = processor.tokenizer.pad_token_id
    kwargs = dict(
        max_new_tokens=max_new_tokens,
        do_sample=False,
        pad_token_id=pad_id,
        synced_gpus=bool(synced_gpus),
        use_cache=True,
    )
    try:
        from transformers import StoppingCriteria, StoppingCriteriaList

        class _StopAfterUnit(StoppingCriteria):
            def __call__(self, input_ids, scores, **unused):
                texts = processor.tokenizer.batch_decode(input_ids[:, -24:], skip_special_tokens=True)
                return all("</unit>" in text for text in texts)

        kwargs["stopping_criteria"] = StoppingCriteriaList([_StopAfterUnit()])
    except Exception:
        pass
    return kwargs


def _run_generate(model, batch: dict, gen_kwargs: dict):
    try:
        return model.generate(**batch, **gen_kwargs)
    except TypeError:
        fallback = {k: v for k, v in gen_kwargs.items() if k not in {"synced_gpus", "stopping_criteria", "use_cache"}}
        return model.generate(**batch, **fallback)


@torch.no_grad()
def generate_one(
    model,
    processor,
    collator: PhysicsVLCollator,
    row: dict,
    max_new_tokens: int,
    *,
    device=None,
    synced_gpus: bool = False,
) -> str:
    encoded = collator.encode_example({**row, "assistant": None}, include_assistant=False)
    target = device if device is not None else getattr(model, "device", "cpu")
    batch = tensors_for_generate(encoded, target)
    generated = _run_generate(model, batch, _generate_kwargs(processor, max_new_tokens, synced_gpus=synced_gpus))
    new_tokens = generated[0, batch["input_ids"].shape[-1] :]
    return processor.tokenizer.decode(new_tokens, skip_special_tokens=True)


@torch.no_grad()
def generate_many(
    model,
    processor,
    collator: PhysicsVLCollator,
    rows: list[dict],
    max_new_tokens: int,
    *,
    device=None,
    batch_size: int = 4,
    synced_gpus: bool = False,
) -> list[str]:
    """Greedy-decode a list of rows, batching same has_image type with left padding."""
    if not rows:
        return []
    if batch_size <= 1:
        return [
            generate_one(model, processor, collator, row, max_new_tokens, device=device, synced_gpus=synced_gpus)
            for row in rows
        ]

    target = device if device is not None else getattr(model, "device", "cpu")
    gen_kwargs = _generate_kwargs(processor, max_new_tokens, synced_gpus=synced_gpus)
    preds = [""] * len(rows)
    groups: dict[bool, list[int]] = {False: [], True: []}
    for i, row in enumerate(rows):
        groups[bool(row.get("has_image"))].append(i)

    for idxs in groups.values():
        for start in range(0, len(idxs), batch_size):
            chunk = idxs[start : start + batch_size]
            encoded = [
                collator.encode_example({**rows[i], "assistant": None}, include_assistant=False) for i in chunk
            ]
            batch = _left_pad_for_generate(encoded, processor.tokenizer.pad_token_id, target)
            prompt_len = int(batch["input_ids"].shape[-1])
            generated = _run_generate(model, batch, gen_kwargs)
            for local, row_i in enumerate(chunk):
                new_tokens = generated[local, prompt_len:]
                preds[row_i] = processor.tokenizer.decode(new_tokens, skip_special_tokens=True)
    return preds


def _left_pad_for_generate(encoded: list[dict], pad_id: int | None, device) -> dict:
    pad_id = 0 if pad_id is None else pad_id
    ids = []
    masks = []
    for item in encoded:
        tok = item["input_ids"]
        mask = item["attention_mask"]
        if tok.dim() == 2:
            tok = tok[0]
            mask = mask[0]
        ids.append(tok)
        masks.append(mask)
    max_len = max(int(t.shape[-1]) for t in ids)
    padded_ids = []
    padded_mask = []
    for tok, mask in zip(ids, masks):
        pad = max_len - int(tok.shape[-1])
        if pad:
            padded_ids.append(torch.nn.functional.pad(tok, (pad, 0), value=pad_id))
            padded_mask.append(torch.nn.functional.pad(mask, (pad, 0), value=0))
        else:
            padded_ids.append(tok)
            padded_mask.append(mask)
    batch = {
        "input_ids": torch.stack(padded_ids, dim=0).to(device),
        "attention_mask": torch.stack(padded_mask, dim=0).to(device),
    }
    if "pixel_values" in encoded[0]:
        batch["pixel_values"] = torch.cat([item["pixel_values"] for item in encoded], dim=0).to(device)
    if "image_grid_thw" in encoded[0]:
        batch["image_grid_thw"] = torch.cat([item["image_grid_thw"] for item in encoded], dim=0).to(device)
    return batch


def _select_rows(rows: list[dict], *, limit: int | None, images_only: bool) -> list[dict]:
    if images_only:
        rows = [row for row in rows if row.get("has_image")]
    if limit is None:
        return rows
    n = max(0, int(limit))
    if images_only or len(rows) <= n:
        return rows[:n]
    images = [row for row in rows if row.get("has_image")]
    texts = [row for row in rows if not row.get("has_image")]
    n_img = min(len(images), n // 2)
    n_txt = min(len(texts), n - n_img)
    picked = images[:n_img] + texts[:n_txt]
    if len(picked) < n:
        leftover = [row for row in rows if row not in picked]
        picked.extend(leftover[: n - len(picked)])
    return picked


def _dist_info() -> tuple[int, int]:
    rank = int(os.environ.get("RANK", os.environ.get("LOCAL_RANK", "0")) or 0)
    world = int(os.environ.get("WORLD_SIZE", "1") or 1)
    return rank, max(world, 1)


def evaluate_split(
    model,
    processor,
    collator: PhysicsVLCollator,
    rows: list[dict],
    *,
    max_new_tokens: int,
) -> tuple[list[dict], dict]:
    rank, world = _dist_info()
    mine = rows[rank::world] if world > 1 else rows
    detailed = []
    for row in tqdm(mine, desc=f"eval r{rank}", disable=rank != 0):
        pred = generate_one(model, processor, collator, row, max_new_tokens)
        detailed.append(score_prediction(row, pred))
    if world > 1:
        from physics_model.val_callback import _all_gather_object, _merge_sharded_rows

        gathered = _all_gather_object({"rows": detailed})
        if rank == 0:
            detailed = _merge_sharded_rows(rows, gathered, world)
        else:
            return [], {}
    return detailed, summarize(detailed)


def main(argv: list[str] | None = None) -> int:
    parser = argparse.ArgumentParser(description="Evaluate base or LoRA physics VLM")
    parser.add_argument("--root", type=Path, default=None)
    parser.add_argument("--data-dir", type=Path, default=Path("data/physics_sft"))
    parser.add_argument("--split", choices=("val", "test", "train"), default="val")
    parser.add_argument("--model-dir", type=Path, default=Path("third-party/qwen"))
    parser.add_argument("--adapter-dir", type=Path, default=None)
    parser.add_argument("--output", type=Path, default=None)
    parser.add_argument("--max-new-tokens", type=int, default=1024)
    parser.add_argument("--max-length", type=int, default=4096)
    parser.add_argument("--min-pixels", type=int, default=65536)
    parser.add_argument("--max-pixels", type=int, default=602112)
    parser.add_argument("-n", "--limit", type=int, default=None, help="evaluate only N rows (mixed image/text)")
    parser.add_argument("--images-only", action="store_true", help="keep image rows only before applying -n")
    parser.add_argument("--attn-implementation", default="sdpa")
    args = parser.parse_args(argv)

    _setup_logging()
    root = (args.root or repo_root_from_here()).resolve()
    data_dir = args.data_dir if args.data_dir.is_absolute() else root / args.data_dir
    model_dir = args.model_dir if args.model_dir.is_absolute() else root / args.model_dir
    adapter_dir = None
    if args.adapter_dir is not None:
        adapter_dir = args.adapter_dir if args.adapter_dir.is_absolute() else root / args.adapter_dir

    jsonl = data_dir / f"{args.split}.jsonl"
    if not jsonl.is_file():
        raise FileNotFoundError(jsonl)
    dataset = JsonlDataset.from_path(jsonl)
    rows = _select_rows(list(dataset), limit=args.limit, images_only=args.images_only)
    logger.info("eval %s rows (limit=%s images_only=%s)", len(rows), args.limit, args.images_only)

    processor = load_processor(model_dir, min_pixels=args.min_pixels, max_pixels=args.max_pixels)
    processor.tokenizer.padding_side = "left"
    collator = PhysicsVLCollator(processor, repo_root=root, max_length=args.max_length)
    model = load_model(
        model_dir,
        torch_dtype="bfloat16",
        attn_implementation=args.attn_implementation,
        gradient_checkpointing=False,
        use_cache=True,
    )
    model = _maybe_load_adapter(model, adapter_dir)
    model.eval()
    if torch.cuda.is_available():
        model.to("cuda")

    rank, world = _dist_info()
    logger.info("eval device=cuda world=%s rank=%s", world, rank)
    detailed, summary = evaluate_split(model, processor, collator, rows, max_new_tokens=args.max_new_tokens)
    if world > 1 and rank != 0:
        return 0
    payload = {"split": args.split, "n": len(detailed), "summary": summary, "rows": detailed}
    default_name = f"eval_{args.split}.json"
    output = args.output or (adapter_dir or Path("checkpoints")) / default_name
    output = output if output.is_absolute() else root / output
    output.parent.mkdir(parents=True, exist_ok=True)
    output.write_text(json.dumps(payload, ensure_ascii=False, indent=2) + "\n", encoding="utf-8")
    print(format_eval_table(summary))
    print(json.dumps(summary, ensure_ascii=False, indent=2))
    print(f"wrote {output}")
    return 0


if __name__ == "__main__":
    raise SystemExit(main())