cbrkit 0.18.2__tar.gz → 0.19.0__tar.gz

{cbrkit-0.18.2 → cbrkit-0.19.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cbrkit
-Version: 0.18.2
+Version: 0.19.0
 Summary: Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI.
 Home-page: https://wi2trier.github.io/cbrkit/
 License: MIT

{cbrkit-0.18.2 → cbrkit-0.19.0}/cbrkit/eval/_common.py

@@ -1,4 +1,3 @@
-import itertools
 import statistics
 import warnings
 from collections.abc import Iterable, Mapping, Sequence
@@ -34,36 +33,37 @@ def _correctness_completeness_single(
     k: int | None,
 ) -> tuple[float, float]:
     sorted_run = sorted(run.items(), key=lambda x: x[1], reverse=True)
-    run_ranking = {x[0]: i + 1 for i, x in enumerate(sorted_run[:k])}
+    run_k = {x[0]: x[1] for x in sorted_run[:k]}
 
-    orders = 0
-    concordances = 0
-    disconcordances = 0
+    concordant_pairs = 0
+    discordant_pairs = 0
+    total_pairs = 0
 
-    correctness = 1
-    completeness = 1
+    case_keys = list(qrel.keys())
 
-    for (user_key_1, user_rank_1), (user_key_2, user_rank_2) in itertools.product(
-        qrel.items(), qrel.items()
-    ):
-        if user_key_1 != user_key_2 and user_rank_1 > user_rank_2:
-            orders += 1
+    for i in range(len(case_keys)):
+        for j in range(i + 1, len(case_keys)):
+            idx1, idx2 = case_keys[i], case_keys[j]
+            total_pairs += 1
 
-            system_rank_1 = run_ranking.get(user_key_1)
-            system_rank_2 = run_ranking.get(user_key_2)
+            if idx1 in run_k and idx2 in run_k:
+                qrel1, qrel2 = qrel[idx1], qrel[idx2]
+                run1, run2 = run_k[idx1], run_k[idx2]
 
-            if system_rank_1 is not None and system_rank_2 is not None:
-                if system_rank_1 > system_rank_2:
-                    concordances += 1
-                elif system_rank_1 < system_rank_2:
-                    disconcordances += 1
+                if (qrel1 < qrel2 and run1 < run2) or (qrel1 > qrel2 and run1 > run2):
+                    concordant_pairs += 1
+                elif qrel1 != qrel2:
+                    discordant_pairs += 1
 
-    if concordances + disconcordances > 0:
-        correctness = (concordances - disconcordances) / (
-            concordances + disconcordances
-        )
-    if orders > 0:
-        completeness = (concordances + disconcordances) / orders
+    correctness = (
+        (concordant_pairs - discordant_pairs) / (concordant_pairs + discordant_pairs)
+        if (concordant_pairs + discordant_pairs) > 0
+        else 0.0
+    )
+
+    completeness = (
+        (concordant_pairs + discordant_pairs) / total_pairs if total_pairs > 0 else 0.0
+    )
 
     return correctness, completeness
 

{cbrkit-0.18.2 → cbrkit-0.19.0}/cbrkit/sim/generic.py

@@ -109,6 +109,7 @@ class dynamic_table[K, V, S: Float](SimSeqFunc[V, S], SupportsMetadata):
         entries: Sequence[tuple[a, b, sim(a, b)]
         symmetric: If True, the table is assumed to be symmetric, i.e. sim(a, b) = sim(b, a)
         default: Default similarity value for pairs not in the table
+        key_getter: A function that extracts the the key for lookup from the input values
 
     Examples:
         >>> sim = dynamic_table(

cbrkit-0.19.0/cbrkit/sim/graphs/__init__.py

@@ -0,0 +1,5 @@
+from . import _model as model
+from ._astar import astar
+from ._isomorphism import isomorphism
+
+__all__ = ["model", "astar", "isomorphism"]

{cbrkit-0.18.2 → cbrkit-0.19.0}/cbrkit/sim/graphs/_astar.py

@@ -5,23 +5,22 @@ import itertools
 import random
 from collections.abc import Iterable, Sequence
 from dataclasses import dataclass, field
-from typing import Any, Literal, Protocol, cast, override
+from typing import Literal, Protocol, override
 
 from cbrkit.helpers import (
     SimSeqWrapper,
-    SimWrapper,
     get_metadata,
     unpack_sim,
     unpack_sims,
 )
 from cbrkit.sim.graphs._model import (
+    DataSimWrapper,
     Edge,
     Graph,
-    HasData,
+    GraphSim,
     Node,
 )
 from cbrkit.typing import (
-    AnnotatedFloat,
     AnySimFunc,
     Float,
     JsonDict,
@@ -33,13 +32,6 @@ from cbrkit.typing import (
 type ElementKind = Literal["node", "edge"]
 
 
-@dataclass(slots=True, frozen=True)
-class GraphSim[K](AnnotatedFloat):
-    value: float
-    node_mappings: dict[K, K]
-    edge_mappings: dict[K, K]
-
-
 @dataclass(slots=True, frozen=True)
 class SelectionResult[K]:
     query_element: K
@@ -195,17 +187,6 @@ class default_edge_sim[K, N, E](SimSeqFunc[Edge[K, N, E], Float]):
         ]
 
 
-class DataSimWrapper[V: HasData[Any], S: Float](SimWrapper, SimSeqFunc[V, S]):
-    @override
-    def __call__(self, pairs: Sequence[tuple[V, V]]) -> Sequence[S]:
-        if self.kind == "pair":
-            func = cast(SimPairFunc[V, S], self.func)
-            return [func(x.data, y.data) for (x, y) in pairs]
-
-        func = cast(SimSeqFunc[V, S], self.func)
-        return func([(x.data, y.data) for x, y in pairs])
-
-
 @dataclass(slots=True)
 class astar[K, N, E, G](
     SimPairFunc[Graph[K, N, E, G], GraphSim[K]],

cbrkit-0.19.0/cbrkit/sim/graphs/_isomorphism.py

@@ -0,0 +1,104 @@
+from collections.abc import Callable
+from dataclasses import dataclass
+from typing import Any, override
+
+from cbrkit.helpers import SimSeqWrapper
+from cbrkit.typing import (
+    AggregatorFunc,
+    AnySimFunc,
+    Float,
+    SimPairFunc,
+    SimSeqFunc,
+    SupportsMetadata,
+)
+
+from ._model import DataSimWrapper, Graph, GraphSim, Node, to_rustworkx_with_lookup
+
+
+@dataclass(slots=True)
+class isomorphism[K, N, E, G, S: Float](
+    SimPairFunc[Graph[K, N, E, G], GraphSim[K]],
+    SupportsMetadata,
+):
+    """Compute subgraph isomorphisms between two graphs.
+
+    - Convert the input graphs to Rustworkx graphs.
+    - Compute all possible subgraph isomorphisms between the two graphs.
+    - For each isomorphism, compute the similarity based on the node mapping.
+    - Return the isomorphism mapping with the highest similarity.
+    """
+
+    node_matcher: Callable[[N, N], bool]
+    edge_matcher: Callable[[E, E], bool]
+    node_sim_func: SimSeqFunc[Node[K, N], S]
+    aggregator: AggregatorFunc[Any, S]
+
+    def __init__(
+        self,
+        node_matcher: Callable[[N, N], bool],
+        edge_matcher: Callable[[E, E], bool],
+        aggregator: AggregatorFunc[Any, S],
+        node_obj_sim: AnySimFunc[Node[K, N], Float] | None = None,
+        node_data_sim: AnySimFunc[N, Float] | None = None,
+    ) -> None:
+        # verify that only one of the object or data similarity functions is provided
+        if node_obj_sim and node_data_sim:
+            raise ValueError(
+                "Only one of the object or data similarity functions can be provided for nodes"
+            )
+
+        if node_data_sim:
+            self.node_sim_func = DataSimWrapper(node_data_sim)
+        elif node_obj_sim:
+            self.node_sim_func = SimSeqWrapper(node_obj_sim)
+        else:
+            raise ValueError("Either node_obj_sim or node_data_sim must be provided")
+
+        self.node_matcher = node_matcher
+        self.edge_matcher = edge_matcher
+        self.aggregator = aggregator
+
+    @override
+    def __call__(
+        self,
+        x: Graph[K, N, E, G],
+        y: Graph[K, N, E, G],
+    ) -> GraphSim[K]:
+        import rustworkx
+
+        x_rw, x_lookup = to_rustworkx_with_lookup(x)
+        y_rw, y_lookup = to_rustworkx_with_lookup(y)
+
+        rw_mappings = rustworkx.vf2_mapping(
+            y_rw,
+            x_rw,
+            subgraph=True,
+            node_matcher=self.node_matcher,
+            edge_matcher=self.edge_matcher,
+        )
+
+        node_mappings: list[dict[K, K]] = [
+            {y_lookup[y_key]: x_lookup[x_key] for y_key, x_key in mapping.items()}
+            for mapping in rw_mappings
+        ]
+
+        if len(node_mappings) == 0:
+            return GraphSim(0.0, node_mappings={}, edge_mappings={})
+
+        mapping_similarities: list[float] = []
+
+        for node_mapping in node_mappings:
+            node_pairs = [
+                (x.nodes[x_key], y.nodes[y_key])
+                for y_key, x_key in node_mapping.items()
+            ]
+            node_similarities = self.node_sim_func(node_pairs)
+            mapping_similarities.append(self.aggregator(node_similarities))
+
+        best_mapping_id, best_sim = max(
+            enumerate(mapping_similarities),
+            key=lambda x: x[1],
+        )
+        best_mapping = node_mappings[best_mapping_id]
+
+        return GraphSim(best_sim, node_mappings=best_mapping, edge_mappings={})

{cbrkit-0.18.2 → cbrkit-0.19.0}/cbrkit/sim/graphs/_model.py

@@ -1,9 +1,19 @@
-from collections.abc import Mapping
+from __future__ import annotations
+
+from collections.abc import Mapping, Sequence
 from dataclasses import dataclass
-from typing import Any, Protocol, TypedDict
+from typing import Any, Protocol, TypedDict, cast, override
 
 import immutables
 
+from cbrkit.helpers import SimWrapper
+from cbrkit.typing import (
+    AnnotatedFloat,
+    Float,
+    SimPairFunc,
+    SimSeqFunc,
+)
+
 __all__ = [
     "Node",
     "Edge",
@@ -16,6 +26,24 @@ __all__ = [
 ]
 
 
+@dataclass(slots=True, frozen=True)
+class GraphSim[K](AnnotatedFloat):
+    value: float
+    node_mappings: dict[K, K]
+    edge_mappings: dict[K, K]
+
+
+class DataSimWrapper[V: HasData[Any], S: Float](SimWrapper, SimSeqFunc[V, S]):
+    @override
+    def __call__(self, pairs: Sequence[tuple[V, V]]) -> Sequence[S]:
+        if self.kind == "pair":
+            func = cast(SimPairFunc[V, S], self.func)
+            return [func(x.data, y.data) for (x, y) in pairs]
+
+        func = cast(SimSeqFunc[V, S], self.func)
+        return func([(x.data, y.data) for x, y in pairs])
+
+
 class HasData[T](Protocol):
     data: T
 
@@ -49,7 +77,7 @@ class Node[K, N](HasData[N]):
         cls,
         key: K,
         data: SerializedNode[N],
-    ) -> "Node[K, N]":
+    ) -> Node[K, N]:
         return cls(key, data["data"])
 
 
@@ -73,7 +101,7 @@ class Edge[K, N, E](HasData[E]):
         key: K,
         data: SerializedEdge[K, E],
         nodes: Mapping[K, Node[K, N]],
-    ) -> "Edge[K, N, E]":
+    ) -> Edge[K, N, E]:
         return cls(
             key,
             nodes[data["source"]],
@@ -99,7 +127,7 @@ class Graph[K, N, E, G](HasData[G]):
     def from_dict(
         cls,
         g: SerializedGraph[K, N, E, G],
-    ) -> "Graph[K, N, E, G]":
+    ) -> Graph[K, N, E, G]:
         nodes = immutables.Map(
             (key, Node.from_dict(key, value)) for key, value in g["nodes"].items()
         )
@@ -121,7 +149,9 @@ def from_dict[K, N, E, G](g: SerializedGraph[K, N, E, G]) -> Graph[K, N, E, G]:
 try:
     import rustworkx
 
-    def to_rustworkx[N, E](g: Graph[Any, N, E, Any]) -> "rustworkx.PyDiGraph[N, E]":
+    def to_rustworkx_with_lookup[K, N, E](
+        g: Graph[K, N, E, Any],
+    ) -> tuple[rustworkx.PyDiGraph[N, E], dict[int, K]]:
         ng = rustworkx.PyDiGraph(attrs=g.data)
         new_ids = ng.add_nodes_from(list(g.nodes.values()))
         id_map = {
@@ -139,19 +169,18 @@ try:
             ]
         )
 
-        return ng
+        return ng, {new_id: old_id for old_id, new_id in id_map.items()}
 
-    def from_rustworkx[N, E](g: "rustworkx.PyDiGraph[N, E]") -> Graph[int, N, E, Any]:
+    def to_rustworkx[N, E](g: Graph[Any, N, E, Any]) -> rustworkx.PyDiGraph[N, E]:
+        return to_rustworkx_with_lookup(g)[0]
+
+    def from_rustworkx[N, E](g: rustworkx.PyDiGraph[N, E]) -> Graph[int, N, E, Any]:
         nodes = immutables.Map(
             (idx, Node(idx, g.get_node_data(idx))) for idx in g.node_indices()
         )
         edges = immutables.Map(
             (edge_id, Edge(edge_id, nodes[source_id], nodes[target_id], edge_data))
-            for edge_id, (
-                source_id,
-                target_id,
-                edge_data,
-            ) in g.edge_index_map().items()
+            for edge_id, (source_id, target_id, edge_data) in g.edge_index_map().items()
         )
 
         return Graph(nodes, edges, g.attrs)
@@ -164,43 +193,44 @@ except ImportError:
 try:
     import networkx as nx
 
-    def to_networkx[N, E](g: Graph[Any, N, E, Any]) -> "nx.DiGraph":
+    def to_networkx(g: Graph) -> nx.DiGraph:
         ng = nx.DiGraph()
-        # Set graph attributes
-        ng.graph.update(g.data)
+        ng.graph = g.data
 
-        # Add nodes with their data
-        for node in g.nodes.values():
-            ng.add_node(node.key, data=node.data)
+        ng.add_nodes_from(
+            (
+                node.key,
+                (node.data if isinstance(node.data, Mapping) else {"data": node.data}),
+            )
+            for node in g.nodes
+        )
 
-        # Add edges with their data
-        for edge in g.edges.values():
-            ng.add_edge(edge.source.key, edge.target.key, key=edge.key, data=edge.data)
+        ng.add_edges_from(
+            (
+                edge.source.key,
+                edge.target.key,
+                (
+                    {**edge.data, "key": edge.key}
+                    if isinstance(edge.data, Mapping)
+                    else {"data": edge.data, "key": edge.key}
+                ),
+            )
+            for edge in g.edges.values()
+        )
 
         return ng
 
-    def from_networkx[N, E](g: "nx.DiGraph") -> Graph[Any, N, E, Any]:
-        # Create nodes
+    def from_networkx(g: nx.DiGraph) -> Graph:
         nodes = immutables.Map(
-            (node_id, Node(node_id, g.nodes[node_id].get("data")))
-            for node_id in g.nodes
+            (idx, Node(idx, data)) for idx, data in g.nodes(data=True)
         )
 
-        # Create edges
         edges = immutables.Map(
-            (
-                edge_data.get("key", idx),
-                Edge(
-                    edge_data.get("key", idx),
-                    nodes[source],
-                    nodes[target],
-                    edge_data.get("data"),
-                ),
-            )
-            for idx, (source, target, edge_data) in enumerate(g.edges(data=True))
+            (idx, Edge(idx, nodes[source_id], nodes[target_id], edge_data))
+            for idx, (source_id, target_id, edge_data) in enumerate(g.edges(data=True))
         )
 
-        return Graph(nodes, edges, dict(g.graph))
+        return Graph(nodes, edges, g.graph)
 
     __all__ += ["to_networkx", "from_networkx"]
 

{cbrkit-0.18.2 → cbrkit-0.19.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "cbrkit"
-version = "0.18.2"
+version = "0.19.0"
 description = "Customizable Case-Based Reasoning (CBR) toolkit for Python with a built-in API and CLI."
 authors = ["Mirko Lenz <mirko@mirkolenz.com>"]
 license = "MIT"

cbrkit-0.18.2/cbrkit/sim/graphs/__init__.py

@@ -1,8 +0,0 @@
-from . import _model as model
-from ._astar import GraphSim, astar
-
-__all__ = [
-    "model",
-    "GraphSim",
-    "astar",
-]