Chess Challenge submission by ilanou20

README.md

@@ -0,0 +1,15 @@
+---
+library_name: transformers
+tags:
+- chess
+- llm-course
+- chess-challenge
+license: mit
+---
+
+# chess-ilan-v6
+
+Chess model submitted to the LLM Course Chess Challenge.
+
+- Submitted by: ilanou20
+- Parameters: 798,592

config.json

@@ -0,0 +1,24 @@
+{
+  "architectures": [
+    "ChessForCausalLM"
+  ],
+  "bos_token_id": 22,
+  "dropout": 0.0,
+  "dtype": "float32",
+  "eos_token_id": 23,
+  "hidden_size": 128,
+  "is_decoder": true,
+  "model_type": "chess_transformer",
+  "n_ctx": 256,
+  "n_embd": 128,
+  "n_head": 4,
+  "n_inner": 341,
+  "n_layer": 4,
+  "num_attention_heads": 4,
+  "num_hidden_layers": 4,
+  "pad_token_id": 24,
+  "rms_norm_eps": 1e-06,
+  "tie_weights": true,
+  "transformers_version": "4.57.3",
+  "vocab_size": 90
+}

generation_config.json

@@ -0,0 +1,9 @@
+{
+  "_from_model_config": true,
+  "bos_token_id": 22,
+  "eos_token_id": [
+    23
+  ],
+  "pad_token_id": 24,
+  "transformers_version": "4.57.3"
+}

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5aa32d0f1681550d5efd389caf1e346f5f34dd20b63d53f6e9183ca15d58f75d
+size 3198168

special_tokens_map.json

@@ -0,0 +1,6 @@
+{
+  "bos_token": "[BOS]",
+  "eos_token": "[EOS]",
+  "pad_token": "[PAD]",
+  "unk_token": "[UNK]"
+}

tokenizer.py

@@ -0,0 +1,130 @@
+from __future__ import annotations
+import json
+import os
+import re
+from typing import Dict, List, Optional
+from transformers import PreTrainedTokenizer, AutoTokenizer
+
+class ChessTokenizer(PreTrainedTokenizer):
+    vocab_files_names = {"vocab_file": "vocab.json"}
+    model_input_names = ["input_ids", "attention_mask"]
+    
+    PIECES = ["WP", "WN", "WB", "WR", "WQ", "WK", "BP", "BN", "BB", "BR", "BQ", "BK"]
+    SQUARES = [f"{c}{r}" for c in "abcdefgh" for r in "12345678"]
+    SUFFIXES = ["(-)", "(x)", "(+)", "(#)", "(x+)", "(x#)", "(O)", "(o)", "(Q)", "=Q"]
+    
+    PAD_TOKEN = "[PAD]"
+    BOS_TOKEN = "[BOS]"
+    EOS_TOKEN = "[EOS]"
+    UNK_TOKEN = "[UNK]"
+
+    
+    def __init__(self, vocab_file: Optional[str] = None, vocab: Optional[Dict[str, int]] = None, **kwargs):
+        # 1. Build or Load Vocab
+        self._vocab = vocab
+        if vocab_file and os.path.exists(vocab_file):
+            with open(vocab_file, "r", encoding="utf-8") as f:
+                self._vocab = json.load(f)
+        
+        if not self._vocab:
+            self._vocab = self._build_split_vocab()
+            
+        self._ids_to_tokens = {v: k for k, v in self._vocab.items()}
+       
+        pad_token = kwargs.pop("pad_token", self.PAD_TOKEN)
+        bos_token = kwargs.pop("bos_token", self.BOS_TOKEN)
+        eos_token = kwargs.pop("eos_token", self.EOS_TOKEN)
+        unk_token = kwargs.pop("unk_token", self.UNK_TOKEN)
+
+        super().__init__(
+            pad_token=pad_token,
+            bos_token=bos_token,
+            eos_token=eos_token,
+            unk_token=unk_token,
+            **kwargs,
+        )
+
+    def _build_split_vocab(self):
+        tokens = [self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN]
+        tokens += self.PIECES + self.SQUARES + self.SUFFIXES
+        unique_tokens = sorted(list(set(tokens)))
+        return {t: i for i, t in enumerate(unique_tokens)}
+
+    def get_vocab(self) -> Dict[str, int]:
+        return dict(self._vocab)
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    def _tokenize(self, text: str) -> List[str]:
+        moves = text.strip().split()
+        tokens = []
+        
+        
+        pattern = re.compile(r"([WB][PNBRQK])([a-h][1-8])([a-h][1-8])(.*)")
+        
+        for move in moves:
+            match = pattern.match(move)
+            if match:
+                p, s, t, suf = match.groups()
+                tokens.extend([p, s, t])
+                tokens.append(self._normalize_suffix(suf))
+            else:
+                tokens.extend(["WP", "a1", "a1", "(-)"])
+        
+        return tokens
+
+    def _normalize_suffix(self, suf: str) -> str:
+        suf = suf.strip()
+        if not suf:
+            return "(-)"
+        if suf.startswith("x"):
+            if "+" in suf: return "(x+)"
+            if "#" in suf: return "(x#)"
+            return "(x)"
+        if suf == "+": return "(+)"
+        if suf == "#": return "(#)"
+        if suf in {"O", "o"}: return f"({suf})"
+        if suf in {"Q", "=Q"}: return "=Q"
+        return "(-)"
+
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._vocab.get(token, self._vocab.get(self.UNK_TOKEN))
+
+    def _convert_id_to_token(self, index: int) -> str:
+        return self._ids_to_tokens.get(index, self.UNK_TOKEN)
+
+    def convert_tokens_to_string(self, tokens: List[str]) -> str:
+        out = []
+        specials = {self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN}
+        clean = [t for t in tokens if t not in specials]
+        
+        current_move = ""
+        for i, t in enumerate(clean):
+            if t == "(-)":
+                pass
+            else:
+                current_move += t
+            
+            if (i + 1) % 4 == 0:
+                out.append(current_move)
+                current_move = ""
+                
+        if current_move: out.append(current_move)
+        return " ".join(out)
+    
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> tuple:
+        path = os.path.join(save_directory, (filename_prefix + "-" if filename_prefix else "") + "vocab.json")
+        with open(path, "w") as f:
+            json.dump(self._vocab, f)
+        return (path,)
+
+    @classmethod
+    def build_vocab_from_dataset(cls, *args, **kwargs):
+        print("Using static 4-Step Split vocabulary.")
+        return cls()
+
+# Register
+AutoTokenizer.register("ChessTokenizer", ChessTokenizer)

tokenizer_config.json

@@ -0,0 +1,50 @@
+{
+  "added_tokens_decoder": {
+    "22": {
+      "content": "[BOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "23": {
+      "content": "[EOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "24": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "25": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenizer.ChessTokenizer",
+      null
+    ]
+  },
+  "bos_token": "[BOS]",
+  "clean_up_tokenization_spaces": false,
+  "eos_token": "[EOS]",
+  "extra_special_tokens": {},
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "tokenizer_class": "ChessTokenizer",
+  "unk_token": "[UNK]"
+}

vocab.json

@@ -0,0 +1 @@
+{"(#)": 0, "(+)": 1, "(-)": 2, "(O)": 3, "(Q)": 4, "(o)": 5, "(x#)": 6, "(x)": 7, "(x+)": 8, "=Q": 9, "BB": 10, "BK": 11, "BN": 12, "BP": 13, "BQ": 14, "BR": 15, "WB": 16, "WK": 17, "WN": 18, "WP": 19, "WQ": 20, "WR": 21, "[BOS]": 22, "[EOS]": 23, "[PAD]": 24, "[UNK]": 25, "a1": 26, "a2": 27, "a3": 28, "a4": 29, "a5": 30, "a6": 31, "a7": 32, "a8": 33, "b1": 34, "b2": 35, "b3": 36, "b4": 37, "b5": 38, "b6": 39, "b7": 40, "b8": 41, "c1": 42, "c2": 43, "c3": 44, "c4": 45, "c5": 46, "c6": 47, "c7": 48, "c8": 49, "d1": 50, "d2": 51, "d3": 52, "d4": 53, "d5": 54, "d6": 55, "d7": 56, "d8": 57, "e1": 58, "e2": 59, "e3": 60, "e4": 61, "e5": 62, "e6": 63, "e7": 64, "e8": 65, "f1": 66, "f2": 67, "f3": 68, "f4": 69, "f5": 70, "f6": 71, "f7": 72, "f8": 73, "g1": 74, "g2": 75, "g3": 76, "g4": 77, "g5": 78, "g6": 79, "g7": 80, "g8": 81, "h1": 82, "h2": 83, "h3": 84, "h4": 85, "h5": 86, "h6": 87, "h7": 88, "h8": 89}