algorhino-anemone 0.1.1__py3-none-any.whl

anemone/tree_manager/algorithm_node_tree_manager.py

@@ -0,0 +1,246 @@
+"""
+Defining the AlgorithmNodeTreeManager class
+"""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any
+
+from valanga import BranchKey
+
+from anemone import trees
+from anemone.indices.index_manager import (
+    NodeExplorationIndexManager,
+)
+from anemone.indices.index_manager.node_exploration_manager import (
+    update_all_indices,
+)
+from anemone.node_evaluation.node_direct_evaluation import (
+    EvaluationQueries,
+    NodeDirectEvaluator,
+)
+from anemone.node_factory.algorithm_node_factory import AlgorithmNodeFactory
+from anemone.nodes.algorithm_node.algorithm_node import (
+    AlgorithmNode,
+)
+from anemone.updates.algorithm_node_updater import AlgorithmNodeUpdater
+from anemone.updates.updates_file import (
+    UpdateInstructionsFromOneNode,
+    UpdateInstructionsTowardsMultipleNodes,
+    UpdateInstructionsTowardsOneParentNode,
+)
+
+from .tree_expander import TreeExpansion, TreeExpansions, record_tree_expansion
+from .tree_manager import TreeManager
+
+# todo should we use a discount? and discounted per round reward?
+# todo maybe convenient to seperate this object into openner updater and dsiplayer
+# todo have the reward with a discount
+# DISCOUNT = 1/.99999
+if TYPE_CHECKING:
+    from anemone import node_selector as node_sel
+
+
+@dataclass
+class AlgorithmNodeTreeManager[NodeT: AlgorithmNode[Any] = AlgorithmNode[Any]]:
+    """
+    This class that and manages a tree by opening new nodes and updating the values and indexes on the nodes.
+    It wraps around the Tree Manager class as it has a tree_manager as member and adds functionality as this handles
+    trees with nodes that are of the class AlgorithmNode (managing the value for instance)
+    """
+
+    tree_manager: TreeManager[NodeT]
+    algorithm_tree_node_factory: AlgorithmNodeFactory
+
+    algorithm_node_updater: AlgorithmNodeUpdater
+    evaluation_queries: EvaluationQueries
+    node_evaluator: NodeDirectEvaluator | None
+    index_manager: NodeExplorationIndexManager
+
+    def open_tree_expansion_from_branch(
+        self,
+        tree: trees.Tree[NodeT],
+        parent_node: NodeT,
+        branch: BranchKey,
+    ) -> TreeExpansion[NodeT]:
+        """
+
+        Args:
+            tree: the tree to open
+            parent_node: the node to open
+            move: to move to open with
+
+        Returns: the tree expansions
+
+        """
+
+        tree_expansion: TreeExpansion[NodeT]
+        tree_expansion = self.tree_manager.open_tree_expansion_from_branch(
+            tree=tree, parent_node=parent_node, branch=branch
+        )
+
+        parent_node.tree_evaluation.branches_not_over.append(
+            branch
+        )  # default action checks for over event are performed later
+
+        return tree_expansion
+
+    def open_instructions(
+        self,
+        tree: trees.Tree[NodeT],
+        opening_instructions: "node_sel.OpeningInstructions[NodeT]",
+    ) -> TreeExpansions[NodeT]:
+        """
+
+        Args:
+            tree: the tree object to open
+            opening_instructions: the opening instructions
+
+        Returns: the expansions that have been performed
+
+        """
+
+        # place to store the tree expansion logs generated by the openings
+        tree_expansions: TreeExpansions[NodeT] = TreeExpansions()
+
+        opening_instruction: node_sel.OpeningInstruction[NodeT]
+        tree_expansion: TreeExpansion[NodeT]
+        for opening_instruction in opening_instructions.values():
+            # open
+            assert isinstance(opening_instruction.node_to_open, AlgorithmNode)
+            tree_expansion = self.open_tree_expansion_from_branch(
+                tree=tree,
+                parent_node=opening_instruction.node_to_open,
+                branch=opening_instruction.branch,
+            )
+
+            print("opened", tree_expansion)
+
+            record_tree_expansion(
+                tree=tree,
+                tree_expansions=tree_expansions,
+                tree_expansion=tree_expansion,
+            )
+
+        assert self.node_evaluator is not None
+        for tree_expansion in tree_expansions.expansions_with_node_creation:
+            # TODO give the tree expansion to the function directly
+            assert isinstance(tree_expansion.child_node, AlgorithmNode)
+            self.node_evaluator.add_evaluation_query(
+                node=tree_expansion.child_node,
+                evaluation_queries=self.evaluation_queries,
+            )
+
+        self.node_evaluator.evaluate_all_queried_nodes(
+            evaluation_queries=self.evaluation_queries
+        )
+
+        return tree_expansions
+
+    def update_indices(self, tree: trees.Tree[NodeT]) -> None:
+        """
+        Updates the indices of the nodes in the given tree.
+
+        Args:
+            tree (ValueTree): The tree whose indices need to be updated.
+
+        Returns:
+            None
+        """
+        update_all_indices(index_manager=self.index_manager, tree=tree)
+
+    def update_backward(self, tree_expansions: TreeExpansions[NodeT]) -> None:
+        """
+        Updates the algorithm node tree in a backward manner based on the given tree expansions.
+
+        Args:
+            tree_expansions (TreeExpansions): The tree expansions used to update the algorithm node tree.
+
+        Returns:
+            None
+        """
+        update_instructions_batch: UpdateInstructionsTowardsMultipleNodes[NodeT]
+        update_instructions_batch = (
+            self.algorithm_node_updater.generate_update_instructions(
+                tree_expansions=tree_expansions
+            )
+        )
+
+        while update_instructions_batch:
+            node_to_update: NodeT
+            update_instructions: UpdateInstructionsTowardsOneParentNode
+            node_to_update, update_instructions = update_instructions_batch.pop_item()
+            extra_update_instructions_batch: UpdateInstructionsTowardsMultipleNodes[
+                NodeT
+            ]
+            extra_update_instructions_batch = self.update_node(
+                node_to_update=node_to_update, update_instructions=update_instructions
+            )
+            # merge
+            while extra_update_instructions_batch.one_node_instructions:
+                parent_node_to_update: NodeT
+                update: UpdateInstructionsTowardsOneParentNode
+                parent_node_to_update, update = (
+                    extra_update_instructions_batch.pop_item()
+                )
+                update_instructions_batch.add_updates_towards_one_parent_node(
+                    parent_node=parent_node_to_update, update_from_child_node=update
+                )
+
+    def update_node(
+        self,
+        node_to_update: NodeT,
+        update_instructions: UpdateInstructionsTowardsOneParentNode,
+    ) -> UpdateInstructionsTowardsMultipleNodes[NodeT]:
+        """
+        Updates the given node with the provided update instructions.
+
+        Args:
+            node_to_update (AlgorithmNode): The node to be updated.
+            update_instructions (UpdateInstructions): The instructions for updating the node.
+
+        Returns:
+            UpdateInstructionsBatch: A batch of update instructions for the parent nodes of the updated node.
+        """
+
+        # UPDATES
+        new_update_instructions: UpdateInstructionsFromOneNode = (
+            self.algorithm_node_updater.perform_updates(
+                node_to_update=node_to_update, update_instructions=update_instructions
+            )
+        )
+
+        update_instructions_batch: UpdateInstructionsTowardsMultipleNodes[NodeT]
+        update_instructions_batch = UpdateInstructionsTowardsMultipleNodes()
+        parent_node: NodeT
+        branch_from_parent: BranchKey
+        for parent_node, branch_from_parent in node_to_update.parent_nodes.items():
+            # there was a test for emptiness here of new updates instructions remove this comment if no bug appear
+            assert parent_node not in update_instructions_batch.one_node_instructions
+            update_instructions_batch.add_update_from_one_child_node(
+                update_from_child_node=new_update_instructions,
+                parent_node=parent_node,
+                branch_from_parent=branch_from_parent,
+            )
+
+        return update_instructions_batch
+
+    def print_some_stats(self, tree: trees.Tree[NodeT]) -> None:
+        """
+        Prints statistics about the given tree.
+
+        Args:
+            tree (ValueTree): The tree to print statistics for.
+
+        Returns:
+            None
+        """
+        self.tree_manager.print_some_stats(tree=tree)
+
+    def print_best_line(self, tree: trees.Tree[NodeT]) -> None:
+        """
+        Prints the best line of moves based on the tree evaluation of the tree.
+
+        Args:
+            tree (ValueTree): The tree containing the moves and their minmax evaluations.
+        """
+        tree.root_node.tree_evaluation.print_best_line()

anemone/tree_manager/factory.py

@@ -0,0 +1,77 @@
+"""
+This module provides a factory function for creating an AlgorithmNodeTreeManager object.
+
+The AlgorithmNodeTreeManager is responsible for managing the tree structure of algorithm nodes,
+performing updates on the nodes, and handling evaluation queries.
+
+"""
+
+from typing import Any
+
+from anemone import updates as upda
+from anemone.indices.index_manager import (
+    NodeExplorationIndexManager,
+    create_exploration_index_manager,
+)
+from anemone.indices.node_indices.index_types import (
+    IndexComputationType,
+)
+from anemone.node_evaluation.node_direct_evaluation import (
+    EvaluationQueries,
+    NodeDirectEvaluator,
+)
+from anemone.node_factory import (
+    AlgorithmNodeFactory,
+)
+from anemone.nodes.algorithm_node.algorithm_node import AlgorithmNode
+from anemone.state_transition import ValangaStateTransition
+from anemone.updates.index_updater import IndexUpdater
+
+from .algorithm_node_tree_manager import AlgorithmNodeTreeManager
+from .tree_manager import TreeManager
+
+
+def create_algorithm_node_tree_manager(
+    node_direct_evaluator: NodeDirectEvaluator[Any] | None,
+    algorithm_node_factory: AlgorithmNodeFactory[Any],
+    index_computation: IndexComputationType | None,
+    index_updater: IndexUpdater | None,
+) -> AlgorithmNodeTreeManager:
+    """
+    Create an AlgorithmNodeTreeManager object.
+
+    Args:
+        node_evaluator: The NodeEvaluator object used for evaluating nodes in the tree.
+        algorithm_node_factory: The AlgorithmNodeFactory object used for creating algorithm nodes.
+        index_computation: The type of index computation to be used.
+        index_updater: The IndexUpdater object used for updating the indices.
+
+    Returns:
+        An AlgorithmNodeTreeManager object.
+
+    """
+    tree_manager: TreeManager[AlgorithmNode] = TreeManager[AlgorithmNode](
+        node_factory=algorithm_node_factory,
+        transition=ValangaStateTransition(),
+    )
+
+    algorithm_node_updater: upda.AlgorithmNodeUpdater = (
+        upda.create_algorithm_node_updater(index_updater=index_updater)
+    )
+
+    evaluation_queries: EvaluationQueries = EvaluationQueries()
+
+    exploration_index_manager: NodeExplorationIndexManager = (
+        create_exploration_index_manager(index_computation=index_computation)
+    )
+
+    algorithm_node_tree_manager: AlgorithmNodeTreeManager = AlgorithmNodeTreeManager(
+        node_evaluator=node_direct_evaluator,
+        tree_manager=tree_manager,
+        algorithm_node_updater=algorithm_node_updater,
+        algorithm_tree_node_factory=algorithm_node_factory,
+        evaluation_queries=evaluation_queries,
+        index_manager=exploration_index_manager,
+    )
+
+    return algorithm_node_tree_manager

anemone/tree_manager/tree_expander.py

@@ -0,0 +1,122 @@
+"""
+Tree expansion representations for managing game trees.
+"""
+
+from dataclasses import dataclass, field
+from typing import Any, Iterator, TypeVar
+
+from valanga import BranchKey, StateModifications
+
+from anemone import nodes as node
+from anemone import trees
+
+NodeT = TypeVar("NodeT", bound=node.ITreeNode[Any])
+
+
+@dataclass(slots=True)
+class TreeExpansion[NodeT: node.ITreeNode[Any] = node.ITreeNode[Any]]:
+    """
+    Represents an expansion of a tree in a chess game.
+
+    Attributes:
+        child_node (NodeT): The child node created during the expansion.
+        parent_node (node.ITreeNode | None): The parent node of the child node. None if it's the root node.
+        board_modifications (board_mod.BoardModification | None): The modifications made to the chess board during the expansion.
+        creation_child_node (bool): Indicates whether the child node was created during the expansion.
+        move (chess.Move): the move from parent to child node.
+    """
+
+    child_node: NodeT
+    parent_node: NodeT | None
+    state_modifications: StateModifications | None
+    creation_child_node: bool
+    branch_key: BranchKey | None
+
+    def __repr__(self) -> str:
+        """Return a debug representation of the tree expansion."""
+        return (
+            f"child_node{self.child_node.id} | "
+            f"parent_node{self.parent_node.id if self.parent_node is not None else None} | "
+            f"creation_child_node{self.creation_child_node}"
+        )
+
+
+def record_tree_expansion(
+    *,
+    tree: trees.Tree[NodeT],
+    tree_expansions: "TreeExpansions[NodeT]",
+    tree_expansion: TreeExpansion[NodeT],
+) -> None:
+    """Apply one TreeExpansion's bookkeeping to a tree + its log."""
+
+    if tree_expansion.creation_child_node:
+        tree.nodes_count += 1
+        tree.descendants.add_descendant(tree_expansion.child_node)
+
+    tree_expansions.add(tree_expansion=tree_expansion)
+
+
+def _new_expansions_list() -> list[TreeExpansion[Any]]:
+    """Return a new list for tree expansions."""
+    return []
+
+
+@dataclass(slots=True)
+class TreeExpansions[NodeT: node.ITreeNode[Any] = node.ITreeNode[Any]]:
+    """
+    Represents a collection of tree expansions in a chess game.
+
+    Attributes:
+        expansions_with_node_creation (List[TreeExpansion]): List of expansions where child nodes were created.
+        expansions_without_node_creation (List[TreeExpansion]): List of expansions where child nodes were not created.
+    """
+
+    expansions_with_node_creation: list[TreeExpansion[NodeT]] = field(
+        default_factory=_new_expansions_list
+    )
+    expansions_without_node_creation: list[TreeExpansion[NodeT]] = field(
+        default_factory=_new_expansions_list
+    )
+
+    def __iter__(self) -> Iterator[TreeExpansion[NodeT]]:
+        """Iterate over all recorded expansions."""
+        return iter(
+            self.expansions_with_node_creation + self.expansions_without_node_creation
+        )
+
+    def add(self, tree_expansion: TreeExpansion[NodeT]) -> None:
+        """
+        Adds a tree expansion to the collection.
+
+        Args:
+            tree_expansion (TreeExpansion): The tree expansion to add.
+        """
+        if tree_expansion.creation_child_node:
+            self.add_creation(tree_expansion=tree_expansion)
+        else:
+            self.add_connection(tree_expansion=tree_expansion)
+
+    def add_creation(self, tree_expansion: TreeExpansion[NodeT]) -> None:
+        """
+        Adds a tree expansion with a created child node to the collection.
+
+        Args:
+            tree_expansion (TreeExpansion): The tree expansion to add.
+        """
+        self.expansions_with_node_creation.append(tree_expansion)
+
+    def add_connection(self, tree_expansion: TreeExpansion[NodeT]) -> None:
+        """
+        Adds a tree expansion without a created child node to the collection.
+
+        Args:
+            tree_expansion (TreeExpansion): The tree expansion to add.
+        """
+        self.expansions_without_node_creation.append(tree_expansion)
+
+    def __str__(self) -> str:
+        """Return a string summary of recorded expansions."""
+        return (
+            f"expansions_with_node_creation {self.expansions_with_node_creation} \n"
+            f"expansions_without_node_creation{self.expansions_without_node_creation}"
+        )

anemone/tree_manager/tree_manager.py

@@ -0,0 +1,254 @@
+"""
+This module contains the TreeManager class, which is responsible for managing a tree by opening new nodes and updating the values and indexes on the nodes.
+"""
+
+from typing import TYPE_CHECKING, Any
+
+from valanga import BranchKey, State, StateModifications, StateTag
+
+from anemone import nodes as node
+from anemone import trees
+from anemone.node_factory.base import (
+    NodeFactory,
+)
+from anemone.node_selector.opening_instructions import (
+    OpeningInstruction,
+    OpeningInstructions,
+)
+from anemone.state_transition import StateTransition
+from anemone.tree_manager.tree_expander import (
+    TreeExpansion,
+    TreeExpansions,
+    record_tree_expansion,
+)
+
+if TYPE_CHECKING:
+    from anemone.basics import TreeDepth
+
+# todo should we use a discount? and discounted per round reward?
+# todo maybe convenient to seperate this object into openner updater and dsiplayer
+# todo have the reward with a discount
+# DISCOUNT = 1/.99999
+
+
+class TreeManager[
+    FamilyT: node.ITreeNode[Any] = node.ITreeNode[Any],
+]:
+    """
+    This class manages a tree by opening new nodes.This is the core one only responsible for creating core TreeNodes
+    """
+
+    node_factory: NodeFactory[FamilyT]
+    transition: StateTransition[State]
+
+    def __init__(
+        self,
+        node_factory: NodeFactory[FamilyT],
+        transition: StateTransition[State],
+    ) -> None:
+        """Initialize the tree manager with a node factory and transition."""
+        self.node_factory = node_factory
+        self.transition = transition
+
+    def open_tree_expansion_from_branch(
+        self,
+        tree: trees.Tree[FamilyT],
+        parent_node: FamilyT,
+        branch: BranchKey,
+    ) -> TreeExpansion[FamilyT]:
+        """
+        Opening a Node that contains a board following a move.
+
+        Args:
+            tree: The tree object.
+            parent_node: The parent node that we want to expand.
+            move: The move to play to expand the node.
+
+        Returns:
+            The tree expansion object.
+        """
+        # The parent board is copied, we only copy the stack (history of previous board) if the depth is smaller than 2
+        # Having the stack information allows checking for draw by repetition.
+        # To limit computation we limit copying it all the time. The resulting policy will only be aware of immediate
+        # risk of draw by repetition
+        copy_stack: bool = tree.node_depth(parent_node) < 2
+        parent_state: State = parent_node.state
+        state: State = self.transition.copy_for_expansion(
+            parent_state,
+            copy_stack=copy_stack,
+        )
+
+        # The move is played. The state is now advanced.
+        state, modifications = self.transition.step(state, branch_key=branch)
+
+        return self.open_tree_expansion_from_state(
+            tree=tree,
+            parent_node=parent_node,
+            state=state,
+            modifications=modifications,
+            branch=branch,
+        )
+
+    def open_tree_expansion_from_state(
+        self,
+        tree: trees.Tree[FamilyT],
+        parent_node: FamilyT,
+        state: State,
+        modifications: StateModifications | None,
+        branch: BranchKey,
+    ) -> TreeExpansion[FamilyT]:
+        """
+        Opening a Node that contains a board given the modifications.
+        Checks if the new node needs to be created or if the new_board already existed in the tree
+         (was reached from a different serie of move)
+
+        Args:
+            tree: The tree object.
+            parent_node: The parent node that we want to expand.
+            board: The board object that is a move forward compared to the board in the parent node
+            modifications: The board modifications.
+            move: The move to play to expand the node.
+
+        Returns:
+            The tree expansion object.
+        """
+
+        # Creation of the child node. If the board already exited in another node, that node is returned as child_node.
+        tree_depth: int = parent_node.tree_depth + 1
+        state_tag: StateTag = state.tag
+
+        need_creation_child_node: bool = (
+            tree.descendants.is_new_generation(tree_depth)
+            or state_tag not in tree.descendants.descendants_at_tree_depth[tree_depth]
+        )
+
+        tree_expansion: TreeExpansion[FamilyT]
+
+        if need_creation_child_node:
+            child_node: FamilyT
+            child_node = self.node_factory.create(
+                state=state,
+                tree_depth=tree_depth,
+                count=tree.nodes_count,
+                branch_from_parent=branch,
+                parent_node=parent_node,
+                modifications=modifications,
+            )
+
+            tree_expansion = TreeExpansion(
+                child_node=child_node,
+                parent_node=parent_node,
+                state_modifications=modifications,
+                creation_child_node=need_creation_child_node,
+                branch_key=branch,
+            )
+
+        else:  # the node already exists
+            child_node_existing: FamilyT
+            child_node_existing = tree.descendants[tree_depth][state_tag]
+            child_node_existing.add_parent(
+                branch_key=branch, new_parent_node=parent_node
+            )
+
+            tree_expansion = TreeExpansion(
+                child_node=child_node_existing,
+                parent_node=parent_node,
+                state_modifications=modifications,
+                creation_child_node=need_creation_child_node,
+                branch_key=branch,
+            )
+
+        # add it to the list of opened move and out of the non-opened moves
+        parent_node.branches_children[branch] = tree_expansion.child_node
+        #   parent_node.tree_node.non_opened_legal_moves.remove(move)
+        tree.move_count += 1  # counting moves
+
+        return tree_expansion
+
+    def open_instructions(
+        self,
+        tree: trees.Tree[FamilyT],
+        opening_instructions: OpeningInstructions[FamilyT],
+    ) -> TreeExpansions[FamilyT]:
+        """
+        Opening multiple nodes based on the opening instructions.
+
+        Args:
+            tree: The tree object.
+            opening_instructions: The opening instructions.
+
+        Returns:
+            The tree expansions that have been performed.
+        """
+
+        # place to store the tree expansion logs generated by the openings
+        tree_expansions: TreeExpansions[FamilyT] = TreeExpansions()
+
+        opening_instruction: OpeningInstruction[FamilyT]
+        for opening_instruction in opening_instructions.values():
+            # open
+            tree_expansion: TreeExpansion[FamilyT] = (
+                self.open_tree_expansion_from_branch(
+                    tree=tree,
+                    parent_node=opening_instruction.node_to_open,
+                    branch=opening_instruction.branch,
+                )
+            )
+
+            record_tree_expansion(
+                tree=tree,
+                tree_expansions=tree_expansions,
+                tree_expansion=tree_expansion,
+            )
+
+        return tree_expansions
+
+    def print_some_stats(
+        self,
+        tree: trees.Tree[FamilyT],
+    ) -> None:
+        """
+        Print some statistics about the tree.
+
+        Args:
+            tree: The tree object.
+        """
+        print(
+            "Tree stats: move_count",
+            tree.move_count,
+            " node_count",
+            tree.descendants.get_count(),
+        )
+        sum_ = 0
+        tree.descendants.print_stats()
+        tree_depth: TreeDepth
+        for tree_depth in tree.descendants:
+            sum_ += len(tree.descendants[tree_depth])
+            print("tree_depth", tree_depth, len(tree.descendants[tree_depth]), sum_)
+
+    def test_count(
+        self,
+        tree: trees.Tree[FamilyT],
+    ) -> None:
+        """
+        Test the count of nodes in the tree.
+
+        Args:
+            tree: The tree object.
+        """
+        assert tree.descendants.get_count() == tree.nodes_count
+
+    def print_best_line(
+        self,
+        tree: trees.Tree[FamilyT],
+    ) -> None:
+        """
+        Print the best line in the tree.
+
+        Args:
+            tree: The tree object.
+        """
+
+        raise NotImplementedError(
+            "print_best_line should not be called; override or modify this behavior"
+        )