Moved sunfish_nnue.py to make it testable by quick_tests

Author: tahle

nnue/sunfish_nnue_color.py renamed to sunfish_nnue.py

@@ -7,6 +7,8 @@
 from functools import partial
 print = partial(print, flush=True)
 
+version = 'sunfish nnue'
+
 ###############################################################################
 # A small neural network to evaluate positions
 ###############################################################################
@@ -105,11 +107,13 @@ def features(board):
 }
 
 # Constants for tuning search
-#EVAL_ROUGHNESS = 13
-#QS_LIMIT = 200
-#QS_CAPTURE, QS_SINGLE, QS_DOUBLE = range(3)
-#QS_TYPE = QS_CAPTURE
-#debug = False
+EVAL_ROUGHNESS = 13
+
+# minifier-hide start
+opt_ranges = dict(
+    EVAL_ROUGHNESS = (0, 50),
+)
+# minifier-hide end
 
 
 ###############################################################################
@@ -258,11 +262,7 @@ def is_capture(self, move):
         # to last forever (until python stackoverflows.) Thus we need to either
         # dampen the eval function, or like here, reduce QS search to captures
         # only. Well, captures plus promotions.
-        return (
-            self.board[move.j] != "."
-            or abs(move.j - self.kp) < 2
-            or self.board[move.i] == "P" and (A8 <= move.j <= H8 or move.j == self.ep)
-        )
+        return self.board[move.j] != "." or abs(move.j - self.kp) < 2 or move.prom
 
     def compute_value(self):
         #relu6 = lambda x: np.minimum(np.maximum(x, 0), 6)
@@ -288,7 +288,6 @@ def hash(self):
         # return (self.wf + self.bf).sum()
         # return self._replace(wf=0, bf=0)
 
-
 ###############################################################################
 # Search logic
 ###############################################################################
@@ -359,11 +358,7 @@ def bound(self, pos, gamma, depth, root=True):
         def moves():
             # First try not moving at all. We only do this if there is at least one major
             # piece left on the board, since otherwise zugzwangs are too dangerous.
-            # It doesn't make sense to use this function for depth 2, since it will take us
-            # to depth max(0, d-2)=0, meaning reducing by two. So it's not actually the
-            # opponents turn. This seems like it should be a major bug?
-            #if (depth >= 3 or depth == 1) and not root and any(c in pos.board for c in "NBRQ"):
-            if depth >= 3 and not root:
+            if depth > 2 and not root and any(c in pos.board for c in "NBRQ"):
                 yield None, -self.bound(pos.rotate(nullmove=True), 1-gamma, depth-3, False)
             # For QSearch we have a different kind of null-move, namely we can just stop
             # and not capture anything else.
@@ -387,9 +382,8 @@ def mvv_lva(move):
                 return score
 
             killer = self.tp_move.get(pos.hash())
-            if killer:
-                if depth > 0 or pos.is_capture(killer):
-                    yield killer, -self.bound(pos.move(killer), 1-gamma, depth-1, False)
+            if killer and (depth > 0 or pos.is_capture(killer)):
+                yield killer, -self.bound(pos.move(killer), 1-gamma, depth-1, False)
 
             # Then all the other moves
             # moves = [(move, pos.move(move)) for move in pos.gen_moves()]
@@ -430,24 +424,12 @@ def mvv_lva(move):
                     self.tp_move[pos.hash()] = move
                 break
 
-        # Stalemate checking is a bit tricky: Say we failed low, because
-        # we can't (legally) move and so the (real) score is -infty.
-        # At the next depth we are allowed to just return r, -infty <= r < gamma,
-        # which is normally fine.
-        # However, what if gamma = -10 and we don't have any legal moves?
-        # Then the score is actaully a draw and we should fail high!
-        # Thus, if best < gamma and best < 0 we need to double check what we are doing.
-        # This doesn't prevent sunfish from making a move that results in stalemate,
-        # but only if depth == 1, so that's probably fair enough.
-        # (Btw, at depth 1 we can also mate without realizing.)
-        if best < gamma and best < 0 and depth > 0:
-            # A position is dead if the curent player has a move that captures the king
-            is_dead = lambda pos: any(
-                pos.move(m).score <= -MATE_LOWER for m in pos.gen_moves()
-            )
-            if all(is_dead(pos.move(m)) for m in pos.gen_moves()):
-                in_check = is_dead(pos.rotate(nullmove=True))
-                best = -MATE_UPPER if in_check else 0
+        # Stalemate checking
+        if depth > 0 and best == -MATE_UPPER:
+            flipped = pos.rotate(nullmove=True)
+            # Hopefully this is already in the TT because of null-move
+            in_check = self.bound(flipped, MATE_UPPER, 0) == MATE_UPPER
+            best = -MATE_LOWER if in_check else 0
 
         # Table part 2
         self.tp_score[pos.hash(), depth, root] = (
@@ -477,7 +459,7 @@ def search(self, history):
             # 'while lower != upper' would work, but play tests show a margin of 20 plays
             # better.
             lower, upper = -MATE_UPPER, MATE_UPPER
-            while lower < upper - 1:
+            while lower < upper - EVAL_ROUGHNESS:
                 score = self.bound(pos, gamma, depth)
                 if score >= gamma:
                     lower = score
@@ -504,11 +486,20 @@ def render(i):
 
 wf, bf = features(initial)
 hist = [Position(initial, 0, wf, bf, (True, True), (True, True), 0, 0)]
+
+
+# minifier-hide start
+import sys, tools.uci
+tools.uci.run(sys.modules[__name__], hist[-1])
+sys.exit()
+# minifier-hide end
+
+
 searcher = Searcher()
 while True:
     args = input().split()
     if args[0] == "uci":
-        print(f"id name sunfish nnue")
+        print(f"id name {version}")
         print("uciok")
 
     elif args[0] == "isready":

tools/tester.py

@@ -266,7 +266,7 @@ async def run(cls, engine, args):
                         continue
                     score = info["score"]
                     if score.is_mate() or score.relative.cp > 10000:
-                        if info["pv"]:
+                        if "pv" in info and info["pv"]:
                             b = board.copy()
                             for move in info["pv"]:
                                 b.push(move)

tools/uci.py

@@ -53,10 +53,12 @@ def go_loop(searcher, hist, stop_event, max_movetime=0, max_depth=0, debug=False
             fields["score cp"] = f"{score} upperbound"
         print("info", " ".join(f"{k} {v}" for k, v in fields.items()))
 
-        if best_move and elapsed > max_movetime * 2 / 3:
-            break
-        if stop_event.is_set():
-            break
+        # We may not have a move yet at depth = 1
+        if depth > 1:
+            if elapsed > max_movetime * 2 / 3:
+                break
+            if stop_event.is_set():
+                break
 
     my_pv = pv(searcher, hist[-1], include_scores=False)
     print("bestmove", my_pv[0] if my_pv else "(none)")
@@ -134,12 +136,11 @@ def _perft_count(pos, depth):
     return res
 
 
-def run(sunfish_module):
+def run(sunfish_module, startpos):
     global sunfish
     sunfish = sunfish_module
 
     debug = False
-    startpos = sunfish.Position(sunfish.initial, 0, (True, True), (True, True), 0, 0)
     hist = [startpos]
     searcher = sunfish.Searcher()
 
@@ -208,7 +209,11 @@ def run(sunfish_module):
                     wc = ("Q" in castling, "K" in castling)
                     bc = ("k" in castling, "q" in castling)
                     ep = sunfish.parse(enpas) if enpas != "-" else 0
-                    pos = sunfish.Position(board, 0, wc, bc, ep, 0)
+                    if hasattr(sunfish, 'features'):
+                        wf, bf = sunfish.features(board)
+                        pos = sunfish.Position(board, 0, wf, bf, wc, bc, ep, 0)
+                    else:
+                        pos = sunfish.Position(board, 0, wc, bc, ep, 0)
                     hist = [pos] if color == "w" else [pos, pos.rotate()]
                     if len(args) > 8 and args[8] == "moves":
                         for move in args[9:]:
@@ -288,8 +293,9 @@ def get_color(pos):
 def can_kill_king(pos):
     # If we just checked for opponent moves capturing the king, we would miss
     # captures in case of illegal castling.
-    MATE_LOWER = 60_000 - 10 * 929
-    return any(pos.value(m) >= MATE_LOWER for m in pos.gen_moves())
+    #MATE_LOWER = 60_000 - 10 * 929
+    #return any(pos.value(m) >= MATE_LOWER for m in pos.gen_moves())
+    return any(pos.board[m.j] == 'k' or abs(m.j - pos.kp) < 2 for m in pos.gen_moves())
 
 
 def pv(searcher, pos, include_scores=True, include_loop=False):
@@ -300,7 +306,9 @@ def pv(searcher, pos, include_scores=True, include_loop=False):
     if include_scores:
         res.append(str(pos.score))
     while True:
-        if hasattr(searcher, "tp_move"):
+        if hasattr(pos, "wf"):
+            move = searcher.tp_move.get(pos.hash())
+        elif hasattr(searcher, "tp_move"):
             move = searcher.tp_move.get(pos)
         elif hasattr(searcher, "tt_new"):
             move = searcher.tt_new[0][pos, True].move
@@ -309,11 +317,20 @@ def pv(searcher, pos, include_scores=True, include_loop=False):
             break
         res.append(render_move(move, get_color(pos) == WHITE))
         pos, color = pos.move(move), 1 - color
-        if pos in seen_pos:
-            if include_loop:
-                res.append("loop")
-            break
-        seen_pos.add(pos)
+
+        if hasattr(pos, "wf"):
+            if pos.hash() in seen_pos:
+                if include_loop:
+                    res.append("loop")
+                break
+            seen_pos.add(pos.hash())
+        else:
+            if pos in seen_pos:
+                if include_loop:
+                    res.append("loop")
+                break
+            seen_pos.add(pos)
+
         if include_scores:
             res.append(str(pos.score if color == origc else -pos.score))
     return res