Chess Challenge submission by steakmagnan

README.md

@@ -0,0 +1,31 @@
+---
+library_name: transformers
+tags:
+- chess
+- llm-course
+- chess-challenge
+license: mit
+---
+
+# chess-maxence-V2
+
+Chess model submitted to the LLM Course Chess Challenge.
+
+## Submission Info
+
+- **Submitted by**: [steakmagnan](https://huggingface.co/steakmagnan)
+- **Parameters**: 798,208
+- **Organization**: LLM-course
+
+## Usage
+
+```python
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
+model = AutoModelForCausalLM.from_pretrained("LLM-course/chess-maxence-V2", trust_remote_code=True)
+tokenizer = AutoTokenizer.from_pretrained("LLM-course/chess-maxence-V2", trust_remote_code=True)
+```
+
+## Evaluation
+
+This model is evaluated at the [Chess Challenge Arena](https://huggingface.co/spaces/LLM-course/Chess1MChallenge).

config.json

@@ -0,0 +1,24 @@
+{
+  "architectures": [
+    "ChessForCausalLM"
+  ],
+  "bos_token_id": 1,
+  "dropout": 0.1,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "layer_norm_epsilon": 1e-05,
+  "model_type": "chess_transformer",
+  "n_ctx": 256,
+  "n_embd": 128,
+  "n_head": 4,
+  "n_inner": 384,
+  "n_layer": 4,
+  "pad_token_id": 0,
+  "tie_weights": true,
+  "transformers_version": "4.57.4",
+  "vocab_size": 81,
+  "auto_map": {
+    "AutoConfig": "model.ChessConfig",
+    "AutoModelForCausalLM": "model.ChessForCausalLM"
+  }
+}

model.py

@@ -0,0 +1,352 @@
+
+"""
+Chess Transformer Model for the Chess Challenge.
+
+This module provides a simple GPT-style transformer architecture
+designed to fit within the 1M parameter constraint.
+
+Key components:
+- ChessConfig: Configuration class for model hyperparameters
+- ChessForCausalLM: The main model class for next-move prediction
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Optional, Tuple, Union, List
+
+import torch
+import torch.nn as nn
+import torch.nn.functional as F
+from transformers import PretrainedConfig, PreTrainedModel
+from transformers.modeling_outputs import CausalLMOutputWithPast
+
+
+class ChessConfig(PretrainedConfig):
+    """
+    Configuration class for the Chess Transformer model.
+    """
+    
+    model_type = "chess_transformer"
+    
+    def __init__(
+        self,
+        vocab_size: int = 200, # Approx size for component vocab
+        n_embd: int = 120,    # Reduced to be divisible by heads and fit budget
+        n_layer: int = 6,
+        n_head: int = 4,
+        n_ctx: int = 250,     # Max moves (not tokens)
+        n_inner: Optional[int] = None,
+        dropout: float = 0.1,
+        layer_norm_epsilon: float = 1e-5,
+        tie_weights: bool = True,
+        pad_token_id: int = 0,
+        bos_token_id: int = 1,
+        eos_token_id: int = 2,
+        **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 = vocab_size
+        self.n_embd = n_embd
+        self.n_layer = n_layer
+        self.n_head = n_head
+        self.n_ctx = n_ctx
+        self.n_inner = n_inner if n_inner is not None else 3 * n_embd
+        self.dropout = dropout
+        self.layer_norm_epsilon = layer_norm_epsilon
+        self.tie_weights = tie_weights
+        self.tie_word_embeddings = bool(tie_weights)
+
+
+class MultiHeadAttention(nn.Module):
+    def __init__(self, config: ChessConfig):
+        super().__init__()
+        assert config.n_embd % config.n_head == 0
+        self.n_head = config.n_head
+        self.n_embd = config.n_embd
+        self.head_dim = config.n_embd // config.n_head
+        
+        self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd)
+        self.c_proj = nn.Linear(config.n_embd, config.n_embd)
+        self.dropout = nn.Dropout(config.dropout)
+        
+        self.register_buffer(
+            "bias",
+            torch.tril(torch.ones(config.n_ctx, config.n_ctx)).view(
+                1, 1, config.n_ctx, config.n_ctx
+            ),
+            persistent=False,
+        )
+    
+    def forward(self, x, attention_mask=None):
+        batch_size, seq_len, _ = x.size()
+        qkv = self.c_attn(x)
+        q, k, v = qkv.split(self.n_embd, dim=2)
+        q = q.view(batch_size, seq_len, self.n_head, self.head_dim).transpose(1, 2)
+        k = k.view(batch_size, seq_len, self.n_head, self.head_dim).transpose(1, 2)
+        v = v.view(batch_size, seq_len, self.n_head, self.head_dim).transpose(1, 2)
+        
+        attn_weights = torch.matmul(q, k.transpose(-2, -1)) / math.sqrt(self.head_dim)
+        
+        causal_mask = self.bias[:, :, :seq_len, :seq_len]
+        attn_weights = attn_weights.masked_fill(causal_mask == 0, float("-inf"))
+        
+        if attention_mask is not None:
+            # Mask should be broadcastable
+            attn_weights = attn_weights + attention_mask
+        
+        attn_weights = F.softmax(attn_weights, dim=-1)
+        attn_weights = self.dropout(attn_weights)
+        
+        attn_output = torch.matmul(attn_weights, v)
+        attn_output = attn_output.transpose(1, 2).contiguous().view(
+            batch_size, seq_len, self.n_embd
+        )
+        return self.c_proj(attn_output)
+
+
+class FeedForward(nn.Module):
+    def __init__(self, config: ChessConfig):
+        super().__init__()
+        self.c_fc = nn.Linear(config.n_embd, config.n_inner)
+        self.c_proj = nn.Linear(config.n_inner, config.n_embd)
+        self.dropout = nn.Dropout(config.dropout)
+    
+    def forward(self, x):
+        x = self.c_fc(x)
+        x = F.gelu(x)
+        x = self.c_proj(x)
+        x = self.dropout(x)
+        return x
+
+
+class TransformerBlock(nn.Module):
+    def __init__(self, config: ChessConfig):
+        super().__init__()
+        self.ln_1 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
+        self.attn = MultiHeadAttention(config)
+        self.ln_2 = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
+        self.mlp = FeedForward(config)
+    
+    def forward(self, x, attention_mask=None):
+        x = x + self.attn(self.ln_1(x), attention_mask=attention_mask)
+        x = x + self.mlp(self.ln_2(x))
+        return x
+
+
+class ChessForCausalLM(PreTrainedModel):
+    config_class = ChessConfig
+    base_model_prefix = "transformer"
+    supports_gradient_checkpointing = True
+    
+    def __init__(self, config: ChessConfig):
+        super().__init__(config)
+        
+        # Component embeddings (Color, Piece, Src, Dst, Suffix)
+        self.wte_color = nn.Embedding(config.vocab_size, config.n_embd)
+        self.wte_piece = nn.Embedding(config.vocab_size, config.n_embd)
+        self.wte_src = nn.Embedding(config.vocab_size, config.n_embd)
+        self.wte_dst = nn.Embedding(config.vocab_size, config.n_embd)
+        self.wte_suf = nn.Embedding(config.vocab_size, config.n_embd)
+        
+        self.wpe = nn.Embedding(config.n_ctx, config.n_embd)
+        self.drop = nn.Dropout(config.dropout)
+        
+        self.h = nn.ModuleList([
+            TransformerBlock(config) for _ in range(config.n_layer)
+        ])
+        
+        self.ln_f = nn.LayerNorm(config.n_embd, eps=config.layer_norm_epsilon)
+        
+        # 5 Heads for predicting next components
+        # We model p(NextMove | History). 
+        # Components of NextMove are predicted conditionally independent given History (simplification)
+        # or we could make them autoregressive within the move. 
+        # For "product encoding", parallel prediction is natural.
+        self.head_color = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.head_piece = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.head_src = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.head_dst = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        self.head_suf = nn.Linear(config.n_embd, config.vocab_size, bias=False)
+        
+        self.post_init()
+
+    def _init_weights(self, module):
+        if isinstance(module, nn.Linear):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+            if module.bias is not None:
+                torch.nn.init.zeros_(module.bias)
+        elif isinstance(module, nn.Embedding):
+            torch.nn.init.normal_(module.weight, mean=0.0, std=0.02)
+        elif isinstance(module, nn.LayerNorm):
+            torch.nn.init.ones_(module.weight)
+            torch.nn.init.zeros_(module.bias)
+            
+    def get_input_embeddings(self):
+        # Return first embedding as proxy, though we have multiple
+        return self.wte_color
+
+    def forward(
+        self,
+        input_ids: torch.LongTensor,
+        attention_mask: Optional[torch.Tensor] = None,
+        position_ids: Optional[torch.LongTensor] = 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
+        
+        batch_size, seq_len = input_ids.size()
+        
+        # Ensure sequence length is multiple of 5
+        if seq_len % 5 != 0:
+            # Pad or truncate? For training we expect aligned batches
+            # Truncate to nearest multiple of 5
+            new_len = (seq_len // 5) * 5
+            input_ids = input_ids[:, :new_len]
+            if labels is not None:
+                labels = labels[:, :new_len]
+            if attention_mask is not None:
+                attention_mask = attention_mask[:, :new_len]
+            seq_len = new_len
+            
+        num_moves = seq_len // 5
+        
+        # Reshape to (B, L, 5)
+        # Components: 0=Color, 1=Piece, 2=Src, 3=Dst, 4=Suf
+        reshaped_ids = input_ids.view(batch_size, num_moves, 5)
+        
+        # Product Embedding
+        emb_c = self.wte_color(reshaped_ids[:, :, 0])
+        emb_p = self.wte_piece(reshaped_ids[:, :, 1])
+        emb_s = self.wte_src(reshaped_ids[:, :, 2])
+        emb_d = self.wte_dst(reshaped_ids[:, :, 3])
+        emb_f = self.wte_suf(reshaped_ids[:, :, 4])
+        
+        # Element-wise product
+        token_embeds = emb_c * emb_p * emb_s * emb_d * emb_f
+        
+        # Position Embeddings
+        device = input_ids.device
+        if position_ids is None:
+            position_ids = torch.arange(num_moves, device=device).unsqueeze(0)
+        
+        position_embeds = self.wpe(position_ids)
+        hidden_states = self.drop(token_embeds + position_embeds)
+        
+        # Attention mask adaptation
+        # input mask is (B, 5L). We need (B, L).
+        # We consider a move valid if ALL components are valid? Or ANY?
+        # Typically padding is consistent.
+        if attention_mask is not None:
+             # Take every 5th element or min/max
+             reshaped_mask = attention_mask.view(batch_size, num_moves, 5)
+             # If any part is unmasked (1), keep it? 
+             # Usually PAD=0. If all are PAD, then 0.
+             chess_mask = reshaped_mask.all(dim=-1).float() # (B, L)
+             # Standard broadcast for attention: (B, 1, 1, L)
+             extended_attention_mask = (1.0 - chess_mask) * -10000.0
+             extended_attention_mask = extended_attention_mask.unsqueeze(1).unsqueeze(2)
+        else:
+             extended_attention_mask = None
+        
+        # Transformer
+        for block in self.h:
+            hidden_states = block(hidden_states, attention_mask=extended_attention_mask)
+            
+        hidden_states = self.ln_f(hidden_states)
+        
+        # Output Heads (Predicting Next Move Components)
+        logits_c = self.head_color(hidden_states)
+        logits_p = self.head_piece(hidden_states)
+        logits_s = self.head_src(hidden_states)
+        logits_d = self.head_dst(hidden_states)
+        logits_f = self.head_suf(hidden_states)
+        
+        # Stack logits: (B, L, 5, V)
+        logits_stacked = torch.stack([logits_c, logits_p, logits_s, logits_d, logits_f], dim=2)
+        
+        # Compute Loss
+        loss = None
+        if labels is not None:
+            # Reshape labels: (B, L, 5)
+            labels_reshaped = labels.view(batch_size, num_moves, 5)
+            
+            # Shift: Hidden[t] predicts Labels[t+1]
+            shift_logits = logits_stacked[:, :-1, :, :].contiguous()
+            shift_labels = labels_reshaped[:, 1:, :].contiguous()
+            
+            # Flatten
+            loss_fct = nn.CrossEntropyLoss(ignore_index=-100)
+            loss = loss_fct(
+                shift_logits.view(-1, self.config.vocab_size),
+                shift_labels.view(-1)
+            )
+            
+        # Return structured output
+        # To satisfy Trainer, we might need to return (B, 5L, V) logits?
+        # But we produced (B, L, 5, V). Flattening gives (B, 5L, V).
+        # Trainer expects logits matching input length usually, or labels length.
+        
+        flat_logits = logits_stacked.view(batch_size, -1, self.config.vocab_size)
+        
+        if not return_dict:
+            output = (flat_logits,)
+            return ((loss,) + output) if loss is not None else output
+            
+        return CausalLMOutputWithPast(
+            loss=loss,
+            logits=flat_logits,
+        )
+
+    @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,
+    ) -> List[int]:
+        """
+        Generate the next move (5 tokens).
+        """
+        self.eval()
+        
+        # Forward pass
+        # input_ids (1, 5L)
+        outputs = self(input_ids)
+        # Logits: (1, 5L, V)
+        # We want the last move prediction.
+        # The logits for the NEXT move are at the very end.
+        # Specifically, the last block of 5 logits corresponds to predictions from the last hidden state.
+        
+        # Check dimensions
+        next_move_logits = outputs.logits[:, -5:, :] # (1, 5, V)
+        
+        generated = []
+        for i in range(5):
+            logits = next_move_logits[:, i, :] / temperature
+            # Apply filtering
+            if top_k is not None:
+                v, _ = torch.topk(logits, top_k)
+                logits[logits < v[:, [-1]]] = -float('Inf')
+            
+            probs = F.softmax(logits, dim=-1)
+            next_token = torch.multinomial(probs, num_samples=1)
+            generated.append(next_token.item())
+            
+        return generated
+
+# Register
+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:d9de2b4871bde7dc163d4f8a6f930da7a4f2f5bd89b47e4fadc5c628ceca711d
+size 3197992

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,226 @@
+"""
+Custom Chess Tokenizer for the Chess Challenge.
+
+This tokenizer breaks down moves into 5 components:
+Color, Piece, Source, Destination, Suffix.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import re
+from typing import Dict, List, Optional
+
+from transformers import PreTrainedTokenizer
+
+
+class ChessTokenizer(PreTrainedTokenizer):
+    """
+    A component-based tokenizer for chess moves.
+    
+    Each move is split into 5 tokens:
+    [Color, Piece, Source, Destination, Suffix]
+    
+    Vocabulary is fixed and deterministic.
+    """
+    
+    model_input_names = ["input_ids", "attention_mask"]
+    vocab_files_names = {"vocab_file": "vocab.json"}
+    
+    # Special tokens
+    PAD_TOKEN = "[PAD]"
+    BOS_TOKEN = "[BOS]"
+    EOS_TOKEN = "[EOS]"
+    UNK_TOKEN = "[UNK]"
+    
+    # Component definitions
+    COLORS = ["W", "B"]
+    PIECES = ["P", "N", "B", "R", "Q", "K"]
+    FILES = ["a", "b", "c", "d", "e", "f", "g", "h"]
+    RANKS = ["1", "2", "3", "4", "5", "6", "7", "8"]
+    SUFFIXES = ["", "(x)", "(+)", "(+*)", "(o)", "(O)"]
+    
+    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_default_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,
+        )
+
+    def _create_default_vocab(self) -> Dict[str, int]:
+        tokens = [self.PAD_TOKEN, self.BOS_TOKEN, self.EOS_TOKEN, self.UNK_TOKEN]
+        
+        # Add all possible components
+        tokens.extend(self.COLORS)
+        tokens.extend(self.PIECES)
+        
+        # Squares
+        squares = [f"{f}{r}" for f in self.FILES for r in self.RANKS]
+        tokens.extend(squares)
+        
+        # Suffixes (ensure empty string is handled explicitly if needed, but usually empty splitting result needs a token)
+        # We will map "no suffix" to a specific token, e.g., "_" or just use PAD? 
+        # Using a dedicated empty token is safer for the 5-component structure.
+        # Let's use "[None]" for empty suffix to be explicit, or just "" if valid key.
+        # JSON keys must be strings. "" is valid.
+        
+        # Add suffixes
+        for s in self.SUFFIXES:
+            if s == "":
+                tokens.append("[None]") # Representation for empty suffix
+            else:
+                tokens.append(s)
+                
+        # Unique tokens only (order matters for ID stability)
+        seen = set()
+        unique_tokens = []
+        for t in tokens:
+            if t not in seen:
+                unique_tokens.append(t)
+                seen.add(t)
+                
+        return {t: i for i, t in enumerate(unique_tokens)}
+
+    @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 is space-separated moves
+        moves = text.strip().split()
+        tokens = []
+        
+        for move in moves:
+            # Handle special tokens directly if they appear in text (rare in raw data but good for safety)
+            if move in [self.BOS_TOKEN, self.EOS_TOKEN, self.PAD_TOKEN, self.UNK_TOKEN]:
+                # Expand special tokens to 5-tuples for consistency?
+                # Or keep as single tokens?
+                # If we want the model to reshape (..., 5), we MUST have multiple of 5.
+                # Let's repeat them 5 times.
+                tokens.extend([move] * 5)
+                continue
+                
+            # Parse Move: e.g. WPe2e4(x)
+            # Regex to capture: (Color)(Piece)(Src)(Dst)(Suffix)
+            # Suffix is optional.
+            # However some moves might be castling? 
+            # Note: Dataset says "(o)/(O)=castling". 
+            # If the move is literally "(o)", it lacks Color/Piece.
+            # But the example `WPe2e4` implies standard algebraic.
+            # `(o)` usually appears as `WKe1g1(o)`?
+            # Let's assume the string format is always full or identifiable.
+            
+            # Simple parsing:
+            # Color: 1 char
+            # Piece: 1 char
+            # Src: 2 chars
+            # Dst: 2 chars
+            # Suffix: Remainder
+            
+            if len(move) < 6: # Shortest move WPe2e4 is 6 chars.
+                # Maybe castling? "0-0"? No, "extended UCI". 
+                # If invalid, emit UNK x 5
+                tokens.extend([self.UNK_TOKEN] * 5)
+                continue
+                
+            c = move[0]
+            p = move[1]
+            src = move[2:4]
+            dst = move[4:6]
+            suf = move[6:]
+            
+            if suf == "":
+                suf_tok = "[None]"
+            else:
+                suf_tok = suf
+                
+            # Validation (optional, but good for safety)
+            raw_components = [c, p, src, dst, suf_tok]
+            
+            # Check if all are in vocab, else UNK
+            final_components = []
+            for comp in raw_components:
+                if comp in self._vocab:
+                    final_components.append(comp)
+                else:
+                    final_components.append(self.UNK_TOKEN)
+            
+            tokens.extend(final_components)
+            
+        return tokens
+
+    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:
+        # Reconstruct moves
+        # tokens is list of components
+        output = []
+        # Process in chunks of 5
+        for i in range(0, len(tokens), 5):
+            chunk = tokens[i:i+5]
+            if len(chunk) < 5:
+                break
+                
+            # Check if special
+            if chunk[0] in [self.BOS_TOKEN, self.EOS_TOKEN, self.PAD_TOKEN]:
+                continue # Skip specials for string output
+                
+            c, p, src, dst, suf = chunk
+            if suf == "[None]":
+                suf = ""
+            
+            output.append(f"{c}{p}{src}{dst}{suf}")
+            
+        return " ".join(output)
+
+    @classmethod
+    def build_vocab_from_dataset(cls, *args, **kwargs):
+        # We use a fixed vocab, so just return an instance
+        return cls()
+        
+    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,50 @@
+{
+  "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
+    }
+  },
+  "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]",
+  "auto_map": {
+    "AutoTokenizer": [
+      "tokenizer.ChessTokenizer",
+      null
+    ]
+  }
+}

training_args.bin

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

vocab.json

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