Upload validators/chess_validator.py with huggingface_hub

validators/chess_validator.py

@@ -0,0 +1,228 @@
+"""Training-free hallucination detector for the ChessImages dataset.
+
+A generated 256x256 chessboard is parsed back to a FEN piece-placement string
+via template matching, and its legality is checked with ``python-chess``
+(``chess.Board.is_valid()``). A board that fails legality (e.g. two white kings,
+>8 pawns, pawns on the back rank, ...) is counted as *hallucinated*.
+
+This mirrors the "ChessImages" detection module described in the paper
+(Section 5.1 / Appendix E). Only ``<PiecePlacement>`` is recovered from the
+image, so rules that need the rest of a FEN (castling / en-passant / side-to-move
+checks) are not used by the legality test.
+
+Usage
+-----
+    python -m evaluation.chess_validator \
+        --gen-dir /path/to/generated/images \
+        [--gt-json train_fen.json --conditional] \
+        [--template-dir evaluation/templates/chess] \
+        [--threshold 0.50]
+
+``--gen-dir`` may be passed multiple times (e.g. one folder per seed); the
+hallucination rate is reported per folder and aggregated (mean +/- std).
+"""
+import argparse
+import json
+import os
+from difflib import SequenceMatcher
+
+import chess
+import cv2
+import numpy as np
+from tqdm import tqdm
+
+# Bundled 32x32 piece templates ship alongside this file.
+DEFAULT_TEMPLATE_DIR = os.path.join(os.path.dirname(__file__), "templates", "chess")
+
+# Map python-chess status flags to a human-readable violation name. Used to
+# bucket hallucinated boards by the rule they break (see paper Appendix E).
+STATUS_FOLDERS = {
+    chess.STATUS_NO_WHITE_KING: "NO_WHITE_KING",
+    chess.STATUS_NO_BLACK_KING: "NO_BLACK_KING",
+    chess.STATUS_TOO_MANY_KINGS: "TOO_MANY_KINGS",
+    chess.STATUS_TOO_MANY_WHITE_PAWNS: "TOO_MANY_WHITE_PAWNS",
+    chess.STATUS_TOO_MANY_BLACK_PAWNS: "TOO_MANY_BLACK_PAWNS",
+    chess.STATUS_PAWNS_ON_BACKRANK: "PAWNS_ON_BACKRANK",
+    chess.STATUS_TOO_MANY_WHITE_PIECES: "TOO_MANY_WHITE_PIECES",
+    chess.STATUS_TOO_MANY_BLACK_PIECES: "TOO_MANY_BLACK_PIECES",
+    chess.STATUS_BAD_CASTLING_RIGHTS: "BAD_CASTLING_RIGHTS",
+    chess.STATUS_INVALID_EP_SQUARE: "INVALID_EP_SQUARE",
+    chess.STATUS_OPPOSITE_CHECK: "OPPOSITE_CHECK",
+    chess.STATUS_EMPTY: "EMPTY",
+    chess.STATUS_RACE_CHECK: "RACE_CHECK",
+    chess.STATUS_RACE_OVER: "RACE_OVER",
+    chess.STATUS_RACE_MATERIAL: "RACE_MATERIAL",
+    chess.STATUS_TOO_MANY_CHECKERS: "TOO_MANY_CHECKERS",
+    chess.STATUS_IMPOSSIBLE_CHECK: "IMPOSSIBLE_CHECK",
+}
+
+PIECE_MAP = {"king": "K", "queen": "Q", "rook": "R", "bishop": "B", "knight": "N", "pawn": "P"}
+
+
+def load_templates(template_dir, target_size=(32, 32)):
+    """Load piece templates keyed by (square color -> FEN char -> [images]).
+
+    Template files are named ``{piece}_{pc}{sc}.png`` where ``pc`` is the piece
+    color (w/b) and ``sc`` the square color (w/b), e.g. ``king_ww.png``.
+    """
+    templates = {"b": {}, "w": {}}
+
+    def process_image(path):
+        img = cv2.imread(path, cv2.IMREAD_GRAYSCALE)
+        if img is None:
+            return None
+        if img.shape != target_size:
+            img = cv2.resize(img, target_size)
+        return img
+
+    loaded = 0
+    for fname in os.listdir(template_dir):
+        if not fname.endswith(".png"):
+            continue
+        try:
+            piece, colors = fname[:-4].split("_")
+            if len(colors) != 2:
+                continue
+            piece_color, square_color = colors[0].lower(), colors[1].lower()
+            if piece.lower() not in PIECE_MAP or piece_color not in "wb" or square_color not in "wb":
+                continue
+            fen_char = PIECE_MAP[piece.lower()]
+            fen_char = fen_char.upper() if piece_color == "w" else fen_char.lower()
+            template = process_image(os.path.join(template_dir, fname))
+            if template is not None:
+                templates[square_color].setdefault(fen_char, []).append(template)
+                loaded += 1
+        except ValueError:
+            continue
+
+    if loaded != 24:
+        raise ValueError(f"Loaded {loaded}/24 templates from {template_dir}. Check filenames/format.")
+    return templates
+
+
+def image_to_fen(image_path, templates, confidence_threshold=0.50, img_size=256):
+    """Reconstruct the FEN piece-placement string from a rendered board image."""
+    board_img = cv2.imread(image_path)
+    if board_img is None:
+        raise FileNotFoundError(f"Image not found: {image_path}")
+    board_img = cv2.resize(board_img, (img_size, img_size))
+    gray = cv2.cvtColor(board_img, cv2.COLOR_BGR2GRAY)
+
+    square_size = img_size // 8
+    fen_rows = []
+    for rank in reversed(range(8)):
+        fen_row, empty_count = [], 0
+        for file in range(8):
+            y, x = (7 - rank) * square_size, file * square_size
+            square = gray[y:y + square_size, x:x + square_size]
+            square_color = "b" if (file + rank) % 2 == 0 else "w"
+
+            best_match = ("", -1)
+            for fen_char, char_templates in templates[square_color].items():
+                for template in char_templates:
+                    result = cv2.matchTemplate(square, template, cv2.TM_CCOEFF_NORMED)
+                    _, max_val, _, _ = cv2.minMaxLoc(result)
+                    if max_val > best_match[1]:
+                        best_match = (fen_char, max_val)
+
+            if best_match[1] >= confidence_threshold:
+                if empty_count:
+                    fen_row.append(str(empty_count))
+                    empty_count = 0
+                fen_row.append(best_match[0])
+            else:
+                empty_count += 1
+        if empty_count:
+            fen_row.append(str(empty_count))
+        fen_rows.append("".join(fen_row))
+    return "/".join(fen_rows)
+
+
+def is_fuzzy_match(extracted, gt, threshold=0.95):
+    return SequenceMatcher(None, extracted, gt).ratio() >= threshold
+
+
+def validate_dirs(images_dirs, template_dir=DEFAULT_TEMPLATE_DIR, gt_json=None,
+                  conditional=False, fuzzy_threshold=0.8, confidence_threshold=0.50,
+                  save_buckets=False):
+    """Validate every image folder and return a metrics dict.
+
+    Set ``conditional=True`` together with ``gt_json`` (a ``{name: FEN}`` map) to
+    additionally report exact / fuzzy FEN reconstruction accuracy against the
+    ground truth. Otherwise only validity / hallucination rate is reported.
+    """
+    templates = load_templates(template_dir)
+    ground_truth = json.load(open(gt_json)) if gt_json else {}
+
+    metrics = {"valid_acc": [], "hallucination": []}
+    if conditional:
+        metrics["exact_acc"] = []
+        metrics[f"{fuzzy_threshold * 100:g}%_match_acc"] = []
+
+    for images_dir in images_dirs:
+        if not os.path.isdir(images_dir):
+            print(f"[warn] not a directory, skipping: {images_dir}")
+            continue
+        files = [f for f in os.listdir(images_dir) if f.lower().endswith(".png")]
+        if conditional:
+            files = [f for f in files if os.path.splitext(f)[0] in ground_truth]
+
+        matches = valid_count = fuzzy_count = total = 0
+        for fname in tqdm(files, desc=os.path.basename(images_dir.rstrip("/")) or "images"):
+            path = os.path.join(images_dir, fname)
+            try:
+                fen = image_to_fen(path, templates, confidence_threshold)
+                if conditional:
+                    gt_fen = ground_truth[os.path.splitext(fname)[0]].split()[0]
+                    matches += int(fen == gt_fen)
+                    fuzzy_count += int(is_fuzzy_match(fen, gt_fen, fuzzy_threshold))
+
+                board = chess.Board(fen)
+                if board.is_valid():
+                    valid_count += 1
+                elif save_buckets:
+                    status_mask = board.status()
+                    for flag, folder in STATUS_FOLDERS.items():
+                        if status_mask & flag:
+                            rule_dir = os.path.join(images_dir, "hallucinated", folder)
+                            os.makedirs(rule_dir, exist_ok=True)
+                            cv2.imwrite(os.path.join(rule_dir, fname), cv2.imread(path))
+                total += 1
+            except Exception as e:  # noqa: BLE001 - keep going on a bad file
+                print(f"[warn] error on {fname}: {e}")
+
+        if total == 0:
+            continue
+        metrics["valid_acc"].append(100 * valid_count / total)
+        metrics["hallucination"].append(100 - 100 * valid_count / total)
+        if conditional:
+            metrics["exact_acc"].append(100 * matches / total)
+            metrics[f"{fuzzy_threshold * 100:g}%_match_acc"].append(100 * fuzzy_count / total)
+
+    print("\n=== ChessImages validation ===")
+    for k, v in metrics.items():
+        print(f"  {k}: {np.mean(v):.2f} +/- {np.std(v):.2f}  (per-folder: {[round(x, 2) for x in v]})")
+    return metrics
+
+
+def main():
+    p = argparse.ArgumentParser(description="ChessImages hallucination detector (FEN legality).")
+    p.add_argument("--gen-dir", action="append", required=True,
+                   help="Folder of generated PNG boards. Repeat for multiple seeds.")
+    p.add_argument("--template-dir", default=DEFAULT_TEMPLATE_DIR,
+                   help="Piece templates (defaults to bundled evaluation/templates/chess).")
+    p.add_argument("--gt-json", default=None, help="Optional {name: FEN} ground-truth map.")
+    p.add_argument("--conditional", action="store_true",
+                   help="Also report exact/fuzzy FEN reconstruction accuracy (requires --gt-json).")
+    p.add_argument("--fuzzy-threshold", type=float, default=0.8)
+    p.add_argument("--threshold", type=float, default=0.50, help="Template-match confidence threshold.")
+    p.add_argument("--save-buckets", action="store_true",
+                   help="Save hallucinated boards into per-rule subfolders under each gen-dir.")
+    args = p.parse_args()
+
+    validate_dirs(args.gen_dir, args.template_dir, args.gt_json, args.conditional,
+                  args.fuzzy_threshold, args.threshold, args.save_buckets)
+
+
+if __name__ == "__main__":
+    main()