My first successful attempt at using neural networks to create a "strong" chess engine that can beat me!

You can download the precompiled executables for windows or linux here. Note that the compiled version does not come with a GUI. You have to connect it with a chess GUI such as Arena, Banksia or Cutechess. Make sure to set working directory to the directory of the engine executable as the engine reads off its weights from there.

You can play the latest release of Nectar online at lichess here. Note that it will not always be online.

• Fail-soft negamax search
• Aspiration window search
• Principal variation search (triple PVS)
• Quiescence search
• Efficient updates (UE)
• Tempo

• Beta pruning
• Reverse futility pruning
• Null move pruning
• Futility pruning
• QSearch standing pat pruning
• QSearch delta pruning
• Transposition table cutoffs
• Mate Distancing pruning
• Late move pruning

• Late moves reduction (Log formula)
• Check extensions
• Internal iterative reductions

• Transposition table ordering
• MVV-LVA ordering
• Killer moves (1 move per ply)
• History heuristic
  • History gravity
  • History malus (penalty)

Trained with Nano

The chess positions are encoded into a 768-element array like this, in white's POV

def encode_fen(fen):
 # Define the index mapping for each piece type in the 384-element array
 piece_to_index = {
 'P': 0, 'p': 384, # Pawns
 'N': 64, 'n': 448, # Knights
 'B': 128, 'b': 512, # Bishops
 'R': 192, 'r': 576, # Rooks
 'Q': 256, 'q': 640, # Queens
 'K': 320, 'k': 704 # Kings
 }
 
 # Initialize the 384-element array
 board_array = np.zeros(768, dtype=np.int8) 
 
 # Split the FEN string to get the board layout
 board, _ = fen.split(' ', 1)
 
 # Split the board part into rows
 rows = board.split('/')
 
 for row_idx, row in enumerate(rows):
 col_idx = 0
 for char in row:
 if char.isdigit():
 # Empty squares, advance the column index
 col_idx += int(char)
 else:
 # Piece, determine its position in the 384-element array
 piece_index = piece_to_index[char]
 board_position = row_idx * 8 + col_idx
 board_array[piece_index + board_position] = 1
 col_idx += 1
 
 return board_array

A 768->N->1 network in white's POV

model = Sequential([
 Dense(16, input_shape=(input_shape,)),
 Lambda(SCReLU),
 Dense(1, activation='sigmoid')
])

I used the SCReLU activation function for hidden layers to allow for non-linearity (11.5 +/- 9.2)

def SCReLU(x):
 return tf.square(tf.clip_by_value(x, 0, 1))

• V0.1.4~ish and after : Self-gen data
• <= V0.1.2 : The data I used for my training is stash data parsed by cj5716

• Sebastian Lague (For the whole chess framework)
• Ciekce [Stormphrax] (For teaching me how NNUE works and the NORMAL way to do stuff and AdamW)
• mid_88 [Spaghet] (Explaining how to load binary weights)
• cj5716 [Alexandria] (Parsing the stash data)
• Gediminas (For the UCI interface for Sebastian Lagues's framework)
• gabe [Obsidian] (NNUE explanations)
• jw [Obsidian] (NNUE explanations)
• Matt [Heimdall] (Nicely documented code, based some params on it)
• ChatGPT (Code optimisations)
• And a lot more people in the Engine Programming Discord and Stockfish Discord

• (削除) Change input layer to 728 instead of 384 (削除ここまで)
• Do perspective networks
• (削除) Do the UE of NNUE (削除ここまで)