"""Score one or more ftan moderation models on a benchmark parquet. The benchmark parquet (see make_benchmark.py) holds held-out test rows tagged with a `benchmark_split` column (`test` / `test_obfuscated`) plus the full schema, so scoring is reported overall and sliced by benchmark_split, by `mutated` (plain vs obfuscated), and by `source`. Models can be local directories or Hugging Face Hub ids (any id accepted by `AutoModelForSequenceClassification.from_pretrained`). Usage: .venv/bin/python scripts/benchmark.py \ --model data/final/model/model \ --model data/final/model/checkpoints/checkpoint-300000 \ --model user/moderation-model Outputs: data/final/benchmark/results.json metrics per model (all slices) a printed comparison table """ from __future__ import annotations import argparse import json import os import numpy as np import pandas as pd import torch from sklearn.metrics import accuracy_score, f1_score, precision_score, recall_score from transformers import AutoModelForSequenceClassification, AutoTokenizer from common import FINAL_DIR POS_LABEL = 1 METRICS = ["accuracy", "precision", "recall", "f1"] def _metrics(y_true, y_pred) -> dict: return { "rows": int(len(y_true)), "accuracy": float(accuracy_score(y_true, y_pred)), "precision": float(precision_score(y_true, y_pred, zero_division=0)), "recall": float(recall_score(y_true, y_pred, zero_division=0)), "f1": float(f1_score(y_true, y_pred, zero_division=0)), } def _predict(model, tokenizer, texts, batch_size, max_length, device): model.eval() preds = [] with torch.no_grad(): for i in range(0, len(texts), batch_size): enc = tokenizer( texts[i:i + batch_size], truncation=True, max_length=max_length, padding=True, return_tensors="pt", ) enc = {k: v.to(device) for k, v in enc.items()} logits = model(**enc).logits preds.extend(torch.argmax(logits, dim=-1).cpu().tolist()) return np.asarray(preds) def _label_map(model): """Map argmax indices to 0/1 labels from config.id2label, if possible. Trained ftan models use {0: clean, 1: offensive}, so the argmax index already is the label. Hub models may use a different id2label naming, so translate known names ("clean"/"offensive", etc.) when present. Returns None when no reliable mapping exists (then the argmax index is used). """ cfg = getattr(model, "config", None) id2label = getattr(cfg, "id2label", None) if cfg is not None else None if not id2label: return None mapping = {} for idx, name in id2label.items(): try: mapping[int(idx)] = int(name) except (ValueError, TypeError): low = str(name).lower() if low in ("clean", "normal", "benign", "non-offensive", "neutral"): mapping[int(idx)] = 0 elif low in ("offensive", "toxic", "hate", "hateful", "abusive", "explicit"): mapping[int(idx)] = 1 return mapping or None def _apply_label_map(preds, label_map): if not label_map: return preds return np.asarray([label_map.get(int(p), p) for p in preds]) def _fmt(m) -> str: return f"acc={m['accuracy']:.4f} p={m['precision']:.4f} r={m['recall']:.4f} f1={m['f1']:.4f}" def _fmt_or(groups, key) -> str: m = groups.get(key) return _fmt(m) if m else "-" def main(): ap = argparse.ArgumentParser() ap.add_argument("--model", action="append", required=True, help="model to score: a local dir or a Hugging Face Hub id " "(repeat for multiple models)") ap.add_argument("--benchmark", default=str(FINAL_DIR / "benchmark" / "benchmark.parquet"), help="benchmark parquet (default: data/final/benchmark/benchmark.parquet)") ap.add_argument("--batch_size", type=int, default=32) ap.add_argument("--max_length", type=int, default=512, help="token truncation length for scoring") ap.add_argument("--max_rows", type=int, default=None, help="score only the first N rows (for quick smoke runs)") ap.add_argument("--device", default=None, help="device id, e.g. 0 (auto if omitted)") ap.add_argument("--out", default=str(FINAL_DIR / "benchmark" / "results.json")) args = ap.parse_args() df = pd.read_parquet(args.benchmark) if args.max_rows is not None: df = df.head(args.max_rows) labels = df["label"].to_numpy() texts = df["text"].tolist() print(f"benchmark rows: {len(df):,} (offensive {int((labels == POS_LABEL).sum()):,})") if args.device is None: device = "cuda" if torch.cuda.is_available() else "cpu" else: device = "cpu" if str(args.device).lower() == "cpu" else int(args.device) print(f"device: {device}\n") results = {} for model_id in args.model: name = os.path.basename(model_id.rstrip("/")) \ if os.path.isdir(model_id) else model_id print(f"[{name}] loading {model_id} ...") tokenizer = AutoTokenizer.from_pretrained(model_id) model = AutoModelForSequenceClassification.from_pretrained(model_id) n_labels = getattr(model.config, "num_labels", 2) if n_labels != 2: print(f" ! warning: model has {n_labels} labels; only a 2-class " "(clean/offensive) mapping is meaningful") model.to(device) label_map = _label_map(model) if label_map: print(f" label mapping from config: {label_map}") preds = _apply_label_map( _predict(model, tokenizer, texts, args.batch_size, args.max_length, device), label_map, ) entry = {"overall": _metrics(labels, preds)} for group, col in (("by_benchmark_split", "benchmark_split"), ("by_mutated", "mutated"), ("by_source", "source")): entry[group] = {} for value, ix in df.groupby(col).groups.items(): entry[group][str(value)] = _metrics(labels[ix], preds[ix]) results[name] = entry print(f" overall: {_fmt(entry['overall'])}") print(f" test: {_fmt_or(entry['by_benchmark_split'], 'test')}") print(f" test_obfuscated: {_fmt_or(entry['by_benchmark_split'], 'test_obfuscated')}") print(f" plain: {_fmt_or(entry['by_mutated'], '0')}") print(f" mutated: {_fmt_or(entry['by_mutated'], '1')}\n") os.makedirs(os.path.dirname(args.out), exist_ok=True) with open(args.out, "w", encoding="utf-8") as f: json.dump(results, f, indent=2) print(f"saved: {args.out}") if __name__ == "__main__": main()