code/scripts/score_sft_split.py

from __future__ import annotations

import argparse
import json
import statistics
from collections import Counter
from pathlib import Path
from typing import Any

import torch
from datasets import load_dataset
from transformers import AutoModelForCausalLM, AutoTokenizer

from swarm_ctf_eval.sft_metrics import validate_dataset_response


def render_prompt(tokenizer: Any, messages: list[dict[str, str]]) -> str:
    kwargs = {"tokenize": False, "add_generation_prompt": True}
    try:
        return tokenizer.apply_chat_template(messages, enable_thinking=False, **kwargs)
    except TypeError:
        return tokenizer.apply_chat_template(messages, **kwargs)


@torch.inference_mode()
def score(
    model_path: str,
    dataset_id: str,
    split: str,
    batch_size: int,
) -> tuple[list[dict[str, Any]], dict[str, Any]]:
    tokenizer = AutoTokenizer.from_pretrained(model_path)
    tokenizer.padding_side = "left"
    if tokenizer.pad_token_id is None:
        tokenizer.pad_token = tokenizer.eos_token
    model = AutoModelForCausalLM.from_pretrained(
        model_path,
        dtype=torch.bfloat16,
        attn_implementation="flash_attention_2",
    ).to("cuda")
    model.eval()
    dataset = load_dataset(dataset_id, split=split)
    rows: list[dict[str, Any]] = []
    counts: Counter[str] = Counter()
    phase_counts: Counter[str] = Counter()
    phase_metrics: dict[str, Counter[str]] = {
        "BROADCAST": Counter(),
        "ACT": Counter(),
    }
    for start in range(0, len(dataset), batch_size):
        batch = [dict(dataset[index]) for index in range(start, min(start + batch_size, len(dataset)))]
        prompts = [render_prompt(tokenizer, row["messages"][:-1]) for row in batch]
        encoded = tokenizer(prompts, return_tensors="pt", padding=True).to("cuda")
        generated = model.generate(
            **encoded,
            max_new_tokens=224,
            do_sample=False,
            pad_token_id=tokenizer.pad_token_id,
        )
        for index, row in enumerate(batch):
            raw = tokenizer.decode(
                generated[index, encoded["input_ids"].shape[1] :],
                skip_special_tokens=True,
            ).strip()
            result = validate_dataset_response(row, raw)
            phase = row["metadata"]["phase"]
            phase_counts[phase] += 1
            for key, value in result.items():
                counts[key] += int(value)
                phase_metrics[phase][key] += int(value)
            rows.append(
                {
                    "id": row["id"],
                    "phase": phase,
                    "response": raw,
                    "target": row["messages"][-1]["content"],
                    **result,
                }
            )
    total = len(rows)
    summary: dict[str, Any] = {
        "model": model_path,
        "dataset": dataset_id,
        "split": split,
        "examples": total,
        **{key: counts[key] / total for key in ("schema_valid", "supported", "legal", "exact")},
    }
    for phase in ("BROADCAST", "ACT"):
        summary[phase.lower()] = {
            "examples": phase_counts[phase],
            **{
                key: phase_metrics[phase][key] / max(1, phase_counts[phase])
                for key in ("schema_valid", "supported", "legal", "exact")
            },
        }
    summary["selection_score"] = statistics.mean(
        [summary["broadcast"]["exact"], summary["act"]["exact"]]
    )
    return rows, summary


def main() -> None:
    parser = argparse.ArgumentParser()
    parser.add_argument("--model", required=True)
    parser.add_argument("--dataset", default="CK0607/swarm-arena-sft-v2")
    parser.add_argument("--split", default="validation")
    parser.add_argument("--batch-size", type=int, default=8)
    parser.add_argument("--output-dir", type=Path, required=True)
    args = parser.parse_args()
    rows, summary = score(args.model, args.dataset, args.split, args.batch_size)
    args.output_dir.mkdir(parents=True, exist_ok=True)
    (args.output_dir / "rows.jsonl").write_text(
        "".join(json.dumps(row, sort_keys=True) + "\n" for row in rows), encoding="utf-8"
    )
    (args.output_dir / "summary.json").write_text(
        json.dumps(summary, indent=2, sort_keys=True) + "\n", encoding="utf-8"
    )
    print(json.dumps(summary, indent=2, sort_keys=True))


if __name__ == "__main__":
    main()