Fix critical, high, and medium review issues in core library

kernel_lr.py:
- C1: Use K.shape[0] for alpha_init instead of len(X)
- C4: Use np.logaddexp(0, -yf) for numerical stability
- H1: Merge objective/gradient to eliminate redundant K @ alpha
- H2: Avoid double featurization when X2 is None
- L1: Remove unused random_state and project_dim parameters

vun.py:
- C2: Replace signal.SIGALRM timeout with ThreadPoolExecutor
  (works in multiprocessing workers and on Windows)
- H3: Add edges="links" to nx.node_link_data/graph calls
- M7: Remove section separator comments

generic_descriptors.py:
- M2: Replace .get() defensive defaults with direct access
- M3: Remove bare except Exception in PyramidMatchDescriptor

io.py:
- M1: Replace hasattr with isinstance(obj, np.generic)

Author: pjhartout

polygraph/metrics/base/kernel_lr.py

@@ -37,13 +37,11 @@ def __init__(
         use_node_labels: bool = False,
         node_label_key: Optional[str] = None,
         digest_size: int = 4,
-        project_dim: Optional[int] = None,
         C: float = 1.0,
         max_iter: int = 100,
         tol: float = 1e-4,
         n_jobs: int = 1,
         verbose: bool = False,
-        random_state: Optional[int] = None,
         normalize_kernel: bool = True,
         center_kernel: bool = True,
     ):
@@ -52,13 +50,11 @@ def __init__(
         self.use_node_labels = use_node_labels
         self.node_label_key = node_label_key
         self.digest_size = digest_size
-        self.project_dim = project_dim
         self.C = C
         self.max_iter = max_iter
         self.tol = tol
         self.n_jobs = n_jobs
         self.verbose = verbose
-        self.random_state = random_state
         self.normalize_kernel = normalize_kernel
         self.center_kernel = center_kernel
 
@@ -101,15 +97,15 @@ def _compute_kernel_matrix(
         X2: Optional[Union[List[nx.Graph], np.ndarray, csr_array]] = None,
     ) -> np.ndarray:
         """Compute kernel matrix between X1 and X2."""
-        if X2 is None:
-            X2 = X1
-
         is_array = isinstance(X1, (np.ndarray, csr_array))
         kernel = self._resolve_kernel(is_array, show_progress=self.verbose)
 
+        if X2 is None:
+            features1 = X1 if is_array else kernel.featurize(X1)
+            return kernel.pre_gram_block(features1, features1)  # pyright: ignore[reportArgumentType]
+
         features1 = X1 if is_array else kernel.featurize(X1)
         features2 = X2 if is_array else kernel.featurize(X2)  # pyright: ignore[reportArgumentType]
-
         return kernel.pre_gram_block(features1, features2)  # pyright: ignore[reportArgumentType]
 
     def _compute_kernel_diag(
@@ -121,26 +117,28 @@ def _compute_kernel_diag(
         features = X if is_array else kernel.featurize(X)
         return kernel.kernel_diag(features)  # pyright: ignore[reportArgumentType]
 
-    def _objective(
-        self, alpha: np.ndarray, K: np.ndarray, y: np.ndarray
-    ) -> float:
-        """Objective function minimizing log-likelihood plus regularization."""
-        f = K @ alpha
-        yf = y * f
-        log_likelihood = np.sum(np.log(1 + np.exp(-yf)))
-        regularization = (1.0 / (2.0 * self.C)) * (alpha.T @ K @ alpha)
-        return log_likelihood + regularization
-
-    def _gradient(
-        self, alpha: np.ndarray, K: np.ndarray, y: np.ndarray
-    ) -> np.ndarray:
-        """Gradient of the objective function."""
-        f = K @ alpha
-        yf = y * f
+    def _objective_and_gradient(
+        self,
+        alpha: np.ndarray,
+        K: np.ndarray,
+        y: np.ndarray,
+    ) -> tuple[float, np.ndarray]:
+        """Objective and gradient for L-BFGS-B optimization.
+
+        Returns both to avoid redundant K @ alpha computation.
+        """
+        Ka = K @ alpha
+        yf = y * Ka
+        log_likelihood = np.sum(np.logaddexp(0, -yf))
+        regularization = (1.0 / (2.0 * self.C)) * (alpha.T @ Ka)
+        objective = log_likelihood + regularization
+
         sigmoid_neg_yf = self._sigmoid(-yf)
         grad_log_likelihood = -K.T @ (y * sigmoid_neg_yf)
-        grad_regularization = (1.0 / self.C) * (K @ alpha)
-        return grad_log_likelihood + grad_regularization
+        grad_regularization = (1.0 / self.C) * Ka
+        gradient = grad_log_likelihood + grad_regularization
+
+        return objective, gradient
 
     def fit(
         self, X: Union[List[nx.Graph], np.ndarray, csr_array], y: np.ndarray
@@ -172,14 +170,14 @@ def fit(
             K = self.centerer_.transform(K)
 
         self.kernel_ = K
-        alpha_init = np.zeros(len(X))
+        alpha_init = np.zeros(K.shape[0])
 
         result = minimize(
-            fun=self._objective,
+            fun=self._objective_and_gradient,
             x0=alpha_init,
             args=(K, y),
             method="L-BFGS-B",
-            jac=self._gradient,
+            jac=True,
             options={"maxiter": self.max_iter, "ftol": self.tol},
         )
 

polygraph/metrics/vun.py

@@ -28,8 +28,11 @@
 """
 
 import json
-import signal
 from collections import defaultdict
+from concurrent.futures import (
+    ThreadPoolExecutor,
+    TimeoutError as FuturesTimeoutError,
+)
 from functools import partial
 from multiprocessing import Pool
 from typing import (
@@ -76,34 +79,23 @@ def __repr__(self) -> str:
         )
 
 
-class _IsomorphismTimeout(Exception):
-    pass
-
-
-def _timeout_handler(signum, frame):
-    raise _IsomorphismTimeout()
-
-
 def _is_isomorphic_with_timeout(
     g: nx.Graph,
     h: nx.Graph,
     timeout: int,
 ) -> bool:
-    """Run isomorphism check with a SIGALRM timeout.
+    """Run isomorphism check with a timeout.
 
     If the check exceeds ``timeout`` seconds, conservatively returns True
-    (i.e. treats the pair as isomorphic).
+    (i.e. treats the pair as isomorphic). This is safe for novelty/
+    uniqueness metrics because it can only decrease the reported score.
     """
-    old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
-    signal.alarm(timeout)
-    try:
-        result = nx.is_isomorphic(g, h)
-    except _IsomorphismTimeout:
-        result = True
-    finally:
-        signal.alarm(0)
-        signal.signal(signal.SIGALRM, old_handler)
-    return result
+    with ThreadPoolExecutor(max_workers=1) as executor:
+        future = executor.submit(nx.is_isomorphic, g, h)
+        try:
+            return future.result(timeout=timeout)
+        except FuturesTimeoutError:
+            return True
 
 
 class _GraphSet:
@@ -138,32 +130,29 @@ def __contains__(self, g: nx.Graph) -> bool:
         return False
 
 
-# ---------------------------------------------------------------------------
-# Parallel worker functions (must be importable, not in __main__)
-# ---------------------------------------------------------------------------
-
-
 def _check_novel_worker(
     gen_graph_json: str,
     train_graphs_json: List[str],
     train_hashes: Dict[str, List[int]],
     iso_timeout: int,
 ) -> bool:
     """Check if a single generated graph is novel (not in training set)."""
-    g = nx.node_link_graph(json.loads(gen_graph_json))
+    g = nx.node_link_graph(json.loads(gen_graph_json), edges="links")
     fp = nx.weisfeiler_lehman_graph_hash(g)
     if fp not in train_hashes:
         return True
     for idx in train_hashes[fp]:
-        h = nx.node_link_graph(json.loads(train_graphs_json[idx]))
+        h = nx.node_link_graph(
+            json.loads(train_graphs_json[idx]), edges="links"
+        )
         if _is_isomorphic_with_timeout(g, h, iso_timeout):
             return False
     return True
 
 
 def _check_validity_worker(graph_json: str, validity_fn: Callable) -> bool:
     """Check validity of a single graph in a worker process."""
-    g = nx.node_link_graph(json.loads(graph_json))
+    g = nx.node_link_graph(json.loads(graph_json), edges="links")
     return validity_fn(g)
 
 
@@ -215,9 +204,13 @@ def _compute_novel_parallel(
         self, generated_graphs: List[nx.Graph]
     ) -> List[bool]:
         train_json = [
-            json.dumps(nx.node_link_data(g)) for g in self._train_graphs
+            json.dumps(nx.node_link_data(g, edges="links"))
+            for g in self._train_graphs
+        ]
+        gen_json = [
+            json.dumps(nx.node_link_data(g, edges="links"))
+            for g in generated_graphs
         ]
-        gen_json = [json.dumps(nx.node_link_data(g)) for g in generated_graphs]
         worker_fn = partial(
             _check_novel_worker,
             train_graphs_json=train_json,
@@ -230,7 +223,10 @@ def _compute_novel_parallel(
     def _compute_valid_parallel(
         self, generated_graphs: List[nx.Graph]
     ) -> List[bool]:
-        gen_json = [json.dumps(nx.node_link_data(g)) for g in generated_graphs]
+        gen_json = [
+            json.dumps(nx.node_link_data(g, edges="links"))
+            for g in generated_graphs
+        ]
         assert self._validity_fn is not None
         worker_fn = partial(
             _check_validity_worker, validity_fn=self._validity_fn

polygraph/utils/descriptors/generic_descriptors.py

@@ -669,8 +669,7 @@ def _get_node_labels(self, graph: nx.Graph) -> Optional[dict]:
         if self.node_label_key is None:
             return None
         return {
-            u: str(graph.nodes[u].get(self.node_label_key, "__UNK__"))
-            for u in graph.nodes()
+            u: str(graph.nodes[u][self.node_label_key]) for u in graph.nodes()
         }
 
     def _hash_feature_key(
@@ -868,17 +867,14 @@ def _compute_features(self, graph: nx.Graph) -> dict:
             feats = [d for _, d in graph.degree()]
             feats = np.array(feats).reshape(-1, 1)
         else:
-            try:
-                feats_list = []
-                for _, data in graph.nodes(data=True):
-                    val = data.get(self.node_label_key, 0)
-                    if isinstance(val, (list, np.ndarray)):
-                        feats_list.append(val)
-                    else:
-                        feats_list.append([val])
-                feats = np.array(feats_list)
-            except Exception:
-                return {}
+            feats_list = []
+            for _, data in graph.nodes(data=True):
+                val = data[self.node_label_key]
+                if isinstance(val, (list, np.ndarray)):
+                    feats_list.append(val)
+                else:
+                    feats_list.append([val])
+            feats = np.array(feats_list)
 
         if len(feats) == 0:
             return {}

polygraph/utils/io.py

@@ -9,6 +9,8 @@
 from pathlib import Path
 from typing import Any, Mapping, Optional
 
+import numpy as np
+
 
 def _json_default(obj: Any) -> Any:
     """Fallback serializer for ``json.dumps``.
@@ -18,11 +20,8 @@ def _json_default(obj: Any) -> Any:
     """
     if isinstance(obj, (dt.datetime, dt.date)):
         return obj.isoformat()
-    if hasattr(obj, "item"):
-        try:
-            return obj.item()
-        except Exception:
-            return str(obj)
+    if isinstance(obj, np.generic):
+        return obj.item()
     if isinstance(obj, Path):
         return str(obj)
     return str(obj)