fewer hints, alternatives search

katrain/core/engine.py

@@ -77,7 +77,9 @@ class KataGoEngine:
             elif not os.path.isfile(cfg):
                 self.katrain.log(i18n._("Kata config not found").format(config=cfg), OUTPUT_ERROR)
                 return  # don't start
-            self.command = shlex.split(f'"{exe}" analysis -model "{model}" -config "{cfg}" -analysis-threads {config["threads"]}')
+            self.command = shlex.split(
+                f'"{exe}" analysis -model "{model}" -config "{cfg}" -analysis-threads {config["threads"]}'
+            )
         self.start()
 
     def start(self):
@@ -224,6 +226,7 @@ class KataGoEngine:
         visits: int = None,
         analyze_fast: bool = False,
         time_limit=True,
+        find_alternatives: bool = False,
         priority: int = 0,
         ownership: Optional[bool] = None,
         next_move: Optional[GameNode] = None,
@@ -241,6 +244,17 @@ class KataGoEngine:
             if analyze_fast and self.config.get("fast_visits"):
                 visits = self.config["fast_visits"]
 
+        if find_alternatives:
+            avoid = [
+                {
+                    "moves": list(analysis_node.analysis["moves"].keys()),
+                    "player": analysis_node.next_player,
+                    "untilDepth": 1,
+                }
+            ]
+        else:
+            avoid = []
+
         size_x, size_y = analysis_node.board_size
         settings = copy.copy(self.override_settings)
         if time_limit:
@@ -254,6 +268,7 @@ class KataGoEngine:
             "analyzeTurns": [len(moves)],
             "maxVisits": visits,
             "komi": analysis_node.komi,
+            "avoidMoves": avoid,
             "boardXSize": size_x,
             "boardYSize": size_y,
             "includeOwnership": ownership and not next_move,

katrain/core/game.py

@@ -369,21 +369,27 @@ class Game:
             visits = engine.config["fast_visits"]
             self.katrain.controls.set_status(i18n._("sweep analysis").format(visits=visits), STATUS_ANALYSIS)
             priority = -1_000_000_000
-        elif mode == "equalize":
+        elif mode in ["equalize", "alternative"]:
             if not cn.analysis_ready:
                 self.katrain.controls.set_status(i18n._("wait-before-equalize"), STATUS_INFO, self.current_node)
                 return
 
             analyze_moves = [Move.from_gtp(gtp, player=cn.next_player) for gtp, _ in cn.analysis["moves"].items()]
-            visits = max(d["visits"] for d in cn.analysis["moves"].values())
-            self.katrain.controls.set_status(i18n._("equalizing analysis").format(visits=visits), STATUS_ANALYSIS)
             priority = -1_000
+            if mode == "alternative":  # also do a quick update on current candidates so it doesn't look too weird
+                self.katrain.controls.set_status("Searching for alternatives", STATUS_ANALYSIS)
+                cn.analyze(engine, priority=-500, time_limit=False, find_alternatives=True)
+                visits = engine.config["fast_visits"]
+            else:
+                visits = max(d["visits"] for d in cn.analysis["moves"].values())
+                self.katrain.controls.set_status(i18n._("equalizing analysis").format(visits=visits), STATUS_ANALYSIS)
         else:
             raise ValueError("Invalid analysis mode")
         for move in analyze_moves:
-            cn.analyze(
-                engine, priority, visits=visits, refine_move=move, time_limit=False
-            )  # explicitly requested so take as long as you need
+            if cn.analysis["moves"].get(move.gtp(), {"visits": 0})["visits"] < visits:
+                cn.analyze(
+                    engine, priority, visits=visits, refine_move=move, time_limit=False
+                )  # explicitly requested so take as long as you need
 
     def analyze_undo(self, node):
         train_config = self.katrain.config("trainer")

katrain/core/game_node.py

@@ -68,15 +68,25 @@ class GameNode(SGFNode):
         )  # analyzed/not undone main, non-teach second, undone last
 
     # various analysis functions
-    def analyze(self, engine, priority=0, visits=None, time_limit=True, refine_move=None, analyze_fast=False):
+    def analyze(
+        self,
+        engine,
+        priority=0,
+        visits=None,
+        time_limit=True,
+        refine_move=None,
+        analyze_fast=False,
+        find_alternatives=False,
+    ):
         engine.request_analysis(
             self,
-            lambda result: self.set_analysis(result, refine_move),
+            lambda result: self.set_analysis(result, refine_move, find_alternatives),
             priority=priority,
             visits=visits,
             analyze_fast=analyze_fast,
             time_limit=time_limit,
             next_move=refine_move,
+            find_alternatives=find_alternatives,
         )
 
     def update_move_analysis(self, move_analysis, move_gtp):
@@ -90,18 +100,22 @@ class GameNode(SGFNode):
         elif cur["visits"] < move_analysis["visits"]:
             cur.update(move_analysis)
 
-    def set_analysis(self, analysis_json, refine_move):
+    def set_analysis(self, analysis_json, refine_move, alternatives_mode):
         if refine_move:
             pvtail = analysis_json["moveInfos"][0]["pv"] if analysis_json["moveInfos"] else []
             self.update_move_analysis(
                 {"pv": [refine_move.gtp()] + pvtail, **analysis_json["rootInfo"]}, refine_move.gtp()
             )
         else:
+            if alternatives_mode:
+                for m in analysis_json["moveInfos"]:
+                    m["order"] += 10  # offset for not making this top
             for move_analysis in analysis_json["moveInfos"]:
                 self.update_move_analysis(move_analysis, move_analysis["move"])
             self.ownership = analysis_json.get("ownership")
             self.policy = analysis_json.get("policy")
-            self.analysis["root"] = analysis_json["rootInfo"]
+            if not alternatives_mode:
+                self.analysis["root"] = analysis_json["rootInfo"]
             if self.parent and self.move:
                 analysis_json["rootInfo"]["pv"] = [self.move.gtp()] + (
                     analysis_json["moveInfos"][0]["pv"] if analysis_json["moveInfos"] else []