orbitsi 0.1.0__cp39-cp39-manylinux_2_24_x86_64.manylinux_2_28_x86_64.whl

orbitsi/main.py

@@ -0,0 +1,59 @@
+# orbitsi/main.py
+import argparse
+from orbitsi.utils import read_graph_from_file
+from orbitsi.orbit import EVOKEOrbitCounter, ORCAOrbitCounter
+from orbitsi.search import FilterEngine, OrderEngine, SearchEngine
+
+def run_search(args):
+    data_graph = read_graph_from_file(args.data)
+    pattern_graph = read_graph_from_file(args.pattern)
+
+    counter_cls = EVOKEOrbitCounter if args.orbit_counter == "evoke" else ORCAOrbitCounter
+
+    filter_engine = FilterEngine(
+        data_graph=data_graph,
+        pattern_graph=pattern_graph,
+        orbit_counter_class=counter_cls,
+        graphlet_size=args.graphlet_size
+    )
+    pattern_orbits, candidate_sets = filter_engine.run()
+    order_engine = OrderEngine(pattern_graph, pattern_orbits)
+    order, pivot = order_engine.run()
+    search_engine = SearchEngine(data_graph, pattern_graph, candidate_sets, order, pivot)
+    matches = search_engine.run()
+
+    print(f"✅ Matches found: {len(matches)}")
+    for match in matches:
+        print(match)
+
+
+def run_orbit_count(args):
+    G = read_graph_from_file(args.graph)
+    counter_cls = EVOKEOrbitCounter if args.orbit_counter == "evoke" else ORCAOrbitCounter
+    counter = counter_cls(G, size=args.graphlet_size)
+    orbits = counter.get_orbits(induced=args.induced)
+    print(orbits)
+
+
+def cli_entrypoint():
+    parser = argparse.ArgumentParser(prog="orbitsi")
+    subparsers = parser.add_subparsers(dest="command", required=True)
+
+    # --- search ---
+    search_parser = subparsers.add_parser("search", help="Subgraph isomorphism search")
+    search_parser.add_argument("--data", required=True, help="Path to data graph")
+    search_parser.add_argument("--pattern", required=True, help="Path to pattern graph")
+    search_parser.add_argument("--orbit-counter", choices=["evoke", "orca"], default="evoke")
+    search_parser.add_argument("--graphlet-size", type=int, choices=[4, 5], default=4)
+    search_parser.set_defaults(func=run_search)
+
+    # --- count-orbits ---
+    count_parser = subparsers.add_parser("count-orbits", help="Count node orbits in a graph")
+    count_parser.add_argument("--graph", required=True, help="Path to graph")
+    count_parser.add_argument("--orbit-counter", choices=["evoke", "orca"], default="evoke")
+    count_parser.add_argument("--graphlet-size", type=int, choices=[4, 5], default=4)
+    count_parser.add_argument("--induced", action="store_true", help="Compute induced orbits")
+    count_parser.set_defaults(func=run_orbit_count)
+
+    args = parser.parse_args()
+    args.func(args)

orbitsi/orbit/__init__.py

@@ -0,0 +1,2 @@
+from .evoke import EVOKEOrbitCounter
+from .orca import ORCAOrbitCounter

orbitsi/orbit/evoke.py

@@ -0,0 +1,26 @@
+import networkx as nx
+import numpy as np
+from _evoke_cpp import evoke_count
+from .orbit_converter import OrbitMatrixConverter
+
+class EVOKEOrbitCounter:
+    def __init__(self, G: nx.Graph, size: int = 4):
+        self.G = G
+        self.size = size
+        self.counts = None
+        self.converter = OrbitMatrixConverter()
+
+    def _nx_to_cpp_graph(self) -> dict[int, list[int]]:
+        return {int(n): [int(nbr) for nbr in self.G.neighbors(n)] for n in self.G.nodes}
+
+    def count_orbits(self):
+        cpp_graph = self._nx_to_cpp_graph()
+        self.counts = evoke_count(cpp_graph, size=self.size, parallel=True)
+        return self.counts
+
+    def get_orbits(self, induced: bool = False) -> np.ndarray:
+        if self.counts is None:
+            self.count_orbits()
+        sorted_nodes = sorted(self.counts)
+        orbit_matrix = np.array([self.counts[node] for node in sorted_nodes], dtype=int)
+        return self.converter.noninduced_to_induced(orbit_matrix) if induced else orbit_matrix

orbitsi/orbit/orbit_converter.py

@@ -0,0 +1,63 @@
+import numpy as np
+import os
+
+class OrbitMatrixConverter:
+    def __init__(self):
+        self.matrices = self._load_matrices()
+
+    def _load_matrices(self):
+        """Load conversion matrices as NumPy arrays, not matrix objects."""
+        this_dir = os.path.dirname(__file__)
+        matrices_path = os.path.join(this_dir, 'orbit_conversion_matrices.npz')
+        matrices_file = np.load(matrices_path, allow_pickle=True)
+
+        return {
+            int(k.split('_')[1]): np.asarray(matrices_file[k])
+            for k in matrices_file.files
+        }
+
+    def noninduced_to_induced(self, noninduced_matrix: np.ndarray) -> np.ndarray:
+        """Convert non-induced orbit counts to induced counts."""
+        mat = self.matrices
+        T = np.asarray(noninduced_matrix.T)  # ensure ndarray
+
+        if noninduced_matrix.shape[1] == 15:
+            induced = np.vstack([
+                T[0:1, :],
+                np.linalg.solve(mat[3], T[1:4, :]),
+                np.linalg.solve(mat[4], T[4:15, :])
+            ])
+        elif noninduced_matrix.shape[1] == 73:
+            induced = np.vstack([
+                T[0:1, :],
+                np.linalg.solve(mat[3], T[1:4, :]),
+                np.linalg.solve(mat[4], T[4:15, :]),
+                np.linalg.solve(mat[5], T[15:, :])
+            ])
+        else:
+            raise ValueError("Unsupported orbit count size for conversion.")
+
+        return np.asarray(induced.T, dtype=int)
+
+    def induced_to_noninduced(self, induced_matrix: np.ndarray) -> np.ndarray:
+        """Convert induced orbit counts to non-induced counts."""
+        mat = self.matrices
+        T = np.asarray(induced_matrix.T)  # ensure ndarray
+
+        if induced_matrix.shape[1] == 15:
+            noninduced = np.vstack([
+                T[0:1, :],
+                mat[3] @ T[1:4, :],
+                mat[4] @ T[4:15, :]
+            ])
+        elif induced_matrix.shape[1] == 73:
+            noninduced = np.vstack([
+                T[0:1, :],
+                mat[3] @ T[1:4, :],
+                mat[4] @ T[4:15, :],
+                mat[5] @ T[15:, :]
+            ])
+        else:
+            raise ValueError("Unsupported orbit count size for conversion.")
+
+        return np.asarray(noninduced.T, dtype=int)

orbitsi/orbit/orca.py

@@ -0,0 +1,34 @@
+import networkx as nx
+import numpy as np
+from _orca_cpp import orca_count
+from .orbit_converter import OrbitMatrixConverter
+
+class ORCAOrbitCounter:
+    def __init__(self, G: nx.Graph, size: int = 4):
+        self.G = G
+        self.size = size
+        self.counts = None
+        self.converter = OrbitMatrixConverter()
+
+    def _nx_to_cpp_adjlist(self) -> tuple[list[list[int]], dict]:
+        n = self.G.number_of_nodes()
+        adj = [[] for _ in range(n)]
+        mapping = {node: i for i, node in enumerate(sorted(self.G.nodes()))}
+        for u, v in self.G.edges():
+            adj[mapping[u]].append(mapping[v])
+            adj[mapping[v]].append(mapping[u])
+        return adj, mapping
+
+    def count_orbits(self) -> dict[int, list[int]]:
+        adj, mapping = self._nx_to_cpp_adjlist()
+        orbit_matrix = orca_count(adj, self.size)
+        reverse_mapping = {v: k for k, v in mapping.items()}
+        self.counts = {reverse_mapping[i]: row for i, row in enumerate(orbit_matrix)}
+        return self.counts
+
+    def get_orbits(self, induced: bool = False) -> np.ndarray:
+        if self.counts is None:
+            self.count_orbits()
+        sorted_nodes = sorted(self.counts)
+        orbit_matrix = np.array([self.counts[node] for node in sorted_nodes], dtype=int)
+        return orbit_matrix if induced else self.converter.induced_to_noninduced(orbit_matrix)

orbitsi/search/__init__.py

@@ -0,0 +1,3 @@
+from .filtering import FilterEngine
+from .ordering import OrderEngine
+from .searching import SearchEngine

orbitsi/search/filtering.py

@@ -0,0 +1,149 @@
+import networkx as nx
+from collections import defaultdict, Counter
+
+class FilterEngine:
+    def __init__(self, data_graph, pattern_graph, orbit_counter_class, graphlet_size=4):
+        self.data_graph = data_graph
+        self.pattern_graph = pattern_graph
+        self.graphlet_size = graphlet_size
+        self.orbit_counter_class = orbit_counter_class
+        self.data_labels = nx.get_node_attributes(data_graph, "label")
+        self.pattern_labels = nx.get_node_attributes(pattern_graph, "label")
+
+
+        self.label_index = defaultdict(list)
+        for node, label in self.data_labels.items():
+            self.label_index[label].append(node)
+
+        # Orbit counters
+        self.pattern_orbits = self._compute_orbits(pattern_graph, orbit_counter_class)
+
+    def extract_induced_subgraph(self, data_graph, candidate_sets):
+        candidate_nodes = set(v for candidates in candidate_sets.values() for v in candidates)
+
+        # Mapping: original node → new node id (0 to n-1)
+        old_to_new = {v: i for i, v in enumerate(sorted(candidate_nodes))}
+        new_to_old = {i: v for v, i in old_to_new.items()}
+
+        # Build induced subgraph with relabeled nodes
+        G_sub = nx.Graph()
+        for u, v in data_graph.subgraph(candidate_nodes).edges():
+            G_sub.add_edge(old_to_new[u], old_to_new[v])
+
+        return G_sub, old_to_new, new_to_old
+
+    def remap_subgraph_to_graph(self, orbit_matrix, new_to_old):
+        return {
+            new_to_old[i]: orbit_matrix[i].tolist()
+            for i in range(len(orbit_matrix))
+        }
+
+    def _compute_orbits(self, graph, counter_class):
+        counter = counter_class(graph, size=self.graphlet_size)
+        orbit_matrix = counter.get_orbits(induced=False)
+        return {node: orbit_matrix[i].tolist() for i, node in enumerate(graph.nodes())}
+
+    def run(self):
+        candidate_sets = self.ldf_filter()
+        if not candidate_sets:
+            return {}
+        print("============================================================\nLDF:\n============================================================\n")
+        self.printCandidateSets(candidate_sets)
+        candidate_sets = self.nlf_filter(candidate_sets)
+        if not candidate_sets:
+            return {}
+        print("============================================================\nNLF:\n============================================================\n")
+        self.printCandidateSets(candidate_sets)
+
+        '''candidate_sets = self.orbit_filter(candidate_sets)
+        if not candidate_sets:
+            return {}
+        print("============================================================\Orbit:\n============================================================\n")'''
+        self.printCandidateSets(candidate_sets)
+
+        return self.pattern_orbits, candidate_sets
+
+    def ldf_filter(self):
+        candidate_sets = {}
+        data_degrees = dict(self.data_graph.degree)
+
+        for u in self.pattern_graph.nodes:
+            label_u = self.pattern_labels[u]
+            deg_u = self.pattern_graph.degree[u]
+
+            labeled_nodes = self.label_index.get(label_u, [])
+            candidates = [
+                v for v in labeled_nodes
+                if data_degrees[v] >= deg_u
+            ]
+
+            if not candidates:
+                return {}
+            candidate_sets[u] = candidates
+        return candidate_sets
+
+    def nlf_filter(self, candidate_sets):
+        refined_sets = {}
+
+        pattern_nlf = {
+            u: Counter(self.pattern_labels[nbr] for nbr in self.pattern_graph.neighbors(u))
+            for u in self.pattern_graph.nodes
+        }
+
+        # Compute only NLFs for candidate vertices actually used
+        used_data_nodes = set(v for cset in candidate_sets.values() for v in cset)
+        data_nlf = {
+            v: Counter(self.data_labels[nbr] for nbr in self.data_graph.neighbors(v))
+            for v in used_data_nodes
+        }
+
+        for u, candidates in candidate_sets.items():
+            u_nlf = pattern_nlf[u]
+            filtered = [
+                v for v in candidates
+                if all(data_nlf[v].get(lbl, 0) >= cnt for lbl, cnt in u_nlf.items())
+            ]
+
+            if not filtered:
+                return {}
+            refined_sets[u] = filtered
+
+        return refined_sets
+
+    def orbit_filter(self, candidate_sets):
+        subgraph, old_to_new, new_to_old = self.extract_induced_subgraph(self.data_graph, candidate_sets)
+        counter = self.orbit_counter_class(subgraph, size=self.graphlet_size)
+        data_orbit_matrix = counter.get_orbits(induced=False)
+
+        # Step 3: Remap orbit vectors to original graph nodes using helper
+        self.data_orbits = self.remap_subgraph_to_graph(data_orbit_matrix, new_to_old)
+        #print(self.data_orbits)
+        # Step 4: Filter based on orbit counts
+        refined_sets = {}
+        for u, candidates in candidate_sets.items():
+            orbit_u = self.pattern_orbits[u]
+            filtered = []
+
+            for v in candidates:
+                orbit_v = self.data_orbits[v]
+                for ov, ou in zip(orbit_v, orbit_u):
+                    if ov < ou:
+                        break
+                else:
+                    filtered.append(v)
+
+            if not filtered:
+                return {}
+            refined_sets[u] = filtered
+
+        return refined_sets
+
+
+    def printCandidateSets(self, candidate_sets):
+        # Display results
+        if not candidate_sets:
+            print("No match possible after filtering.")
+        else:
+            print("\n=== Candidate Sets ===")
+            for u, cands in candidate_sets.items():
+                print(f"Pattern Node {u} → Candidates: {cands}")

orbitsi/search/ordering.py

@@ -0,0 +1,68 @@
+import networkx as nx
+import numpy as np
+
+class OrderEngine:
+    def __init__(self, pattern_graph, pattern_orbits=None, method='auto'):
+        self.pattern_graph = pattern_graph
+        self.pattern_orbits = pattern_orbits
+        self.num_nodes = pattern_graph.number_of_nodes()
+
+        if method == 'auto':
+            self.use_orbit = pattern_orbits is not None
+        elif method == 'orbit':
+            if pattern_orbits is None:
+                raise ValueError("Orbit method selected but no orbit data provided.")
+            self.use_orbit = True
+        elif method == 'degree':
+            self.use_orbit = False
+        else:
+            raise ValueError("Invalid method: choose from 'auto', 'orbit', or 'degree'")
+
+    def compute_score(self, node):
+        if self.use_orbit:
+            return sum(x * x for x in self.pattern_orbits[node])
+        else:
+            return self.pattern_graph.degree[node]
+
+    def run(self):
+        order = []
+        pivot = [None] * self.num_nodes
+        visited = [False] * self.num_nodes
+
+        orbit_strength = {
+            u: self.compute_score(u)
+            for u in self.pattern_graph.nodes
+        }
+
+        start_node = max(orbit_strength, key=orbit_strength.get)
+        order.append(start_node)
+        visited[start_node] = True
+
+        for _ in range(1, self.num_nodes):
+            max_bn = -1
+            selected = None
+
+            for u in self.pattern_graph.nodes:
+                if visited[u]:
+                    continue
+
+                backward_neighbors = sum(
+                    1 for v in order if self.pattern_graph.has_edge(u, v)
+                )
+
+                if backward_neighbors > max_bn or (
+                    backward_neighbors == max_bn and
+                    orbit_strength[u] > orbit_strength.get(selected, -1)
+                ):
+                    max_bn = backward_neighbors
+                    selected = u
+
+            for v in order:
+                if self.pattern_graph.has_edge(selected, v):
+                    pivot[len(order)] = v
+                    break
+
+            visited[selected] = True
+            order.append(selected)
+
+        return order, pivot

orbitsi/search/searching.py

@@ -0,0 +1,55 @@
+import networkx as nx
+
+class SearchEngine:
+    def __init__(self, data_graph, pattern_graph, candidate_sets, order, pivot):
+        self.data_graph = data_graph
+        self.pattern_graph = pattern_graph
+        self.candidate_sets = candidate_sets
+        self.order = order
+        self.pivot = pivot
+        self.mapping = {}  # pattern_node -> data_node
+        self.inverse_mapping = {}  # data_node -> pattern_node
+        self.matches = []
+
+    def is_valid(self, u, v):
+        # Ensure v isn't already used
+        if v in self.inverse_mapping:
+            return False
+
+        # Enforce pivot constraint: v must be connected to mapped pivot in data_graph
+        '''pivot_u = self.pivot[u]
+        if pivot_u is not None:
+            mapped_pivot = self.mapping.get(pivot_u)
+            if mapped_pivot is not None and not self.data_graph.has_edge(v, mapped_pivot):
+                return False'''
+
+        # Enforce all adjacency constraints between u and previously mapped pattern nodes
+        for u_prev in self.mapping:
+            if self.pattern_graph.has_edge(u, u_prev):
+                v_prev = self.mapping[u_prev]
+                if not self.data_graph.has_edge(v, v_prev):
+                    return False
+
+        return True
+
+    def backtrack(self, depth=0):
+        if depth == len(self.order):
+            # Full match found
+            self.matches.append(self.mapping.copy())
+            return
+
+        u = self.order[depth]
+        for v in self.candidate_sets[u]:
+            if self.is_valid(u, v):
+                # Assign
+                self.mapping[u] = v
+                self.inverse_mapping[v] = u
+                self.backtrack(depth + 1)
+                # Undo
+                del self.mapping[u]
+                del self.inverse_mapping[v]
+
+    def run(self, return_all=True):
+        self.matches = []
+        self.backtrack()
+        return self.matches if return_all else self.matches[:1]

orbitsi/utils.py

@@ -0,0 +1,32 @@
+import networkx as nx
+
+def read_graph_from_file(filepath):
+    """
+    Reads an undirected, vertex-labeled graph from file.
+    Format:
+    - Starts with: t N M
+    - Then: N lines of 'v VertexID LabelId Degree' (only label is used)
+    - Then: M lines of 'e VertexID VertexID'
+
+    Parameters:
+    - filepath: str, path to the graph file
+
+    Returns:
+    - G: networkx.Graph with node labels in the 'label' attribute
+    """
+    G = nx.Graph()
+
+    with open(filepath, 'r') as f:
+        for line in f:
+            tokens = line.strip().split()
+            if not tokens:
+                continue
+            if tokens[0] == 'v':
+                node_id = int(tokens[1])
+                label = int(tokens[2])
+                G.add_node(node_id, label=label)
+            elif tokens[0] == 'e':
+                u, v = int(tokens[1]), int(tokens[2])
+                G.add_edge(u, v)
+
+    return G