relationalai 0.13.0.dev0__py3-none-any.whl → 0.13.1__py3-none-any.whl

relationalai/experimental/paths/examples/paths_benchmark.py

@@ -0,0 +1,115 @@
+"""
+Example usage of automaton-based pathfinding.
+"""
+
+import time
+from relationalai.semantics import Model, Integer, select, String, define
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
+
+import argparse
+
+
+# def print_paths(path_node, path_label):
+#     # Print nodes and labels in a readable format
+#     l2 = String.ref()
+#     k = Integer.ref()
+#     m = Integer.ref()
+#     print("\nNodes and labels in the path on the original graph:")
+#     select(k, m, l2).where(
+#         path_node(k, m),
+#         path_label(k, label := String.ref()),
+#         l2 == strings.concat("-[", label, "]->")
+#     ).inspect()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Pathfinder example script.")
+    parser.add_argument("--num_paths", type=int, default=None, help="Number of paths to find.")
+    args = parser.parse_args()
+
+    print("Number of paths to find:", args.num_paths)
+
+    # Create an automaton that matches paths with pattern: A(A*)B:
+    # pattern = path("-[A]->", star("-[A]->"), "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "A"), (3, 4, "A"), (4, 5, "B"), (1, 5, "A")]
+
+    # 2 paths matching AB:
+    # pattern = path("-[A]->", "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "B"), (1, 4, "A"), (4, 3, "B")]
+
+    
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    pattern = path("A")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+    edge_list = [(1, 2, "A")]
+
+
+    sources = []
+    targets = []
+
+    sources = [1]
+    targets = [2]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+    # sources = [1, 2]
+    # targets = [3, 4]
+    # 2 paths from 2 different source nodes:
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+
+    print("\nEdge list:\n", edge_list)
+
+    # Initialize the RelationalAI model
+    model = Model("paths", use_lqp=True) # , use_lqp=True)  # strict=True  # dry_run=False  # use_direct_access=True
+    # use_lqp=True  # strict=True  # dry_run=False  # use_direct_access=True
+
+    # model.define(
+    #     RawSource("rel", "@span_no_threshold")
+    # )
+
+    graph = Graph.from_edge_list(model, edge_list)
+    Node = graph.Node
+
+    # Call the function to find the path
+
+    Source = model.Relationship(f"source5 {{{Node}}}")
+    Target = model.Relationship(f"target5 {{{Node}}}")
+
+    for src in sources:
+        define(Source(Node.new(id=src)))
+
+    for tgt in targets:
+        define(Target(Node.new(id=tgt)))
+
+    src, tgt = Node.ref(), Node.ref()
+
+    # select(graph.Node).inspect()
+
+    graph.Edge.inspect()
+    select(src).where(Source(src)).inspect()
+    select(tgt).where(Target(tgt)).inspect()
+
+    # print(f"\nFinding paths matching the automaton pattern from {src} to {dst}..."
+    # projected_paths = match(graph, pattern, Source, Target, num_paths=args.num_paths)
+
+    start = time.time()
+    projected_paths = match(graph, pattern, Source, Target)
+
+    i, k = Integer.ref(), Integer.ref()
+    node = graph.Node.ref()
+    label = String.ref()
+
+    result = select(i, k, label, node.id).where(projected_paths(i, k, label, node)).inspect()
+    end = time.time()
+
+    print(f"Time taken to find paths: {end - start} seconds")

relationalai/experimental/paths/examples/paths_example.py

@@ -0,0 +1,116 @@
+"""
+Example usage of automaton-based pathfinding.
+"""
+
+import time
+from relationalai.semantics import Model, Integer, select, String, define
+from relationalai.experimental.paths.graph import Graph
+from relationalai.experimental.paths.api import node, path, match
+
+import argparse
+
+
+# def print_paths(path_node, path_label):
+#     # Print nodes and labels in a readable format
+#     l2 = String.ref()
+#     k = Integer.ref()
+#     m = Integer.ref()
+#     print("\nNodes and labels in the path on the original graph:")
+#     select(k, m, l2).where(
+#         path_node(k, m),
+#         path_label(k, label := String.ref()),
+#         l2 == strings.concat("-[", label, "]->")
+#     ).inspect()
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Pathfinder example script.")
+    parser.add_argument("--num_paths", type=int, default=None, help="Number of paths to find.")
+    args = parser.parse_args()
+
+    print("Number of paths to find:", args.num_paths)
+
+    # Create an automaton that matches paths with pattern: A(A*)B:
+    # pattern = path("-[A]->", star("-[A]->"), "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "A"), (3, 4, "A"), (4, 5, "B"), (1, 5, "A")]
+
+    # 2 paths matching AB:
+    # pattern = path("-[A]->", "-[B]->")
+    # edge_list = [(1, 2, "A"), (2, 3, "B"), (1, 4, "A"), (4, 3, "B")]
+
+    
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    pattern = path("A")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+    edge_list = [(1, 2, "A")]
+
+
+    sources = []
+    targets = []
+
+    sources = [1]
+    targets = [2]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+    # sources = [1, 2]
+    # targets = [3, 4]
+    # 2 paths from 2 different source nodes:
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A")]
+
+    # pattern = path("-[A]->")
+    # edge_list = [(1, 3, "A"), (2, 3, "A"), (1, 4, "A"), (2, 4, "A")]
+
+    timestamp = str(time.gmtime(0))
+
+    print("\nEdge list:\n", edge_list)
+
+    # Initialize the RelationalAI model
+    model = Model(f"paths_{timestamp}", use_lqp=True) # , use_lqp=True)  # strict=True  # dry_run=False  # use_direct_access=True
+    # use_lqp=True  # strict=True  # dry_run=False  # use_direct_access=True
+
+    # model.define(
+    #     RawSource("rel", "@span_no_threshold")
+    # )
+
+    graph = Graph.from_edge_list(model, edge_list)
+    Node = graph.Node
+
+    # Call the function to find the path
+
+    Source = model.Relationship(f"source6 {{{Node}}}")
+    Target = model.Relationship(f"target6 {{{Node}}}")
+
+    for src in sources:
+        define(Source(Node.new(id=src)))
+
+    for tgt in targets:
+        define(Target(Node.new(id=tgt)))
+
+    src, tgt = Node.ref(), Node.ref()
+
+    # select(graph.Node).inspect()
+
+    graph.Edge.inspect()
+    select(src).where(Source(src)).inspect()
+    select(tgt).where(Target(tgt)).inspect()
+
+    # print(f"\nFinding paths matching the automaton pattern from {src} to {dst}..."
+    # projected_paths = match(graph, pattern, Source, Target, num_paths=args.num_paths)
+
+    start = time.time()
+    projected_paths = match(graph, pattern, Source, Target)
+
+    i, k = Integer.ref(), Integer.ref()
+    node = graph.Node.ref()
+    label = String.ref()
+
+    result = select(i, k, label, node.id).where(projected_paths(i, k, label, node)).inspect()
+    end = time.time()
+
+    print(f"Time taken to find paths: {end - start} seconds")

relationalai/experimental/paths/examples/pattern_to_automaton.py

@@ -0,0 +1,28 @@
+from relationalai.experimental.paths.api import path, union
+from relationalai.semantics import Concept
+
+Node = Concept('Node')
+OddNode = Concept('OddNode')
+EvenNode = Concept('EvenNode')
+
+# pattern = path(node(Node, lambda n: n.id > 3), star('-[A]->', '-[B]->'), Node)
+
+# pattern = path(node(Node, lambda n: n.id > 3), Node)
+
+# pattern = path(Node, '-[A]->', Node, '-[B]->', Node)
+
+# pattern = path('-[B]->', node(Node, lambda n: n.id > 3), '-[A]->')
+
+# pattern = path(OddNode, star('-[A]->', '-[B]->'), EvenNode)
+
+# pattern = path(OddNode, star('-[A]->', node(OddNode, lambda n: n.id > 3)), EvenNode)
+
+pattern = path(union("-[A]->", "-[B]->"), union("-[A]->", "-[B]->"))
+
+g = pattern.glushkov()
+a = g.automaton()
+a.reduce()
+
+print(a)
+
+

relationalai/experimental/paths/find_paths_via_automaton.py

@@ -0,0 +1,85 @@
+"""
+Main functionality for finding paths through automaton.
+"""
+
+from relationalai.semantics import define, where, Integer
+
+from .product_graph import create_product_graph #, find_path_in_product_graph
+# from .product_graph import project_product_graph_path_to_original_graph
+
+from .path_algorithms.find_paths import find_shortest_paths, find_walks
+
+def find_paths_via_automaton(graph, automaton, Source, Target,
+                             num_paths = None, max_length = 1000,
+                             type = "shortest"):
+    """
+    Find a path in the graph allowed by the automaton from Source nodes to Target nodes.
+
+    Args:
+        graph: The user's input graph
+        automaton: Automaton object representing the pattern to match
+        Source: Source node entities
+        Target: Target node entities
+        num_paths: Optional
+          - if specified, limit the number of paths returned
+          - if None, all paths are returned.
+
+    Returns:
+        product_graph: The product graph
+        paths: Relationship of arity 4 encoding paths in the original graph
+    """
+    model = graph.model
+    Node = graph.Node
+
+    # Create product graph:
+    product_graph = create_product_graph(graph, automaton)
+    ProductGraphNode = product_graph.Node
+
+    # automaton states:
+    init_state = 0  # assumes single initial state labeled 0 of the automaton
+
+    FinalState = model.Relationship("final_state1 {Integer}")
+    for state in automaton.get_final_states():
+        define(FinalState(state))
+
+    # FinalState.inspect()
+
+    # Product graph source and target sets:
+    ProductGraphSource = model.Relationship(f"pg_source {{{ProductGraphNode}}}")
+    ProductGraphTarget = model.Relationship(f"pg_target {{{ProductGraphNode}}}")
+
+    st = Integer.ref() # state in the automaton
+    src, tgt = Node.ref(), Node.ref()
+
+    where(Source(src)).define(
+        product_graph_src := ProductGraphNode.new(
+            state=init_state, orig_node=src
+        ),
+        ProductGraphSource(product_graph_src)
+    )
+
+    where(Target(tgt), FinalState(st)).define(
+        product_graph_dst := ProductGraphNode.new(
+            state=st, orig_node=tgt
+        ),
+        ProductGraphTarget(product_graph_dst)
+    )
+
+    # ProductGraphSource.inspect()
+    # ProductGraphTarget.inspect()
+
+    if type == "shortest":
+        # Find shortest paths in the product graph:
+        find_paths_function = find_shortest_paths
+
+    elif type == "walks":
+        find_paths_function = find_walks
+    else:
+        raise ValueError(f"Unknown type of path search: {type}")
+
+    paths = find_paths_function(
+        product_graph, ProductGraphSource, ProductGraphTarget,
+        num_paths=num_paths, max_length=max_length
+    )
+
+    return product_graph, paths

relationalai/experimental/paths/graph.py

@@ -0,0 +1,185 @@
+from relationalai.semantics import Integer, define, Concept, Relationship, std
+
+
+class Graph:
+    def __init__(self, model, Node:Concept, Edge:Relationship):
+        """
+        Initialize a Graph instance with Node and Edge concepts.
+        """
+        self.Node = Node
+        self.Edge = Edge
+        self.model = model
+
+
+    @classmethod
+    def from_edge_list(cls, model, edge_list):
+        """
+        Create a Graph instance from a Model.
+        The Model should have Node and Edge concepts defined.
+        """
+
+        Node = model.Concept("Node")
+
+        if len(edge_list[0]) == 2:
+            Edge = model.Relationship(f"edge4 {{{Node}}} {{{Node}}}")
+
+            for src, dst, in edge_list:
+                u = Node.new(id=src)
+                v = Node.new(id=dst)
+
+                define(u)
+                define(v)
+                define(Edge(u, v))
+        else:
+            Edge = model.Relationship(f"edge5 {{{Node}}} {{{Node}}} {{String}}")
+
+            for src, dst, label in edge_list:
+                u = Node.new(id=src)
+                v = Node.new(id=dst)
+
+                define(u)
+                define(v)
+                define(Edge(u, v, label))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_grid(cls, model, side, tp = 'directed'):
+        """
+        Create a grid Graph instance from a Model. The length of the side of the grid
+        is given by the parameter `side`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge6 {{{Node}}} {{{Node}}}")
+
+        n, m = Integer.ref(), Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(row = n, col = m)).where(
+            n == std.range(1, side + 1, 1),
+            m == std.range(1, side + 1, 1)
+        )
+
+        define(Edge(u, v)).where(
+            Node(u),
+            Node(v),
+            u.row == v.row,
+            v.col == u.col + 1
+        )
+
+        define(Edge(u, v)).where(
+            Node(u),
+            Node(v),
+            u.col == v.col,
+            v.row == u.row + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_diamond(cls, model, diamonds, tp = 'directed'):
+        """
+        Create a diamond Graph instance from a Model. The number of diamonds in the graph
+        is given by the parameter `diamonds`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge7 {{{Node}}} {{{Node}}}")
+
+        n = Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(id = n)).where(
+            n == std.range(1, 3*diamonds + 2, 1)
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 1,
+            v.id == 3*(n-1) + 2
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 1,
+            v.id == 3*(n-1) + 3
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 2,
+            v.id == 3*n + 1
+        )
+
+        define(Edge(u, v)).where(
+            n == std.range(1, diamonds + 1, 1),
+            Node(u),
+            Node(v),
+            u.id == 3*(n-1) + 3,
+            v.id == 3*n + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)
+
+
+    @classmethod
+    def construct_rake(cls, model, length, fan_out, tp = 'directed'):
+        """
+        Create a grid Graph instance from a Model. The length of the side of the grid
+        is given by the parameter `side`.
+        The Model should have Node and Edge concepts defined.
+        """
+        Node = model.Concept("Node")
+        Edge = model.Relationship(f"edge8 {{{Node}}} {{{Node}}}")
+
+        start, i = Integer.ref(), Integer.ref()
+        u, v = Node.ref(), Node.ref()
+
+        define(Node.new(id = i)).where(
+            i == std.range(0,  (length + 1) * (fan_out + 1), 1)
+        )
+
+        define(Edge(u, v)).where(
+            i == std.range(0, length, 1),
+            Node(u),
+            Node(v),
+            u.id == i,
+            v.id == i + 1
+        )
+
+        define(Edge(u, v)).where(
+            i == std.range(length + 1, (length + 1) * fan_out + 1, length + 1),
+            Node(u),
+            Node(v),
+            u.id == length,
+            v.id == i
+        )
+
+        define(Edge(u, v)).where(
+            start == std.range(length + 1, (length + 1) * fan_out + 2, length + 1),
+            i == std.range(start, start + length, 1),
+            Node(u),
+            Node(v),
+            u.id == i,
+            v.id == i + 1
+        )
+
+        if tp == 'undirected':
+            define(Edge(u, v)).where(Edge(v, u))
+
+        return cls(model, Node, Edge)