Node removal / tree trimming for iterative deepening (time) searches (#63)

* Nodes can be removed from tree

* Node removal wip

* Move to searchTree

* Added removal options

* Node removal functional

* Node removal tests

* Better options

* Updated negamax example for node remove

* docs for node removal

* Removed console log

Author: domw95

examples/negamax_mancala.ts

@@ -6,7 +6,7 @@ const game = new mancala.mancala();
 game.start();
 
 // Perform a search to depth 4
-console.log("Search 1\n");
+console.log("Search 1: Depth 4\n");
 let root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
 let tree = new mx.Negamax(root);
 tree.CreateChildNode = mancala.createChildCallback;
@@ -15,7 +15,7 @@ tree.opts.method = mx.SearchMethod.DEPTH;
 console.log(tree.evaluate());
 
 // Perform a search deepening with alpha-beta pruning to depth 4, printing the result at each depth
-console.log("\nSearch 2\n");
+console.log("\nSearch 2: Deepening with depth callback\n");
 root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
 tree = new mx.Negamax(root);
 tree.CreateChildNode = mancala.createChildCallback;
@@ -27,7 +27,7 @@ tree.depthCallback = (tree, result) => {
 console.log(tree.evaluate());
 
 // Perform a time limited optimal search
-console.log("\nSearch 3\n");
+console.log("\nSearch 3: Optimal Time\n");
 root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
 tree = new mx.Negamax(root);
 tree.CreateChildNode = mancala.createChildCallback;
@@ -37,11 +37,23 @@ tree.opts.method = mx.SearchMethod.TIME;
 console.log(tree.evaluate());
 
 // Select randomly from the best moves
-console.log("\nSearch 4\n");
+console.log("\nSearch 4: Random best selectiom\n");
 root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
 tree = new mx.Negamax(root);
 tree.CreateChildNode = mancala.createChildCallback;
 tree.opts.depth = 2;
 tree.opts.randomBest = true;
 tree.opts.method = mx.SearchMethod.DEPTH;
 console.log(tree.evaluate());
+
+// Remove nodes after each depth when node count >= 1000
+console.log("\nSearch 5: Node removal\n");
+root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
+tree = new mx.Negamax(root);
+tree.CreateChildNode = mancala.createChildCallback;
+tree.opts.depth = 8;
+tree.opts.optimal = true;
+tree.opts.method = mx.SearchMethod.DEEPENING;
+tree.opts.removalMethod = mx.RemovalMethod.COUNT;
+tree.opts.removalCount = 1000;
+console.log(tree.evaluate());

src/index.ts

@@ -1,6 +1,6 @@
 export { Node, NodeAim, NodeType } from "./tree/node.js";
 export { Tree } from "./tree/tree.js";
-export { SearchOpts, SearchExit, PruningType, SearchMethod, SearchResult } from "./tree/search.js";
+export { SearchOpts, SearchExit, PruningType, SearchMethod, SearchResult, RemovalMethod } from "./tree/search.js";
 export { EvaluateNodeFunc, GetMovesFunc, CreateChildNodeFunc, GetScoresFunc } from "./tree/interfaces.js";
 export { Negamax } from "./negamax/negamax.js";
 export { NegamaxResult, NegamaxOpts } from "./negamax/index.js";

src/negamax/index.ts

@@ -28,6 +28,22 @@ import { SearchOpts, SearchResult } from "../tree/search.js";
  * If the value is negative, the one that
  * is more moves away. The opposite holds if the parent is a minimising node.
  *
+ * Does not work with {@link NegamaxOpts.optimal} set to `true`.
+ *
+ * ### Node removal
+ * The {@link NegamaxOpts.removalMethod} option allows for trimming nodes
+ * that aren't needed from the game tree in between successive searches in
+ * {@link SearchMethod.DEEPENING} and {@link SearchMethod.TIME} modes.
+ * This can greatly reduce memory usage and allow
+ * for far deeper searches, but with more computation required.
+ *
+ * There are 3 options:
+ * - {@link RemovalMethod.ALWAYS} = remove nodes after every depth search.
+ * - {@link RemovalMethod.DEPTH} = remove nodes when search depth is
+ * \>\= {@link NegamaxOpts.removalDepth}.
+ * - {@link RemovalMethod.COUNT} = remove nodes when node count is \>\=
+ * {@link NegamaxOpts.removalCount}.
+ *
  * ## Random selections
  * These options can be useful for making the AI less 'robotic'. Neither of them
  * work with {@link NegamaxOpts.pruneByPathLength} or

src/tree/search.ts

@@ -39,6 +39,22 @@ export const enum PruningType {
     ALPHA_BETA,
 }
 
+/**
+ * Control the removal of nodes in between iterative searches when using
+ * {@link SearchMethod.DEEPENING} or {@link SearchMethod.TIME}.
+ *
+ */
+export const enum RemovalMethod {
+    /** Disable node removal */
+    NONE,
+    /** Run node removal at the end of each depth search */
+    ALWAYS,
+    /** Run node removal above a certain depth ({@link SearchOpts.removalDepth}) */
+    DEPTH,
+    /** Run node removal when the node count exceeds a certain value ({@link SearchOpts.removalCount}) */
+    COUNT,
+}
+
 /**
  * Class representing common options for searching a {@link Tree}.
  *
@@ -114,6 +130,21 @@ export class SearchOpts {
      * specific support.
      */
     randomWeight = 0;
+    /**
+     * For removing nodes in between iterative searches.
+     * Allows for deeper searches that would otherwise be memory limited.
+     *
+     * Good for reduced memory usage but takes extra time.
+     */
+    removalMethod = RemovalMethod.NONE;
+    /**
+     * Controls the way removal behaves for {@link RemovalMethod.DEPTH}
+     */
+    removalDepth = 0;
+    /**
+     * Controls the way removal behaves for {@link RemovalMethod.COUNT}
+     */
+    removalCount = 0;
 }
 
 /**

src/tree/searchtree.ts

@@ -1,7 +1,7 @@
 import { Tree } from "./tree.js";
 import { Node, NodeAim } from "./node.js";
 import { EvaluateNodeFunc } from "./interfaces.js";
-import { SearchExit, SearchMethod, SearchOpts, SearchResult } from "./search.js";
+import { RemovalMethod, SearchExit, SearchMethod, SearchOpts, SearchResult } from "./search.js";
 import { bubbleSort, bubbleSortEfficient, defaultSort, SortMethod } from "./sorting.js";
 
 /**
@@ -73,6 +73,17 @@ export class SearchTree<GS, M, D> extends Tree<GS, M, D> {
                 return result;
             } else {
                 prevResult = result;
+                // Check if node removal is enabled
+                if (this.opts.removalMethod != RemovalMethod.NONE) {
+                    if (
+                        this.opts.removalMethod == RemovalMethod.ALWAYS ||
+                        (this.opts.removalMethod == RemovalMethod.DEPTH && activeDepth >= this.opts.removalDepth) ||
+                        (this.opts.removalMethod == RemovalMethod.COUNT && this.nodeCount >= this.opts.removalCount)
+                    ) {
+                        // Remove nodes to minimum required for next search depth
+                        this.removeNodes();
+                    }
+                }
             }
         }
     }
@@ -299,4 +310,53 @@ export class SearchTree<GS, M, D> extends Tree<GS, M, D> {
     getOptimalMoves(): M[] {
         return [...this.optimalMoveGen(this.activeRoot)];
     }
+
+    removeNodes(): number {
+        const removedCount = this.removeNonBestNodes(this.activeRoot, 0, true);
+        this.nodeCount -= removedCount;
+        return removedCount;
+    }
+
+    /**
+     * Recursively go through node and its children removing all
+     * nodes that are not best
+     */
+    protected removeNonBestNodes(node: Node<GS, M, D>, depth: number, keep: boolean): number {
+        // Check if node has 0 children
+        if (node.children.length == 0) {
+            return 0;
+        } else if (keep) {
+            // keep all children, remove grand-children etc
+            let removedCount = 0;
+            // Iterate through children
+            for (let i = 0; i < node.children.length; i++) {
+                const child = node.children[i];
+                removedCount += this.removeNonBestNodes(child, depth + 1, keep && i == 0);
+            }
+            node.descendantCount -= removedCount;
+            return removedCount;
+        } else {
+            // Only keep the best child
+            // Sort current children
+            bubbleSort(node.children, false, false);
+            // Check that best child is correct
+            if (node.children[0] != node.child) {
+                throw new Error("Node best child mismatch");
+            }
+            // Update moves and get number of nodes removed
+            let removedCount = -node.children[0].descendantCount - 1;
+            for (let i = 0; i < node.children.length; i++) {
+                node.moves[i] = node.children[i].move;
+                removedCount += node.children[i].descendantCount + 1;
+            }
+            // Remove the nodes
+            node.children = [node.children[0]];
+            // Recusrive call on remaining child
+            removedCount += this.removeNonBestNodes(node.children[0], depth + 1, false);
+            // Update counts and index of next move to generate from
+            node.descendantCount -= removedCount;
+            node.moveInd = 1;
+            return removedCount;
+        }
+    }
 }

tests/node_removal.ts

@@ -0,0 +1,38 @@
+import * as mancala from "../examples/games/mancala.js";
+import * as mx from "../dist/index.js";
+import { validateDescendants } from "../dist/tree/utils.js";
+
+test("Remove every depth", () => {
+    for (let depth = 1; depth <= 8; depth++) {
+        const game = new mancala.mancala();
+        game.start();
+
+        // Standard search
+        let root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
+        let tree = new mx.Negamax(root);
+        tree.CreateChildNode = mancala.createChildCallback;
+        tree.opts.optimal = true;
+        tree.opts.method = mx.SearchMethod.DEEPENING;
+        tree.opts.depth = depth;
+
+        let result = tree.evaluate();
+        validateDescendants(tree.root);
+        expect(tree.nodeCount).toBe(tree.root.descendantCount + 1);
+
+        // Removal search
+        root = new mx.Node(mx.NodeType.ROOT, game.clone(), 0, 0, mx.NodeAim.MAX, game.moves);
+        tree = new mx.Negamax(root);
+        tree.CreateChildNode = mancala.createChildCallback;
+        tree.opts.optimal = true;
+        tree.opts.method = mx.SearchMethod.DEEPENING;
+        tree.opts.depth = depth;
+        tree.opts.removalMethod = mx.RemovalMethod.ALWAYS;
+
+        let result2 = tree.evaluate();
+
+        expect(result2.move).toBe(result.move);
+        expect(result2.value).toBe(result.value);
+        validateDescendants(tree.root);
+        expect(tree.nodeCount).toBe(tree.root.descendantCount + 1);
+    }
+});