Update README.md

README.md

@@ -1,3 +1,81 @@
----
-license: cc-by-nc-4.0
----
+---
+license: cc-by-nc-4.0
+---
+
+Model Description:
+
+GChess model is a powerful deep neural network designed specifically for the game of chess. Its architecture is heavily inspired by the principles of AlphaZero, utilizing a single neural network to simultaneously predict the optimal move and evaluate the position.
+
+Architecture Details:
+
+The core of the network is a Deep Residual Network (ResNet), a structure well-suited for processing the spatial data of an 8x8 chessboard.
+
+Torso: 
+
+The network employs a robust torso composed of 20 Residual Blocks. Each block contains convolutional layers with skip connections, allowing for the effective learning of deep, hierarchical features and maintaining stable training.
+
+Feature Processing: 
+
+The entire network processes data using a high number of channels, specifically 512 filters in its main convolutional layers.
+
+Input Representation: 
+
+The current board state and history are encoded into a multi-plane tensor with 128 input channels, which typically includes information about piece locations, the player to move, castling rights, and repetition history, a common input format for state-of-the-art chess AI.
+
+Dual Output Heads: 
+
+The shared ResNet torso branches into two specialized heads:
+
+Policy Head (p_logits): 
+
+Predicts a probability distribution over the 4672 possible moves (actions) that can be taken. This output is crucial for guiding the Monte Carlo Tree Search (MCTS).
+
+Value Head (v): 
+
+Outputs a single scalar value, typically between -1.0 (Black is winning) and +1.0 (White is winning). This score represents the network's prediction of the final game outcome from the current position.
+
+Training:
+
+The model is trained on small dataset from high-quality PGN of games. The model is trained on 50.000 games during 50 hours on RTX4060. This model acctually is evaluate around 1000 Elo. Training uses the PyTorch framework with advanced optimization techniques, including a OneCycleLR learning rate scheduler for accelerated convergence and a large batch size of 1024.
+
+Usage:
+
+```
+# Define Input State (FEN)
+# Example: The initial position of a game
+fen = "rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"
+board = chess.Board(fen)
+
+# Preprocess Input
+# This function converts the board object into the 128-channel input tensor expected by the model
+# (Implementation of board_to_tensor is required separately)
+input_tensor = board_to_tensor(board, history_depth=8).unsqueeze(0).to(DEVICE)
+
+# Run Inference
+with torch.no_grad():
+    # policy_logits is a tensor of size 4672, value_output is a scalar tensor
+    policy_logits, value_output = model(input_tensor)
+
+# Post-process Output
+# Convert logits to a probability distribution over all possible moves (actions)
+policy_probabilities = F.softmax(policy_logits, dim=1).squeeze(0)
+
+# Find the move with the highest predicted probability
+best_action_index = torch.argmax(policy_probabilities).item()
+best_move = ACTION_TO_MOVE[best_action_index] # e.g., 'e2e4'
+best_probability = policy_probabilities[best_action_index].item()
+
+# Extract the value prediction
+expected_value = value_output.item()
+
+# Print Results
+print(f"FEN: {fen}")
+print(f"--- Model Prediction ---")
+print(f"Predicted Best Move: {best_move}")
+print(f"Move Probability: {best_probability:.4f}")
+print(f"Position Evaluation (Value): {expected_value:.4f}")
+print("\nInterpretation: Value close to +1.0 means White is winning, -1.0 means Black is winning.")
+
+```
+
+Developed by PENEAUX Benjamin