Upload 4 files

README.md

@@ -1,3 +1,61 @@
----
-license: mit
----
+# NeoChess
+
+NeoChess is a self-learning chess engine written in Python. It uses PyTorch to build a neural network that evaluates chess positions, and it learns by playing games against the Stockfish engine and itself. The core learning mechanism is based on reinforcement learning principles, where the model is rewarded for winning games and penalized for losing.
+
+## How It Works
+
+The training process is orchestrated by the `selfchess.py` script, which follows these steps:
+
+1.  **Game Simulation**: The engine plays a large number of chess games. The games are divided into three categories:
+    *   NeoChess (as White) vs. Stockfish (as Black)
+    *   NeoChess (as Black) vs. Stockfish (as White)
+    *   NeoChess vs. NeoChess (self-play)
+
+2.  **Parallel Processing**: To speed up data generation, games are simulated in parallel using Python's `multiprocessing` library, utilizing available CPU cores.
+
+3.  **Move Selection**:
+    *   **NeoChess**: Uses a negamax search algorithm (`search`) to explore future moves. The evaluation of terminal positions in the search is provided by its neural network.
+    *   **Stockfish**: A standard, powerful chess engine provides the moves for the opponent.
+
+4.  **Data Collection**: During each game, every board position (FEN string) where it is NeoChess's turn to move is stored.
+
+5.  **Training**: After a game concludes, a reward is assigned: `+10` for a win, `-10` for a loss, and `0` for a draw. The neural network is then trained on the collected board positions from that game. The training target for each position is weighted by the final game outcome, encouraging the model to value positions that lead to wins.
+
+6.  **Model Saving**: The model's state (`chessy_model.pth`) is saved after each game. A backup (`chessy_modelt-1.pth`) is also kept and updated periodically.
+
+## Model Architecture
+
+The brain of NeoChess is a neural network (`NN1` class) with the following structure:
+
+-   **Embedding Layer**: Converts the board's piece representation into a 64-dimensional vector space.
+-   **Multi-Head Attention**: An attention mechanism allows the model to weigh the importance of different pieces and their relationships on the board.
+-   **Feed-Forward Network**: A deep series of linear layers and ReLU activation functions process the features from the attention layer to produce a final evaluation score for the position.
+
+## Requirements
+
+-   Python 3.x
+-   PyTorch
+-   `python-chess` library
+-   A UCI-compatible chess engine binary (e.g., Stockfish)
+
+You can install the Python dependencies using pip:
+```bash
+pip install torch python-chess
+```
+
+## Setup and Usage
+
+1.  **Download Stockfish**: Download the appropriate Stockfish binary for your system from the [official website](https://stockfishchess.org/download/).
+
+2.  **Configure the Script**: Open `selfchess.py` and edit the `CONFIG` dictionary at the top of the file:
+    -   `stockfish_path`: Set this to the absolute path of your downloaded Stockfish executable.
+    -   `model_path`: The name of the file to save the primary model.
+    -   `backup_model_path`: The name of the file for the backup model.
+    -   Adjust other parameters like `num_games`, `learning_rate`, etc., as needed.
+
+3.  **Run the Training**: Execute the script from your terminal:
+    ```bash
+    python selfchess.py
+    ```
+
+The script will then begin the training process, printing the status of each game and the training loss.

chessy_model.pth

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

chessy_modelt-1.pth

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

selfchess.py

@@ -0,0 +1,213 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+import chess
+import os
+import chess.engine as eng
+import torch.multiprocessing as mp
+from functools import partial
+
+# CONFIGURATION
+CONFIG = {
+    "stockfish_path": "/Users/aaronvattay/Downloads/stockfish/stockfish-macos-m1-apple-silicon",
+    "model_path": "chessy_model.pth",
+    "backup_model_path": "chessy_modelt-1.pth",
+    "device": torch.device("mps"),
+    "learning_rate": 1e-4,
+    "num_games": 3000,
+    "stockfish_time_limit": 1.0,
+    "search_depth": 1,
+}
+
+device = CONFIG["device"]
+
+def board_to_tensor(board):
+    piece_encoding = {
+        'P': 1, 'N': 2, 'B': 3, 'R': 4, 'Q': 5, 'K': 6,
+        'p': 7, 'n': 8, 'b': 9, 'r': 10, 'q': 11, 'k': 12
+    }
+
+    tensor = torch.zeros(64, dtype=torch.long)
+    for square in chess.SQUARES:
+        piece = board.piece_at(square)
+        if piece:
+            tensor[square] = piece_encoding[piece.symbol()]
+        else:
+            tensor[square] = 0
+
+    return tensor.unsqueeze(0)
+
+class NN1(nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.embedding = nn.Embedding(13, 64)
+        self.attention = nn.MultiheadAttention(embed_dim=64, num_heads=16)
+        self.neu = 512
+        self.neurons = nn.Sequential(
+            nn.Linear(4096, self.neu),
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, self.neu), 
+            nn.ReLU(),
+            nn.Linear(self.neu, 64), 
+            nn.ReLU(),
+            nn.Linear(64, 4)
+        )
+
+    def forward(self, x):
+        x = self.embedding(x)
+        x = x.permute(1, 0, 2)
+        attn_output, _ = self.attention(x, x, x)
+        x = attn_output.permute(1, 0, 2).contiguous()
+        x = x.view(x.size(0), -1)
+        x = self.neurons(x)
+        return x
+
+model = NN1().to(device)
+optimizer = optim.Adam(model.parameters(), lr=CONFIG["learning_rate"])
+
+try:
+    model.load_state_dict(torch.load(CONFIG["model_path"], map_location=device))
+    print(f"Loaded model from {CONFIG['model_path']}")
+except FileNotFoundError:
+    try:
+        model.load_state_dict(torch.load(CONFIG["backup_model_path"], map_location=device))
+        print(f"Loaded backup model from {CONFIG['backup_model_path']}")
+    except FileNotFoundError:
+        print("No model file found, starting from scratch.")
+
+model.train()
+criterion = nn.MSELoss()
+engine = eng.SimpleEngine.popen_uci(CONFIG["stockfish_path"])
+lim = eng.Limit(time=CONFIG["stockfish_time_limit"])
+
+def get_evaluation(board):
+    """
+    Returns the evaluation of the board from the perspective of the current player.
+    The model's output is from White's perspective.
+    """
+    tensor = board_to_tensor(board).to(device)
+    with torch.no_grad():
+        evaluation = model(tensor)[0][0].item()
+    
+    if board.turn == chess.WHITE:
+        return evaluation
+    else:
+        return -evaluation
+
+def search(board, depth, alpha, beta):
+    """
+    A negamax search function.
+    """
+    if depth == 0 or board.is_game_over():
+        return get_evaluation(board)
+
+    max_eval = float('-inf')
+    for move in board.legal_moves:
+        board.push(move)
+        eval = -search(board, depth - 1, -beta, -alpha)
+        board.pop()
+        max_eval = max(max_eval, eval)
+        alpha = max(alpha, eval)
+        if alpha >= beta:
+            break
+    return max_eval
+
+
+    
+
+def game_gen(engine_side):
+    data = []
+    mc = 0
+    board = chess.Board()
+    while not board.is_game_over():
+        is_bot_turn = board.turn != engine_side
+        
+        if is_bot_turn:
+            evaling = {}
+            for move in board.legal_moves:
+                board.push(move)
+                evaling[move] = -search(board, depth=CONFIG["search_depth"], alpha=float('-inf'), beta=float('inf'))
+                board.pop()
+            
+            if not evaling:
+                break
+            
+            move = max(evaling, key=evaling.get)
+        else:
+            result = engine.play(board, lim)
+            move = result.move
+
+        if is_bot_turn:
+            data.append({
+                'fen': board.fen(),
+                'move_number': mc,
+            })
+
+        board.push(move)
+        mc += 1
+
+    result = board.result()
+    c = 0
+    if result == '1-0':
+        c = 10.0
+    elif result == '0-1':
+        c = -10.0
+    return data, c, mc
+def train(data, c, mc):
+    for entry in data:
+            tensor = board_to_tensor(chess.Board(entry['fen'])).to(device)
+            target = torch.tensor(c * entry['move_number'] / mc, dtype=torch.float32).to(device)
+            output = model(tensor)[0][0]
+            loss = criterion(output, target)
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+        
+    print(f"Saving model to {CONFIG['model_path']}")
+    torch.save(model.state_dict(), CONFIG["model_path"])
+    return
+def main():
+    num_games = CONFIG['num_games']
+    num_instances = mp.cpu_count()
+    print(f"Saving backup model to {CONFIG['backup_model_path']}")
+    torch.save(model.state_dict(), CONFIG["backup_model_path"])
+    with mp.Pool(processes=num_instances) as pool:
+        play_white = partial(game_gen, engine_side=chess.WHITE)
+        play_black = partial(game_gen, engine_side=chess.BLACK)
+        play_self = partial(game_gen, engine_side=None)
+
+        results = pool.map(play_white, range(num_games // 3))
+        results += pool.map(play_black, range(num_games // 3))
+        results += pool.map(play_self, range(num_games // 3))
+        for batch in results:
+            data, c, mc = batch
+            print(f"Saving backup model to {CONFIG['backup_model_path']}")
+            torch.save(model.state_dict(), CONFIG["backup_model_path"])
+            if data:
+                train(data, c, mc)
+    print("Training complete.")
+if __name__ == "__main__":
+ main()
+ engine.quit()