Chess Challenge submission by KHOUTAIBI

README.md

@@ -0,0 +1,26 @@
+---
+library_name: transformers
+tags:
+- chess
+- llm-course
+- chess-challenge
+license: mit
+---
+
+# chess-model-KHOUTAIBI_gated
+
+Chess model submitted to the LLM Course Chess Challenge.
+
+## Submission Info
+
+- **Submitted by**: [KHOUTAIBI](https://huggingface.co/KHOUTAIBI)
+- **Parameters**: 992,242
+- **Organization**: LLM-course
+
+## Model Details
+
+- **Architecture**: Chess Transformer (GPT-style)
+- **Vocab size**: 68
+- **Embedding dim**: 96
+- **Layers**: 10
+- **Heads**: 4

config.json

@@ -0,0 +1,25 @@
+{
+  "_name_or_path": "./output_gated/checkpoint-48243/",
+  "architectures": [
+    "ChessForCausalLM"
+  ],
+  "auto_map": {
+    "AutoConfig": "model.ChessConfig",
+    "AutoModelForCausalLM": "model.ChessForCausalLM"
+  },
+  "bos_token_id": 1,
+  "dropout": 0.1,
+  "eos_token_id": 2,
+  "model_type": "chess_transformer",
+  "n_ctx": 256,
+  "n_embd": 96,
+  "n_head": 4,
+  "n_inner": 210,
+  "n_kv_head": 4,
+  "n_layer": 10,
+  "pad_token_id": 0,
+  "tie_weights": true,
+  "torch_dtype": "float32",
+  "transformers_version": "4.45.2",
+  "vocab_size": 68
+}

model.py

@@ -0,0 +1,416 @@
+from __future__ import annotations
+
+import math
+from typing import Optional, Tuple, Union
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+
+# -------------------------
+# Config
+# -------------------------
+class ChessConfig(PretrainedConfig):
+    model_type = "chess_transformer"
+
+    def __init__(
+        self,
+        vocab_size: int = 72,
+        n_embd: int = 96,
+        n_layer: int = 10,
+        n_head: int = 4,
+        n_ctx: int = 256,
+        n_inner: Optional[int] = None,
+        dropout: float = 0.1,
+        tie_weights: bool = True,
+        pad_token_id: int = 0,
+        bos_token_id: int = 1,
+        eos_token_id: int = 2,
+        layer_norm_epsilon: float = 1e-5,  # kept for compatibility
+        n_kv_head: Optional[int] = None,
+        **kwargs,
+    ):
+        super().__init__(
+            pad_token_id=pad_token_id,
+            bos_token_id=bos_token_id,
+            eos_token_id=eos_token_id,
+            **kwargs,
+        )
+
+        self.vocab_size = int(vocab_size)
+        self.n_embd = int(n_embd)
+        self.n_layer = int(n_layer)
+        self.n_head = int(n_head)
+        self.n_ctx = int(n_ctx)
+        self.n_inner = int(n_inner) if n_inner is not None else int(4 * n_embd)  # common for SwiGLU
+        self.n_kv_head = n_kv_head if n_kv_head is not None else self.n_head
+        self.dropout = float(dropout)
+        self.tie_weights = bool(tie_weights)
+
+        # HF uses this to decide whether to tie embeddings
+        self.tie_word_embeddings = bool(tie_weights)
+
+
+# -------------------------
+# RMSNorm
+# -------------------------
+class RMSNorm(nn.Module):
+    def __init__(self, dim: int, eps: float = 1e-8):
+        super().__init__()
+        self.eps = eps
+        self.weight = nn.Parameter(torch.ones(dim))
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        # x: [..., dim]
+        norm = x.pow(2).mean(dim=-1, keepdim=True).add(self.eps).rsqrt()
+        return x * norm * self.weight
+
+
+# -------------------------
+# ALiBi helpers (0 params)
+# -------------------------
+# src/model.py (REPLACE your MultiHeadAttention with this one)
+# Adds: (1) Grouped Query Attention (GQA) with n_kv_heads < n_head
+#       (2) Gated attention output (cheap scalar gate)
+#       (3) Optional ALiBi bias (recommended for chess, helps generalize with small models)
+#
+# Drop-in: keep the rest of your model.py unchanged.
+
+
+
+def _get_alibi_slopes(n_heads: int) -> torch.Tensor:
+    """
+    Standard ALiBi slopes (Press et al.).
+    Works for any n_heads (not just powers of 2).
+    """
+    def get_slopes_power_of_2(n):
+        start = 2 ** (-2 ** -(math.log2(n) - 3))
+        ratio = start
+        return [start * (ratio ** i) for i in range(n)]
+
+    if (n_heads & (n_heads - 1)) == 0:  # power of 2
+        slopes = get_slopes_power_of_2(n_heads)
+    else:
+        # closest power of 2 lower
+        n_pow2 = 2 ** math.floor(math.log2(n_heads))
+        slopes = get_slopes_power_of_2(n_pow2)
+        # extra heads: interpolate using next power of 2
+        slopes_extra = get_slopes_power_of_2(2 * n_pow2)[0::2][: n_heads - n_pow2]
+        slopes = slopes + slopes_extra
+
+    return torch.tensor(slopes, dtype=torch.float32)
+
+
+class MultiHeadAttention(nn.Module):
+    """
+    Grouped Query Attention (GQA) + gated attention output.
+
+    - Q has n_head heads
+    - K,V have n_kv_heads heads (shared across query heads)
+    - Output is multiplied by a learned sigmoid gate (scalar per token)
+
+    Config expectations:
+      config.n_embd
+      config.n_head
+      config.n_ctx
+      config.dropout
+      (optional) config.n_kv_head  (if absent -> defaults to n_head)
+
+    If you want GQA: set config.n_kv_head = 1 or 2 (must divide n_head).
+    """
+    def __init__(self, config):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0, "n_embd must be divisible by n_head"
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.head_dim = config.n_embd // config.n_head
+
+        # ---- GQA heads ----
+        self.n_kv_head = getattr(config, "n_kv_head", config.n_head)
+        assert self.n_head % self.n_kv_head == 0, "n_head must be divisible by n_kv_head"
+        self.q_per_kv = self.n_head // self.n_kv_head  # how many Q heads share one KV head
+
+        # Projections:
+        # Q: d -> d (n_head * head_dim)
+        # K,V: d -> (n_kv_head * head_dim)
+        self.q_proj = nn.Linear(config.n_embd, config.n_embd, bias=True)
+        self.k_proj = nn.Linear(config.n_embd, self.n_kv_head * self.head_dim, bias=True)
+        self.v_proj = nn.Linear(config.n_embd, self.n_kv_head * self.head_dim, bias=True)
+
+        self.out_proj = nn.Linear(config.n_embd, config.n_embd, bias=True)
+        self.dropout = nn.Dropout(config.dropout)
+
+        # Cheap gate: scalar per token (almost free params)
+        self.gate = nn.Linear(config.n_embd, 1, bias=True)
+
+        # Causal mask
+        self.register_buffer(
+            "causal",
+            torch.tril(torch.ones(config.n_ctx, config.n_ctx, dtype=torch.bool)),
+            persistent=False,
+        )
+
+        # ALiBi slopes (per head)
+        self.register_buffer("alibi_slopes", _get_alibi_slopes(self.n_head), persistent=False)
+
+    def forward(self, x: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+        """
+        x: [B,T,C]
+        attention_mask: [B,T] with 1 for tokens, 0 for padding
+        """
+        B, T, C = x.shape
+        device = x.device
+
+        # Project to Q,K,V
+        q = self.q_proj(x)  # [B,T,C]
+        k = self.k_proj(x)  # [B,T,n_kv*D]
+        v = self.v_proj(x)  # [B,T,n_kv*D]
+
+        # Reshape to heads
+        q = q.view(B, T, self.n_head, self.head_dim).transpose(1, 2)          # [B,H,T,D]
+        k = k.view(B, T, self.n_kv_head, self.head_dim).transpose(1, 2)       # [B,Hkv,T,D]
+        v = v.view(B, T, self.n_kv_head, self.head_dim).transpose(1, 2)       # [B,Hkv,T,D]
+
+        # Expand KV to match Q heads: repeat along head dimension
+        if self.n_kv_head != self.n_head:
+            k = k.repeat_interleave(self.q_per_kv, dim=1)  # [B,H,T,D]
+            v = v.repeat_interleave(self.q_per_kv, dim=1)  # [B,H,T,D]
+
+        # Attention scores
+        att = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.head_dim)  # [B,H,T,T]
+
+        # ALiBi bias: -slope * distance
+        idx = torch.arange(T, device=device)
+        dist = (idx.view(T, 1) - idx.view(1, T)).clamp(min=0).to(att.dtype)     # [T,T]
+        alibi = -self.alibi_slopes.to(att.dtype).view(1, self.n_head, 1, 1) * dist.view(1, 1, T, T)
+        att = att + alibi
+
+        # Causal mask
+        causal = self.causal[:T, :T]  # [T,T]
+        att = att.masked_fill(~causal.view(1, 1, T, T), float("-inf"))
+
+        # Padding mask on keys (mask columns)
+        if attention_mask is not None:
+            key_mask = (attention_mask == 0).unsqueeze(1).unsqueeze(2)  # [B,1,1,T]
+            att = att.masked_fill(key_mask, float("-inf"))
+
+        att = F.softmax(att, dim=-1)
+        att = self.dropout(att)
+
+        out = torch.matmul(att, v)  # [B,H,T,D]
+        out = out.transpose(1, 2).contiguous().view(B, T, C)  # [B,T,C]
+        out = self.out_proj(out)
+
+        # Gate (scalar per token)
+        g = torch.sigmoid(self.gate(x))  # [B,T,1]
+        out = out * g
+
+        return out
+
+
+# -------------------------
+# SwiGLU MLP
+# -------------------------
+class SwiGLU(nn.Module):
+    def __init__(self, config: ChessConfig):
+        super().__init__()
+        self.fc = nn.Linear(config.n_embd, 2 * config.n_inner, bias=True)
+        self.proj = nn.Linear(config.n_inner, config.n_embd, bias=True)
+        self.dropout = nn.Dropout(config.dropout)
+
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        x = self.fc(x)  # [B,T,2*inner]
+        a, b = x.chunk(2, dim=-1)
+        x = F.silu(a) * b
+        x = self.proj(x)
+        x = self.dropout(x)
+        return x
+
+
+# -------------------------
+# Transformer block (Pre-norm)
+# -------------------------
+class TransformerBlock(nn.Module):
+    def __init__(self, config: ChessConfig):
+        super().__init__()
+        self.norm1 = RMSNorm(config.n_embd)
+        self.attn = MultiHeadAttention(config)
+        self.norm2 = RMSNorm(config.n_embd)
+        self.mlp = SwiGLU(config)
+
+    def forward(self, x: torch.Tensor, attention_mask: Optional[torch.Tensor] = None) -> torch.Tensor:
+        x = x + self.attn(self.norm1(x), attention_mask=attention_mask)
+        x = x + self.mlp(self.norm2(x))
+        return x
+
+
+# -------------------------
+# Main model
+# -------------------------
+class ChessForCausalLM(PreTrainedModel):
+    """
+    GPT-style chess model with:
+    - Token embeddings
+    - Token-type embeddings (square / promo / special-other)
+    - ALiBi attention (no learned positions)
+    - RMSNorm + SwiGLU
+    """
+    config_class = ChessConfig
+    base_model_prefix = "transformer"
+    supports_gradient_checkpointing = True
+    keys_to_ignore_on_load_missing = ["lm_head.weight"]
+    _no_split_modules = ["TransformerBlock"]
+
+    def __init__(self, config: ChessConfig):
+        super().__init__(config)
+
+        self.wte = nn.Embedding(config.vocab_size, config.n_embd)
+
+        # token-type embeddings: 0=square, 1=special/other, 2=promotion
+        self.wtt = nn.Embedding(3, config.n_embd)
+
+        self.drop = nn.Dropout(config.dropout)
+        self.h = nn.ModuleList([TransformerBlock(config) for _ in range(config.n_layer)])
+        self.norm_f = RMSNorm(config.n_embd)
+
+        self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+
+        if config.tie_weights:
+            self._tied_weights_keys = ["lm_head.weight"]
+
+        self.post_init()
+
+        if config.tie_weights:
+            self.tie_weights()
+
+    def get_input_embeddings(self) -> nn.Module:
+        return self.wte
+
+    def set_input_embeddings(self, new_embeddings: nn.Module):
+        self.wte = new_embeddings
+        if getattr(self.config, "tie_weights", False) or getattr(self.config, "tie_word_embeddings", False):
+            self.tie_weights()
+
+    def get_output_embeddings(self) -> nn.Module:
+        return self.lm_head
+
+    def set_output_embeddings(self, new_embeddings: nn.Module):
+        self.lm_head = new_embeddings
+
+    def tie_weights(self):
+        if getattr(self.config, "tie_weights", False) or getattr(self.config, "tie_word_embeddings", False):
+            self._tie_or_clone_weights(self.lm_head, self.wte)
+
+    def _init_weights(self, module: nn.Module):
+        if isinstance(module, nn.Linear):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            nn.init.normal_(module.weight, mean=0.0, std=0.02)
+
+    @staticmethod
+    def make_type_ids(input_ids: torch.LongTensor) -> torch.LongTensor:
+        """
+        Build token-type ids without needing the tokenizer at runtime.
+        Assumes:
+          specials: 0..3
+          squares : 4..67  (64 tokens)
+          promos  : 68..71 (4 tokens)
+        Everything else -> type 1 (special/other).
+        """
+        t = torch.ones_like(input_ids)  # default type=1
+        # squares
+        t = torch.where((input_ids >= 4) & (input_ids <= 67), torch.zeros_like(t), t)
+        # promos
+        t = torch.where((input_ids >= 68) & (input_ids <= 71), torch.full_like(t, 2), t)
+        return t
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        labels: Optional[torch.LongTensor] = None,
+        return_dict: Optional[bool] = None,
+        **kwargs,
+    ) -> Union[Tuple, CausalLMOutputWithPast]:
+        return_dict = return_dict if return_dict is not None else self.config.use_return_dict
+
+        # embeddings
+        tok = self.wte(input_ids)
+        type_ids = self.make_type_ids(input_ids)
+        typ = self.wtt(type_ids)
+
+        x = self.drop(tok + typ)
+
+        # blocks
+        for block in self.h:
+            x = block(x, attention_mask=attention_mask)
+
+        x = self.norm_f(x)
+        logits = self.lm_head(x)
+
+        loss = None
+        if labels is not None:
+            # next-token loss
+            shift_logits = logits[..., :-1, :].contiguous()
+            shift_labels = labels[..., 1:].contiguous()
+            loss = F.cross_entropy(
+                shift_logits.view(-1, shift_logits.size(-1)),
+                shift_labels.view(-1),
+                ignore_index=-100,
+            )
+
+        if not return_dict:
+            out = (logits,)
+            return ((loss,) + out) if loss is not None else out
+
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=logits,
+            past_key_values=None,
+            hidden_states=None,
+            attentions=None,
+        )
+
+    @torch.no_grad()
+    def generate_move(
+        self,
+        input_ids: torch.LongTensor,
+        temperature: float = 1.0,
+        top_k: Optional[int] = None,
+        top_p: Optional[float] = None,
+    ) -> int:
+        self.eval()
+        out = self(input_ids=input_ids)
+        logits = out.logits[:, -1, :] / max(temperature, 1e-6)
+
+        if top_k is not None and top_k > 0:
+            top_k = min(top_k, logits.size(-1))
+            thresh = torch.topk(logits, top_k, dim=-1).values[..., -1, None]
+            logits = logits.masked_fill(logits < thresh, float("-inf"))
+
+        if top_p is not None and 0.0 < top_p < 1.0:
+            sorted_logits, sorted_idx = torch.sort(logits, descending=True)
+            probs = F.softmax(sorted_logits, dim=-1)
+            cum = torch.cumsum(probs, dim=-1)
+            remove = cum > top_p
+            remove[..., 1:] = remove[..., :-1].clone()
+            remove[..., 0] = 0
+            remove_idx = remove.scatter(dim=-1, index=sorted_idx, src=remove)
+            logits = logits.masked_fill(remove_idx, float("-inf"))
+
+        probs = F.softmax(logits, dim=-1)
+        next_id = torch.multinomial(probs, num_samples=1)
+        return int(next_id.item())
+
+
+# Register custom model for HF Auto classes
+from transformers import AutoConfig, AutoModelForCausalLM
+
+AutoConfig.register("chess_transformer", ChessConfig)
+AutoModelForCausalLM.register(ChessConfig, ChessForCausalLM)

model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:147c8fdd375c14c340ce536523d9a6142bbb85e8cc5ee4c598aabc3a270c250d
+size 3982840

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,142 @@
+# src/tokenizer.py
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Dict, List, Optional
+
+from transformers import PreTrainedTokenizer
+
+
+class ChessTokenizer(PreTrainedTokenizer):
+    """
+    Ultra-simple square tokenizer.
+
+    Vocab (68 tokens):
+      - 4 specials: [PAD] [BOS] [EOS] [UNK]
+      - 64 squares: a1..h8
+
+    Tokenization:
+      - Any text containing two squares -> emits those squares as tokens
+      - Accepts:
+          "WPe2e4(x+)" , "e2e4" , "e2 e4"  -> ["e2","e4"]
+      - For longer histories, extracts ALL squares in order.
+
+    Decoding:
+      - Joins square tokens with spaces => evaluator regex sees them easily.
+    """
+
+    model_input_names = ["input_ids", "attention_mask"]
+    vocab_files_names = {"vocab_file": "vocab.json"}
+
+    PAD_TOKEN = "[PAD]"
+    BOS_TOKEN = "[BOS]"
+    EOS_TOKEN = "[EOS]"
+    UNK_TOKEN = "[UNK]"
+
+    _SQUARE_PATTERN = r"[a-h][1-8]"
+    _SQUARE_RE = re.compile(_SQUARE_PATTERN)
+
+    def __init__(
+        self,
+        vocab_file: Optional[str] = None,
+        vocab: Optional[Dict[str, int]] = None,
+        **kwargs,
+    ):
+        self._pad_token = self.PAD_TOKEN
+        self._bos_token = self.BOS_TOKEN
+        self._eos_token = self.EOS_TOKEN
+        self._unk_token = self.UNK_TOKEN
+
+        kwargs.pop("pad_token", None)
+        kwargs.pop("bos_token", None)
+        kwargs.pop("eos_token", None)
+        kwargs.pop("unk_token", None)
+
+        if vocab is not None:
+            self._vocab = vocab
+        elif vocab_file is not None and os.path.exists(vocab_file):
+            with open(vocab_file, "r", encoding="utf-8") as f:
+                self._vocab = json.load(f)
+        else:
+            self._vocab = self._create_fixed_vocab()
+
+        self._ids_to_tokens = {v: k for k, v in self._vocab.items()}
+
+        super().__init__(
+            pad_token=self._pad_token,
+            bos_token=self._bos_token,
+            eos_token=self._eos_token,
+            unk_token=self._unk_token,
+            **kwargs,
+        )
+
+    @classmethod
+    def _create_fixed_vocab(cls) -> Dict[str, int]:
+        specials = [cls.PAD_TOKEN, cls.BOS_TOKEN, cls.EOS_TOKEN, cls.UNK_TOKEN]
+        files = "abcdefgh"
+        ranks = "12345678"
+        squares = [f + r for r in ranks for f in files]  # a1..h8
+        tokens = specials + squares
+        return {tok: i for i, tok in enumerate(tokens)}
+
+    @classmethod
+    def build_vocab_from_iterator(cls, iterator, **kwargs) -> "ChessTokenizer":
+        return cls(vocab=cls._create_fixed_vocab())
+
+    @classmethod
+    def build_vocab_from_dataset(cls, *args, **kwargs) -> "ChessTokenizer":
+        return cls(vocab=cls._create_fixed_vocab())
+
+    @property
+    def vocab_size(self) -> int:
+        return len(self._vocab)
+
+    def get_vocab(self) -> Dict[str, int]:
+        return dict(self._vocab)
+
+    def _tokenize(self, text: str) -> List[str]:
+        text = text.strip()
+        if not text:
+            return []
+
+        # Keep BOS/EOS tokens if they appear as standalone strings
+        # (rare, but safe)
+        if text in {self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN}:
+            return [text]
+
+        # Extract all squares in order from the text
+        squares = self._SQUARE_RE.findall(text)
+        if not squares:
+            # if nothing parsable, return UNK token
+            return [self.UNK_TOKEN]
+
+        # Filter to vocab squares only (should always be true)
+        out = [sq for sq in squares if sq in self._vocab]
+        return out if out else [self.UNK_TOKEN]
+
+    def _convert_token_to_id(self, token: str) -> int:
+        return self._vocab.get(token, self._vocab[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:
+        # Drop special tokens; join squares with spaces so evaluator can parse.
+        special = {self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN}
+        toks = [t for t in tokens if t not in special]
+        return " ".join(toks)
+
+    def save_vocabulary(self, save_directory: str, filename_prefix: Optional[str] = None) -> tuple:
+        if not os.path.isdir(save_directory):
+            os.makedirs(save_directory, exist_ok=True)
+
+        vocab_file = os.path.join(
+            save_directory,
+            (filename_prefix + "-" if filename_prefix else "") + "vocab.json",
+        )
+        with open(vocab_file, "w", encoding="utf-8") as f:
+            json.dump(self._vocab, f, ensure_ascii=False, indent=2)
+
+        return (vocab_file,)

tokenizer_config.json

@@ -0,0 +1,49 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[BOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[EOS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "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]",
+  "model_max_length": 1000000000000000019884624838656,
+  "pad_token": "[PAD]",
+  "tokenizer_class": "ChessTokenizer",
+  "unk_token": "[UNK]"
+}

vocab.json

@@ -0,0 +1,70 @@
+{
+  "[PAD]": 0,
+  "[BOS]": 1,
+  "[EOS]": 2,
+  "[UNK]": 3,
+  "a1": 4,
+  "b1": 5,
+  "c1": 6,
+  "d1": 7,
+  "e1": 8,
+  "f1": 9,
+  "g1": 10,
+  "h1": 11,
+  "a2": 12,
+  "b2": 13,
+  "c2": 14,
+  "d2": 15,
+  "e2": 16,
+  "f2": 17,
+  "g2": 18,
+  "h2": 19,
+  "a3": 20,
+  "b3": 21,
+  "c3": 22,
+  "d3": 23,
+  "e3": 24,
+  "f3": 25,
+  "g3": 26,
+  "h3": 27,
+  "a4": 28,
+  "b4": 29,
+  "c4": 30,
+  "d4": 31,
+  "e4": 32,
+  "f4": 33,
+  "g4": 34,
+  "h4": 35,
+  "a5": 36,
+  "b5": 37,
+  "c5": 38,
+  "d5": 39,
+  "e5": 40,
+  "f5": 41,
+  "g5": 42,
+  "h5": 43,
+  "a6": 44,
+  "b6": 45,
+  "c6": 46,
+  "d6": 47,
+  "e6": 48,
+  "f6": 49,
+  "g6": 50,
+  "h6": 51,
+  "a7": 52,
+  "b7": 53,
+  "c7": 54,
+  "d7": 55,
+  "e7": 56,
+  "f7": 57,
+  "g7": 58,
+  "h7": 59,
+  "a8": 60,
+  "b8": 61,
+  "c8": 62,
+  "d8": 63,
+  "e8": 64,
+  "f8": 65,
+  "g8": 66,
+  "h8": 67
+}