diff --git a/docs/examples/HammingGraph.nblink b/docs/examples/HammingGraph.nblink new file mode 100644 index 00000000..8c821b13 --- /dev/null +++ b/docs/examples/HammingGraph.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/HammingGraph.ipynb"} \ No newline at end of file diff --git a/docs/examples/examples.rst b/docs/examples/examples.rst index e65f501a..6e600208 100644 --- a/docs/examples/examples.rst +++ b/docs/examples/examples.rst @@ -9,6 +9,7 @@ Spaces Custom Spaces and Kernels Graph GraphEdges + HammingGraph Hyperbolic HypercubeGraph Hypersphere diff --git a/docs/index.rst b/docs/index.rst index 2970d9bd..d5698e32 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -32,11 +32,13 @@ Before doing anything, you might want to create and activate a new virtual envir .. code-block:: bash uv venv --python python[version] [venv_dir] + where [env_dir] is the directory (default is `.venv`) of the environment and [version] is the version of Python you want to use, we currently support 3.9, 3.10, 3.11, 3.12. [Optional] activate the environment. However, this is not strictly necessary for `uv`. Instead, use tools like `uv run python` to run Python inside the environment. See `uv documentation ` for more details. .. code-block:: bash + source [venv_dir]/bin/activate .. raw:: html diff --git a/docs/references.bib b/docs/references.bib index 0328bfa3..3fe5dc02 100644 --- a/docs/references.bib +++ b/docs/references.bib @@ -152,4 +152,11 @@ @article{sawyer1992 title = {The heat equation on the spaces of positive definite matrices}, volume = {44}, year = {1992}, +} + +@inproceedings{doumont2025, + title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization}, + author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss}, + booktitle = {Advances in Neural Information Processing Systems}, + year = {2025}, } \ No newline at end of file diff --git a/docs/theory/hamming_graph.rst b/docs/theory/hamming_graph.rst new file mode 100644 index 00000000..bba9cf61 --- /dev/null +++ b/docs/theory/hamming_graph.rst @@ -0,0 +1,113 @@ +################################ + Kernels on the Hamming Graph +################################ + +.. warning:: + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following the respective :doc:`example notebook `. + + This is optional material meant to explain the basic theory and based mainly on :cite:t:`doumont2025` and :cite:t:`borovitskiy2023`. + +========================== +Motivation +========================== + +The :class:`~.spaces.HammingGraph` space $H(d,q)$ can be used to model $d$-dimensional *categorical vector* inputs, where each component takes values in $\{0, 1, ..., q-1\}$. + +There are many settings where inputs are categorical vectors or can be represented as such. For instance, DNA sequences (with $q=4$ for A, C, G, T), protein sequences (with $q=20$ for the standard amino acids), or error-correcting codes over finite alphabets. When $q=2$, the Hamming graph reduces to the hypercube graph $C^d$ (see :doc:`HypercubeGraph `), which represents binary vectors. + +========================== +Structure of the Space +========================== + +The elements of this space—given its `dim` is $d \in \mathbb{Z}_{>0}$ and `n_cat` is $q \in \mathbb{Z}_{>1}$—are exactly the categorical vectors of length $d$ where each component is in $\{0, 1, ..., q-1\}$. + +The geometry of this space is simple: it is a graph such that $x, x' \in H(d,q)$ are connected by an edge if and only if they differ in exactly one coordinate (i.e. *Hamming distance* $1$ between them is exactly $1$). + +Being a graph, $H(d,q)$ could also be represented using the general :class:`~.spaces.Graph` space. +However, the number of nodes in $H(d,q)$ is $q^d$, which is exponential in $d$ (and grows rapidly with $q$), rendering the general graph representation intractable in most cases. + +========================== +Eigenfunctions +========================== + +On graphs, kernels are computed using the eigenfunctions and eigenvalues of the Laplacian. + +The eigenfunctions of the Laplacian on the Hamming graph are the *Vilenkin functions* (also known as *generalized Walsh functions*) [#]_. These are characters of the Abelian group $\mathbb{Z}_q^d$ and can be expressed using $q$-th roots of unity. + +The Vilenkin functions $\psi_{\mathbf{s}}$ are indexed by frequency vectors $\mathbf{s} = (s_0, \ldots, s_{d-1})$ where each $s_i \in \{0, 1, \ldots, q-1\}$, and take the form +$$ +\psi_{\mathbf{s}}(x_0, \ldots, x_{d-1}) = \prod_{i=0}^{d-1} \omega_q^{s_i x_i} +$$ +where $\omega_q = e^{2\pi i/q}$ is a primitive $q$-th root of unity and $x = (x_0, \ldots, x_{d-1}) \in H(d,q)$. + +The eigenfunctions with the same number of non-zero frequency components $j = \lvert\{i : s_i \neq 0\}\rvert$ share the same eigenvalue $\lambda_j = \frac{q j}{(q-1)d}$ and form a *level* $j$. The dimension of level $j$ is $\binom{d}{j}(q-1)^j$. + +However, the problem is that the number of eigenfunctions is $q^d$. +Hence naive truncation of the sum in the kernel formula to a few hundred terms leads to a poor approximation of the kernel for larger $d$ or $q$. + +**Note:** Direct evaluation of Vilenkin functions is not currently implemented for $q > 2$, but this is not required for kernel computation thanks to the addition theorem below. + +========================== +Addition Theorem +========================== + +Much like for hyperspheres and hypercube graphs, there is an :doc:`addition theorem ` for the Hamming graph: + +$$ +\sum_{\substack{T \subseteq \{0, .., d-1\} \\ \lvert T \rvert = j}} \sum_{\alpha \in \{1,..,q-1\}^T} \psi_{T,\alpha}(x) \overline{\psi_{T,\alpha}(x')} += +\binom{d}{j} (q-1)^j +\widetilde{K}_{d, q, j}(m) +$$ + +where $\psi_{T,\alpha}$ denotes the Vilenkin function indexed by the subset $T$ with frequency values $\alpha = (\alpha_i)_{i \in T}$, $m$ is the Hamming distance between $x$ and $x'$, and $\widetilde{K}_{d, q, j}(m)$ is the generalized Kravchuk polynomial of degree $d$, alphabet size $q$, and order $j$, normalized such that $\widetilde{K}_{d, q, j}(0) = 1$. + +Normalized generalized Kravchuk polynomials $\widetilde{K}_{d, q, j}(m)$ satisfy the following three-term recurrence relation: +$$ +\widetilde{K}_{d, q, j}(m) += +\frac{d(q-1) - qm + q - j(q-1)}{(d - j + 1)(q-1)} \widetilde{K}_{d, q, j-1}(m) +- \frac{j-1}{d - j + 1} \widetilde{K}_{d, q, j-2}(m) +$$ +with initial conditions: +$$ +\widetilde{K}_{d, q, 0}(m) = 1, +\quad +\widetilde{K}_{d, q, 1}(m) = 1 - \frac{q}{(q-1)d} m, +$$ +which allows for their efficient computation without the need to compute large sums of the individual Vilenkin functions. + +With that, the kernels on the Hamming graph can be computed efficiently using the formula: +$$ +k_{\nu, \kappa}(x, x') += +\frac{1}{C_{\nu, \kappa}} +\sum_{j=0}^{L-1} +\Phi_{\nu, \kappa}(\lambda_j) +\binom{d}{j} (q-1)^j \widetilde{K}_{d, q, j}(m) +\qquad +\Phi_{\nu, \kappa}(\lambda) += +\begin{cases} +\left(\frac{2\nu}{\kappa^2} + \lambda\right)^{-\nu-\frac{d}{2}} +& +\nu < \infty \text{ — Matérn} +\\ +e^{-\frac{\kappa^2}{2} \lambda} +& +\nu = \infty \text{ — Heat (RBF)} +\end{cases} +$$ +where $m$ is the Hamming distance between $x$ and $x'$, and $L \leq d + 1$ is the user-controlled number of levels parameter. + +**Notes:** + +#. We define the dimension of the :class:`~.spaces.HammingGraph` space $H(d,q)$ to be $d$, in contrast to the graphs represented by the :class:`~.spaces.Graph` space, whose dimension is defined to be $0$. + + Because of this, much like in the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ *are* in fact reasonable values for the smoothness parameter $\nu$. + +#. When $q=2$, the Hamming graph $H(d,2)$ is isomorphic to the hypercube graph $C^d$, and the generalized Kravchuk polynomials reduce to the standard Kravchuk polynomials ($q=2$). + +.. rubric:: Footnotes + +.. [#] Since the Hamming graph $H(d,q)$ is $(q-1)d$-regular, the unnormalized Laplacian and the symmetric normalized Laplacian coincide up to a multiplication by $(q-1)d$. Thus their eigenfunctions are the same and eigenvalues coincide up to this multiplication. For better numerical stability, we use symmetric normalized Laplacian in the implementation and assume its use throughout this page. diff --git a/docs/theory/index.rst b/docs/theory/index.rst index 71916b75..c6d37f68 100644 --- a/docs/theory/index.rst +++ b/docs/theory/index.rst @@ -14,3 +14,4 @@ Product kernels Feature maps and sampling Hypercube graph space + Hamming graph space diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index 2956a6a4..3b839d90 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -109,7 +109,7 @@ def __call__( weights = B.power(spectrum, 0.5) # [L, 1] - random_phases_b = B.cast(dtype, from_numpy(X, random_phases)) + random_phases_b = B.cast(B.dtype(X), from_numpy(X, random_phases)) phi_product = self.eigenfunctions.phi_product( X, random_phases_b, **params diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index c404c291..890a4dec 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -15,4 +15,7 @@ MaternGeometricKernel, default_feature_map, ) +from geometric_kernels.kernels.matern_kernel_hamming_graph import ( + MaternKernelHammingGraph, +) from geometric_kernels.kernels.product import ProductGeometricKernel diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 8a63aafb..0fe8795a 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -21,11 +21,15 @@ from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.matern_kernel_hamming_graph import ( + MaternKernelHammingGraph, +) from geometric_kernels.spaces import ( CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, GraphEdges, + HammingGraph, HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, @@ -76,7 +80,7 @@ def default_feature_map( @overload def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): - if isinstance(kernel.space, CompactMatrixLieGroup): + if isinstance(kernel.space, (CompactMatrixLieGroup, HammingGraph)): # Because `CompactMatrixLieGroup` does not currently support explicit # eigenfunction computation (they only support addition theorem). return RandomPhaseFeatureMapCompact( @@ -136,7 +140,7 @@ def feature_map_from_kernel(kernel: BaseGeometricKernel): @overload def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): - if isinstance(space, CompactMatrixLieGroup): + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): return RandomPhaseFeatureMapCompact( space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) @@ -212,7 +216,7 @@ def default_num(space: DiscreteSpectrumSpace) -> int: ) elif isinstance(space, GraphEdges): return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) - elif isinstance(space, HypercubeGraph): + elif isinstance(space, (HypercubeGraph, HammingGraph)): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: return MaternGeometricKernel._DEFAULT_NUM_LEVELS @@ -289,6 +293,7 @@ def __new__( :param space: Space to construct the kernel on. + :param num: If provided, controls the "order of approximation" of the kernel. For the discrete spectrum spaces, this means the number of "levels" @@ -302,6 +307,7 @@ def __new__( If num=None, we use a (hopefully) reasonable default, which is space-dependent. + :param normalize: Normalize the kernel (and the feature map). If normalize=True, then either $k(x, x) = 1$ for all $x \in X$, where $X$ is the @@ -339,6 +345,8 @@ def __new__( num = num or default_num(space) if isinstance(space, HodgeDiscreteSpectrumSpace): kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) + elif isinstance(space, (HypercubeGraph, HammingGraph)): + kernel = MaternKernelHammingGraph(space, num, normalize=normalize) else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: diff --git a/geometric_kernels/kernels/matern_kernel_hamming_graph.py b/geometric_kernels/kernels/matern_kernel_hamming_graph.py new file mode 100644 index 00000000..a262429c --- /dev/null +++ b/geometric_kernels/kernels/matern_kernel_hamming_graph.py @@ -0,0 +1,96 @@ +r""" +This module provides the :class:`MaternKernelHammingGraph` kernel, a subclass of +:class:`MaternKarhunenLoeveKernel` for :class:`HammingGraph` and +:class:`HypercubeGraph` spaces implementing the closed-form formula for the +heat kernel when $\nu = \infty$. +""" + +import lab as B +import numpy as np +from beartype.typing import Dict, Optional, Union + +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.spaces.eigenfunctions import Eigenfunctions +from geometric_kernels.spaces.hamming_graph import HammingGraph +from geometric_kernels.spaces.hypercube_graph import HypercubeGraph +from geometric_kernels.utils.kernel_formulas.hamming_graph import ( + hamming_graph_heat_kernel, +) +from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params + + +class MaternKernelHammingGraph(MaternKarhunenLoeveKernel): + r""" + For $\nu = \infty$, there exists a closed-form formula for the heat kernel + on hamming graphs :class:`HammingGraph` (including the binary hypercube case + :class:`HypercubeGraph`). This class extends :class:`MaternKarhunenLoeveKernel` + to implement this formula in the case of $\nu = \infty$ for efficiency. + + .. note:: + We only use the closed form expression if `num_levels` is `d + 1` which + corresponds to exact computation. When truncated to fewer levels, we + must use the parent class implementation to ensure consistency with + feature map approximations. + """ + + def __init__( + self, + space: Union[HammingGraph, HypercubeGraph], + num_levels: int, + normalize: bool = True, + eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, + ): + if not isinstance(space, (HammingGraph, HypercubeGraph)): + raise ValueError( + f"`space` must be an instance of HammingGraph or HypercubeGraph, but got {type(space)}" + ) + + super().__init__( + space, + num_levels, + normalize, + eigenvalues_laplacian, + eigenfunctions, + ) + + def K( + self, + params: Dict[str, B.Numeric], + X: B.Numeric, + X2: Optional[B.Numeric] = None, + **kwargs, + ) -> B.Numeric: + _check_field_in_params(params, "lengthscale") + _check_1_vector(params["lengthscale"], 'params["lengthscale"]') + + _check_field_in_params(params, "nu") + _check_1_vector(params["nu"], 'params["nu"]') + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + # Get q from space (HammingGraph has n_cat, HypercubeGraph is binary q=2) + q = getattr(self.space, "n_cat", 2) + + return hamming_graph_heat_kernel(params["lengthscale"], X, X2, q=q) + + return super().K(params, X, X2, **kwargs) + + def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: + _check_field_in_params(params, "lengthscale") + _check_1_vector(params["lengthscale"], 'params["lengthscale"]') + + _check_field_in_params(params, "nu") + _check_1_vector(params["nu"], 'params["nu"]') + + if B.all(params["nu"] == np.inf): + d = X.shape[-1] + + # Only use fast path when we have all levels (exact computation) + if self.num_levels == d + 1: + return B.ones(B.dtype(params["nu"]), X.shape[0]) + + return super().K_diag(params, X, **kwargs) diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index 700b75a5..36db926e 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -12,6 +12,7 @@ from geometric_kernels.spaces.circle import Circle from geometric_kernels.spaces.graph import Graph from geometric_kernels.spaces.graph_edges import GraphEdges +from geometric_kernels.spaces.hamming_graph import HammingGraph from geometric_kernels.spaces.hyperbolic import Hyperbolic from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.spaces.hypersphere import Hypersphere diff --git a/geometric_kernels/spaces/hamming_graph.py b/geometric_kernels/spaces/hamming_graph.py new file mode 100644 index 00000000..1cc46037 --- /dev/null +++ b/geometric_kernels/spaces/hamming_graph.py @@ -0,0 +1,323 @@ +""" +This module provides the :class:`HammingGraph` space and the respective +:class:`~.eigenfunctions.Eigenfunctions` subclass :class:`VilenkinFunctions`. +""" + +from math import comb + +import lab as B +import numpy as np +from beartype.typing import List, Optional + +from geometric_kernels.lab_extras import dtype_integer, float_like +from geometric_kernels.spaces.base import DiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import ( + Eigenfunctions, + EigenfunctionsWithAdditionTheorem, +) +from geometric_kernels.utils.special_functions import generalized_kravchuk_normalized +from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial + + +class VilenkinFunctions(EigenfunctionsWithAdditionTheorem): + r""" + Eigenfunctions of the graph Laplacian on the q-ary Hamming graph $H(d,q)$, whose + nodes are indexed by categorical vectors in $\{0, 1, ..., q-1\}^d$. + + These eigenfunctions are the Vilenkin functions (also called Vilenkin-Chrestenson + functions), which generalize the binary Walsh functions to q-ary alphabets. They + map vertices to complex values via products of characters on cyclic groups. + + For the special case $q = 2$, the Vilenkin functions reduce to the Walsh functions + on the binary hypercube $\{0, 1\}^d$. + + .. note:: + The Vilenkin functions can be indexed by "character patterns" - choices of + coordinates and non-identity characters at those coordinates. Each eigenspace + (level) $j$ has dimension $\binom{d}{j}(q-1)^j$, corresponding to choosing + $j$ coordinates and assigning $(q-1)$ possible non-identity characters to each. + + Levels are the whole eigenspaces, comprising all Vilenkin functions with the + same number of coordinates having non-identity characters. The addition theorem + for these is based on generalized Kravchuk polynomials, i.e. discrete orthogonal + polynomials on the q-ary Hamming scheme. + + :param dim: + Dimension $d$ of the q-ary Hamming graph $H(d,q)$. + + :param n_cat: + Number of categories $q \geq 2$ in the q-ary alphabet $\{0, 1, ..., q-1\}$. + + :param num_levels: + Specifies the number of levels (eigenspaces) of the Vilenkin functions to use. + """ + + def __init__(self, dim: int, n_cat: int, num_levels: int) -> None: + if num_levels > dim + 1: + raise ValueError("The number of levels should be at most `dim`+1.") + self.dim = dim + self.n_cat = n_cat + self._num_levels = num_levels + self._num_eigenfunctions: Optional[int] = None # To be computed when needed. + + if n_cat < 2: + raise ValueError("n_cat must be at least 2.") + + def __call__(self, X: B.Int, **kwargs) -> B.Float: + raise NotImplementedError + + def _addition_theorem( + self, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs + ) -> B.Numeric: + + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + values = [] + + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = generalized_kravchuk_normalized( + self.dim, + level, + hamming_distances, + self.n_cat, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) # [N, N2] + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + values.append( + comb(self.dim, level) + * (self.n_cat - 1) ** level + * cur_kravchuk_normalized[..., None] + ) # [N, N2, 1] + + return B.concat(*values, axis=-1) # [N, N2, L] + + def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: + """ + These are certain easy to compute constants. + """ + values = [ + comb(self.dim, level) + * (self.n_cat - 1) ** level + * B.ones(float_like(X), *X.shape[:-1], 1) # [N, 1] + for level in range(self.num_levels) + ] + return B.concat(*values, axis=1) # [N, L] + + def weighted_outerproduct( + self, + weights: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, # type: ignore + **kwargs, + ) -> B.Numeric: + if X2 is None: + X2 = X + + hamming_distances = hamming_distance(X, X2) + + result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] + kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None + for level in range(self.num_levels): + cur_kravchuk_normalized = generalized_kravchuk_normalized( + self.dim, + level, + hamming_distances, + self.n_cat, + kravchuk_normalized_j_minus_1, + kravchuk_normalized_j_minus_2, + ) + kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + # Furthermore, we save the computed Kravchuk polynomials for next iterations. + result += ( + B.exp( + B.log(weights[level]) + + log_binomial(self.dim, level) + + level * B.log(self.n_cat - 1) + ) + * cur_kravchuk_normalized + ) + + return result # [N, N2] + + def weighted_outerproduct_diag( + self, weights: B.Numeric, X: B.Numeric, **kwargs + ) -> B.Numeric: + + # Instead of multiplying weights by binomial coefficients, we sum their + # logs and then exponentiate the result for numerical stability. + result = sum( + B.exp( + B.log(weights[level]) + + log_binomial(self.dim, level) + + level * B.log(self.n_cat - 1) + ) + * B.ones(float_like(X), *X.shape[:-1], 1) + for level in range(self.num_levels) + ) # [N, 1] + + return B.reshape(result, *result.shape[:-1]) # [N,] + + @property + def num_eigenfunctions(self) -> int: + if self._num_eigenfunctions is None: + self._num_eigenfunctions = sum(self.num_eigenfunctions_per_level) + return self._num_eigenfunctions + + @property + def num_levels(self) -> int: + return self._num_levels + + @property + def num_eigenfunctions_per_level(self) -> List[int]: + return [ + comb(self.dim, level) * (self.n_cat - 1) ** level + for level in range(self.num_levels) + ] + + +class HammingGraph(DiscreteSpectrumSpace): + r""" + The GeometricKernels space representing the q-ary Hamming graph + $H(d,q) = \{0, 1, ..., q-1\}^d$, the combinatorial space of categorical + vectors (with $q$ categories) of length $d$. + + The elements of this space are represented by d-dimensional categorical vectors + (with $q$ categories) taking integer values in $\{0, 1, ..., q-1\}$. + + Levels are the whole eigenspaces. + + .. note:: + If you need a kernel operating on categorical vectors where $q$ varies + between dimensions, you can use `HammingGraph` in conjunction with + :class:`ProductGeometricKernel` or :class:`ProductDiscreteSpectrumSpace`. + + .. note:: + For the special case $q = 2$, this reduces to the binary hypercube graph, + also available as :class:`HypercubeGraph`. + + .. note:: + A tutorial on how to use this space is available in the + :doc:`HammingGraph.ipynb ` notebook. + + .. note:: + Since the degree matrix is a constant multiple of the identity, all + types of the graph Laplacian coincide on the Hamming graph up to a + constant, we choose the normalized Laplacian for numerical stability. + + :param dim: + Dimension $d$ of the Hamming graph $H(d,q)$, a positive integer. + + :param n_cat: + Number of categories $q$ of the Hamming graph $H(d,q)$, a positive + integer $q \geq 2$. + + .. admonition:: Citation + + If you use this GeometricKernels space in your research, please consider + citing :cite:t:`borovitskiy2023` and :cite:t:`doumont2025`. + """ + + def __init__(self, dim: int, n_cat: int): + if dim < 1: + raise ValueError("dim must be a positive integer.") + if n_cat < 1: + raise ValueError("n_cat must be a positive integer.") + self.dim = dim + self.n_cat = n_cat + + def __str__(self): + return f"HammingGraph({self.dim},{self.n_cat})" + + @property + def dimension(self) -> int: + """ + Returns d, the `dim` parameter that was passed down to `__init__`. + + .. note: + Although this is a graph, and graphs are generally treated as + 0-dimensional throughout GeometricKernels, we make an exception for + HammingGraph. This is because it helps maintain good behavior of + Matérn kernels with the usual values of the smoothness parameter + nu, i.e. nu = 1/2, nu = 3/2, nu = 5/2. + """ + return self.dim + + def get_eigenfunctions(self, num: int) -> Eigenfunctions: + """ + Returns the :class:`~.VilenkinFunctions` object with `num` levels. + + :param num: + Number of levels. + """ + return VilenkinFunctions(self.dim, self.n_cat, num) + + def get_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues = np.array( + [ + (self.n_cat * level) + / ( + self.dim * (self.n_cat - 1) + ) # we assume normalized Laplacian (for numerical stability) + for level in range(num) + ] + ) + return B.reshape(eigenvalues, -1, 1) # [num, 1] + + def get_repeated_eigenvalues(self, num: int) -> B.Numeric: + eigenvalues_per_level = self.get_eigenvalues(num) + + eigenfunctions = VilenkinFunctions(self.dim, self.n_cat, num) + eigenvalues = chain( + B.squeeze(eigenvalues_per_level), + eigenfunctions.num_eigenfunctions_per_level, + ) # [J,] + return B.reshape(eigenvalues, -1, 1) # [J, 1] + + def random(self, key: B.RandomState, number: int) -> B.Numeric: + r""" + Sample uniformly random points on the Hamming graph $H(d,q)$. + + Always returns [N, D] integer array of the `key`'s backend with values + in $\{0, 1, ..., q-1\}$. + + :param key: + Either `np.random.RandomState`, `tf.random.Generator`, + `torch.Generator` or `jax.tensor` (representing random state). + :param number: + Number N of samples to draw. + + :return: + An array of `number` uniformly random samples on the space. + """ + key, random_points = B.random.randint( + key, dtype_integer(key), number, self.dimension, lower=0, upper=self.n_cat + ) + + return key, random_points + + @property + def element_shape(self): + """ + :return: + [d]. + """ + return [self.dimension] + + @property + def element_dtype(self): + """ + :return: + B.Int. + """ + return B.Int diff --git a/geometric_kernels/spaces/hypercube_graph.py b/geometric_kernels/spaces/hypercube_graph.py index f81f41ab..f0cb8030 100644 --- a/geometric_kernels/spaces/hypercube_graph.py +++ b/geometric_kernels/spaces/hypercube_graph.py @@ -17,7 +17,7 @@ EigenfunctionsWithAdditionTheorem, ) from geometric_kernels.utils.special_functions import ( - kravchuk_normalized, + generalized_kravchuk_normalized, walsh_function, ) from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial @@ -74,10 +74,11 @@ def _addition_theorem( kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for level in range(self.num_levels): - cur_kravchuk_normalized = kravchuk_normalized( + cur_kravchuk_normalized = generalized_kravchuk_normalized( self.dim, level, hamming_distances, + 2, kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2, ) # [N, N2] @@ -115,10 +116,11 @@ def weighted_outerproduct( result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for level in range(self.num_levels): - cur_kravchuk_normalized = kravchuk_normalized( + cur_kravchuk_normalized = generalized_kravchuk_normalized( self.dim, level, hamming_distances, + 2, kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2, ) diff --git a/geometric_kernels/utils/kernel_formulas/__init__.py b/geometric_kernels/utils/kernel_formulas/__init__.py index 82bca600..43d338f1 100644 --- a/geometric_kernels/utils/kernel_formulas/__init__.py +++ b/geometric_kernels/utils/kernel_formulas/__init__.py @@ -4,6 +4,9 @@ euclidean_matern_52_kernel, euclidean_rbf_kernel, ) +from geometric_kernels.utils.kernel_formulas.hamming_graph import ( + hamming_graph_heat_kernel, +) from geometric_kernels.utils.kernel_formulas.hyperbolic import ( hyperbolic_heat_kernel_even, hyperbolic_heat_kernel_odd, diff --git a/geometric_kernels/utils/kernel_formulas/hamming_graph.py b/geometric_kernels/utils/kernel_formulas/hamming_graph.py new file mode 100644 index 00000000..487752c3 --- /dev/null +++ b/geometric_kernels/utils/kernel_formulas/hamming_graph.py @@ -0,0 +1,63 @@ +""" +Implements the closed form expression for the heat kernel on the Hamming graph. + +The implementation is provided mainly for testing purposes. +""" + +from math import sqrt + +import lab as B +from beartype.typing import Optional + +from geometric_kernels.lab_extras import float_like +from geometric_kernels.utils.utils import _check_1_vector, _check_matrix + + +def hamming_graph_heat_kernel( + lengthscale: B.Numeric, + X: B.Numeric, + X2: Optional[B.Numeric] = None, + q: int = 2, + normalized_laplacian: bool = True, +): + """ + Analytic formula for the heat kernel on the Hamming graph, see + Equation (3) in :cite:t:`doumont2025`. + + :param lengthscale: + The length scale of the kernel, an array of shape [1]. + :param X: + A batch of inputs, an array of shape [N, d]. + :param X2: + A batch of inputs, an array of shape [N2, d]. If None, defaults to X. + :param q: + The alphabet size (number of categories). Defaults to 2 (hypercube). + :param normalized_laplacian: + Whether to use normalized Laplacian scaling. + + :return: + The kernel matrix, an array of shape [N, N2]. + """ + if X2 is None: + X2 = X + + _check_1_vector(lengthscale, "lengthscale") + _check_matrix(X, "X") + _check_matrix(X2, "X2") + + d = X.shape[-1] + + if normalized_laplacian: + lengthscale = lengthscale / sqrt(d * (q - 1)) + + beta = lengthscale**2 / 2 + + # Compute disagreement indicator: 1 when coordinates differ, 0 when they match + # Shape: [N, N2, d] + disagreement = B.cast(float_like(X), X[:, None, :] != X2[None, :, :]) + + exp_neg_beta_q = B.exp(-beta * q) + factor_disagree = (1 - exp_neg_beta_q) / (1 + (q - 1) * exp_neg_beta_q) + log_kernel = B.sum(B.log(factor_disagree) * disagreement, axis=-1) + + return B.exp(log_kernel) # Shape: [N, N2] diff --git a/geometric_kernels/utils/special_functions.py b/geometric_kernels/utils/special_functions.py index 41189737..c691f349 100644 --- a/geometric_kernels/utils/special_functions.py +++ b/geometric_kernels/utils/special_functions.py @@ -45,53 +45,68 @@ def walsh_function(d: int, combination: List[int], x: B.Bool) -> B.Float: return (-1) ** count_nonzero(take_along_axis(x, indices, axis=-1), axis=-1) -def kravchuk_normalized( +def generalized_kravchuk_normalized( d: int, j: int, m: B.Int, + q: int, kravchuk_normalized_j_minus_1: Optional[B.Float] = None, kravchuk_normalized_j_minus_2: Optional[B.Float] = None, ) -> B.Float: r""" - This function returns $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the - Kravchuk polynomial defined below. + This function returns $\widetilde{G}_{d, q, j}(m)$ where $\widetilde{G}_{d, q, j}(m)$ is the + normalized generalized Kravchuk polynomial defined below. - Define the Kravchuk polynomial of degree d > 0 and order 0 <= j <= d as the - function $G_{d, j, m}$ of the independent variable 0 <= m <= d given by + Define the generalized Kravchuk polynomial of degree $d > 0$ and order $0 \leq j \leq d$ + as the function $G_{d, q, j}(m)$ of the independent variable $0 \leq m \leq d$ given by - .. math:: G_{d, j, m} = \sum_{T \subseteq \{0, .., d-1\}, |T| = j} w_T(x). + .. math:: G_{d, q, j}(m) = \sum_{\substack{T \subseteq \{0, .., d-1\} \\ |T| = j}} + \sum_{\alpha \in \{1,..,q-1\}^T} \psi_{T,\alpha}(x) \overline{\psi_{T,\alpha}(y)}. - Here $w_T$ are the Walsh functions on the hypercube graph $C^d$ and - $x \in C^d$ is an arbitrary binary vector with $m$ ones (the right-hand side - does not depend on the choice of a particular vector of the kind). + Here $\psi_{T,\alpha}$ are the Vilenkin functions on the q-ary Hamming graph $H(d,q)$ and + $x, y \in \{0, 1, ..., q-1\}^d$ are arbitrary categorical vectors at Hamming distance $m$ + (the right-hand side does not depend on the choice of particular vectors of the kind). + + The normalized polynomial is $\widetilde{G}_{d, q, j}(m) = G_{d, q, j}(m) / G_{d, q, j}(0)$. .. note:: We are using the three term recurrence relation to compute the Kravchuk polynomials. Cf. Equation (60) of Chapter 5 in MacWilliams and Sloane "The - Theory of Error-Correcting Codes", 1977. The parameters q and $\gamma$ - from :cite:t:`macwilliams1977` are set to be q = 2; $\gamma = q - 1 = 1$. + Theory of Error-Correcting Codes", 1977. The parameter $\gamma$ from + :cite:t:`macwilliams1977` is set to $\gamma = q - 1$. + + .. note:: + We use the fact that $G_{d, q, j}(0) = \binom{d}{j}(q-1)^j$. .. note:: - We use the fact that $G_{d, j, 0} = \binom{d}{j}$. + For $q = 2$, this reduces to the classical Kravchuk polynomials. :param d: - The degree of Kravhuk polynomial, an integer d > 0. - Maps to n in :cite:t:`macwilliams1977`. - :param j: d - The order of Kravhuk polynomial, an integer 0 <= j <= d. - Maps to k in :cite:t:`macwilliams1977`. + The degree of Kravchuk polynomial, an integer $d > 0$. + Maps to $n$ in :cite:t:`macwilliams1977`. + + :param j: + The order of Kravchuk polynomial, an integer $0 \leq j \leq d$. + Maps to $k$ in :cite:t:`macwilliams1977`. + :param m: - The independent variable, an integer 0 <= m <= d. - Maps to x in :cite:t:`macwilliams1977`. + The independent variable (Hamming distance), an integer or array with + $0 \leq m \leq d$. Maps to $x$ in :cite:t:`macwilliams1977`. + + :param q: + The alphabet size of the q-ary Hamming graph, an integer $q \geq 2$. + :param kravchuk_normalized_j_minus_1: - The optional precomputed value of $G_{d, j-1, m}/G_{d, j-1, 0}$, helps + The optional precomputed value of $\widetilde{G}_{d, q, j-1}(m)$, helps to avoid exponential complexity growth due to the recursion. + :param kravchuk_normalized_j_minus_2: - The optional precomputed value of $G_{d, j-2, m}/G_{d, j-2, 0}$, helps + The optional precomputed value of $\widetilde{G}_{d, q, j-2}(m)$, helps to avoid exponential complexity growth due to the recursion. :return: - $G_{d, j, m}/G_{d, j, 0}$ where $G_{d, j, m}$ is the Kravchuk polynomial. + $\widetilde{G}_{d, q, j}(m) = G_{d, q, j}(m) / G_{d, q, j}(0)$ where + $G_{d, q, j}(m)$ is the generalized Kravchuk polynomial. """ if d <= 0: raise ValueError("`d` must be positive.") @@ -105,12 +120,20 @@ def kravchuk_normalized( if j == 0: return B.ones(m) elif j == 1: - return 1 - 2 * m / d + return 1 - q * m / (d * (q - 1)) else: if kravchuk_normalized_j_minus_1 is None: - kravchuk_normalized_j_minus_1 = kravchuk_normalized(d, j - 1, m) + kravchuk_normalized_j_minus_1 = generalized_kravchuk_normalized( + d, j - 1, m, q + ) if kravchuk_normalized_j_minus_2 is None: - kravchuk_normalized_j_minus_2 = kravchuk_normalized(d, j - 2, m) - rhs_1 = (d - 2 * m) * kravchuk_normalized_j_minus_1 + kravchuk_normalized_j_minus_2 = generalized_kravchuk_normalized( + d, j - 2, m, q + ) + + rhs_1 = ( + (d - j + 1) * (q - 1) + (j - 1) - q * m + ) * kravchuk_normalized_j_minus_1 rhs_2 = -(j - 1) * kravchuk_normalized_j_minus_2 - return (rhs_1 + rhs_2) / (d - j + 1) + + return (rhs_1 + rhs_2) / ((d - j + 1) * (q - 1)) diff --git a/geometric_kernels/utils/utils.py b/geometric_kernels/utils/utils.py index 452ca8ef..481f6f89 100644 --- a/geometric_kernels/utils/utils.py +++ b/geometric_kernels/utils/utils.py @@ -17,7 +17,6 @@ from geometric_kernels.lab_extras import ( count_nonzero, get_random_state, - logical_xor, restore_random_state, ) @@ -298,7 +297,7 @@ def get_resource_file_path(filename: str): yield path -def hamming_distance(x1: B.Bool, x2: B.Bool): +def hamming_distance(x1: B.Int, x2: B.Int): """ Hamming distance between two batches of boolean vectors. @@ -311,7 +310,7 @@ def hamming_distance(x1: B.Bool, x2: B.Bool): An array of shape [N, M] whose entry n, m contains the Hamming distance between x1[n, :] and x2[m, :]. It is of the same backend as x1 and x2. """ - return count_nonzero(logical_xor(x1[:, None, :], x2[None, :, :]), axis=-1) + return count_nonzero(x1[:, None, :] != x2[None, :, :], axis=-1) def log_binomial(n: B.Int, k: B.Int) -> B.Float: diff --git a/notebooks/HammingGraph.ipynb b/notebooks/HammingGraph.ipynb new file mode 100644 index 00000000..4c3bcd32 --- /dev/null +++ b/notebooks/HammingGraph.ipynb @@ -0,0 +1,758 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Matérn and Heat Kernels on Hamming Graphs\n", + "\n", + "This notebook shows how to define and evaluate kernels on q-ary Hamming graphs $H(d,q)$ for modeling data encoded as categorical vectors with kernels that respect the geometry of the Hamming distance.\n", + "\n", + "**Note:** If you need a kernel operating on categorical vectors where $q$ varies between dimensions, you can use`HammingGraph` in conjunction with [product kernels](https://geometric-kernels.github.io/GeometricKernels/theory/product_kernels.html) or [product spaces](https://geometric-kernels.github.io/GeometricKernels/theory/product_spaces.html).\n", + "\n", + "**Note:** When $q=2$, the Hamming graph $H(d,2)$ reduces to the hypercube graph $C^d = \\{0, 1\\}^d$ (see `HypercubeGraph.ipynb`).\n", + "\n", + "At the very end of the notebook we also show how to construct *approximate finite-dimensional feature maps* for the kernels on the Hamming graph and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "**Note:** the points on the Hamming graph $H(d,q)$ are integer vectors of size $d$ where each component takes values in $\\{0, 1, ..., q-1\\}$ (`array`s of the suitable backend).\n", + "\n", + "We use the **numpy** backend here.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "## Contents\n", + "- [**Basics**](#Basics)\n", + " - [Defining a Space](#Defining-a-Space)\n", + " - [Defining a Kernel](#Defining-a-Kernel)\n", + " - [Evaluating Kernels on Random Inputs](#Evaluating-Kernels-on-Random-Inputs)\n", + " - [Visualizing Kernels](#Visualizing-Kernels)\n", + "- [**Feature Maps and Sampling**](#Feature-Maps-and-Sampling)\n", + " - [Defining a Feature Map](#Defining-a-Feature-Map)\n", + " - [Efficient Sampling using Feature Maps](#Efficient-Sampling-using-Feature-Maps)\n", + "- [**Citation**](#Citation)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basics" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NaG9OvVp-Ryf", + "outputId": "1fbd9363-48ee-4bd0-e214-056a84c64766" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n" + ] + } + ], + "source": [ + "# Import a backend, we use numpy in this example.\n", + "import numpy as np\n", + "\n", + "# Import the geometric_kernels backend.\n", + "import geometric_kernels\n", + "\n", + "# Note: if you are using a backend other than numpy,\n", + "# you _must_ uncomment one of the following lines\n", + "# import geometric_kernels.tensorflow\n", + "# import geometric_kernels.torch\n", + "# import geometric_kernels.jax\n", + "\n", + "# Import a space and an appropriate kernel.\n", + "from geometric_kernels.spaces import HammingGraph\n", + "from geometric_kernels.kernels import MaternGeometricKernel\n", + "\n", + "# We use networkx to visualize graphs\n", + "import networkx as nx\n", + "\n", + "import matplotlib as mpl\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Space" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First we create a GeometricKernels `space` that corresponds to the 4-dimensional ternary Hamming graph $H(4,3)$, where each coordinate takes values in $\\{0, 1, 2\\}$." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [], + "source": [ + "hamming_graph = HammingGraph(4,3)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Defining a Kernel" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we create a generic Matérn kernel.\n", + "\n", + "To initialize `MaternGeometricKernel` you just need to provide a `Space` object, in our case this is the `hamming_graph` we have just created above.\n", + "\n", + "There is also an optional second parameter `num` which determines the order of approximation of the kernel (*number of levels*).\n", + "There is a sensible default value for each of the spaces in the library, so change it only if you know what you are doing.\n", + "\n", + "A brief account on theory behind the kernels on the Hamming graph space can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hamming_graph.html)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(hamming_graph)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To support JAX, our classes do not keep variables you might want to differentiate over in their state.\n", + "Instead, some methods take a `params` dictionary as input, returning its modified version.\n", + "\n", + "The next line initializes the dictionary of kernel parameters `params` with some default values.\n", + "\n", + "**Note:** our kernels do not provide the outputscale/variance parameter frequently used in Gaussian processes.\n", + "However, it is usually trivial to add it by multiplying the kernel by an (optimizable) constant." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'nu': array([inf]), 'lengthscale': array([1.])}\n" + ] + } + ], + "source": [ + "params = kernel.init_params()\n", + "print('params:', params)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To define two different kernels, Matern-3/2 and Matern-∞ (aka heat, RBF, squared exponential, diffusion), we need two different versions of `params` we define below.\n", + "\n", + "**Note:** like in the Euclidean or the manifold case, and unlike the general graph case, the $1/2, 3/2, 5/2$ are reasonable values of $\\nu$." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"lengthscale\"] = np.array([2.0])\n", + "params_32 = params.copy()\n", + "params_inf = params.copy()\n", + "del params\n", + "params_32[\"nu\"] = np.array([3/2])\n", + "\n", + "params_inf[\"nu\"] = np.array([np.inf])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now two kernels are *defined* and we proceed to evaluating both on a set of random inputs." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Evaluating Kernels on Random Inputs" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by sampling `3` (uniformly) random points on our graph.\n", + "An explicit `key` parameter is needed to support JAX as one of the backends." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[[2 1 0 0]\n", + " [0 1 1 1]\n", + " [2 2 2 0]] int32\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = hamming_graph.random(key, 3)\n", + "\n", + "print(xs, xs.dtype)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_inf, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# find common range of values\n", + "minmin = np.min([np.min(kernel_mat_32), np.min(kernel_mat_inf)])\n", + "maxmax = np.max([np.max(kernel_mat_32), np.max(kernel_mat_inf)])\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(nrows=1, ncols=2)\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "ax1.imshow(kernel_mat_32, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax1.set_title('k_32')\n", + "ax1.set_axis_off()\n", + "\n", + "ax2.imshow(kernel_mat_inf, vmin=minmin, vmax=maxmax, cmap=cmap)\n", + "ax2.set_title('k_inf')\n", + "ax2.set_axis_off()\n", + "\n", + "# add space for color bar\n", + "fig.subplots_adjust(right=0.85)\n", + "cbar_ax = fig.add_axes([0.88, 0.25, 0.02, 0.5])\n", + "\n", + "# add colorbar\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=minmin, vmax=maxmax))\n", + "fig.colorbar(sm, cax=cbar_ax)\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualizing Kernels" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we visualize $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points`.\n", + "We define `base_point` and `other_points` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "import itertools\n", + "base_point = np.array([0]*4)[None, :] # choosing a fixed node for kernel visualization\n", + "other_points = np.array([list(i) for i in itertools.product([0, 1, 2], repeat=4)])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_point` $, x)$ for $x \\in $ `other_points` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_32, base_point,\n", + " other_points).flatten()\n", + "values_inf = kernel.K(params_inf, base_point,\n", + " other_points).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We prepare the networkx graph for visualizing the space" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "def hamming_graph_nx(d, q):\n", + " \"\"\"Create q-ary Hamming graph of dimension d.\"\"\"\n", + " G = nx.Graph()\n", + " vertices = list(itertools.product(range(q), repeat=d))\n", + " G.add_nodes_from(range(len(vertices)))\n", + " \n", + " for i, v1 in enumerate(vertices):\n", + " for j, v2 in enumerate(vertices):\n", + " if i < j and sum(a != b for a, b in zip(v1, v2)) == 1:\n", + " G.add_edge(i, j)\n", + " return G\n", + "\n", + "nx_graph = hamming_graph_nx(4, 3) # 81 vertices\n", + "pos = nx.spring_layout(nx_graph, seed=42) # Auto-generate layout" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize the kernels" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(0.0, values_32.min(), values_inf.min())\n", + "vmax = max(1.0, values_32.max(), values_inf.max())\n", + "\n", + "\n", + "# Red outline for the base_point:\n", + "edgecolors = [(0, 0, 0, 0)]*nx_graph.number_of_nodes()\n", + "edgecolors[0] = (1, 0, 0, 1)\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.))\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=values_32,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_aspect(1)\n", + "ax1.set_title('Kernel: $k_{3/2, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values_inf,\n", + " vmin=vmin, vmax=vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_aspect(1)\n", + "ax2.set_title('Kernel: $k_{\\infty, \\kappa}($%s$, \\cdot)$ for $\\cdot$ in nodes' % str(base_point))\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Feature Maps and Sampling\n", + "\n", + "Here we show how to get an approximate finite-dimensional feature map for heat and Matérn kernels on the Hamming graph $H(d,q)$, i.e. such $\\phi$ that\n", + "$$\n", + "k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}.\n", + "$$\n", + "This might be useful for speeding up computations.\n", + "We showcase this below by showing how to efficiently sample the Gaussian process $\\mathrm{GP}(0, k)$.\n", + "\n", + "For a brief theoretical introduction into feature maps, see this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html)." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "tags": [] + }, + "source": [ + "### Defining a Feature Map" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The simplest way to get an approximate finite-dimensional feature map is to use the `default_feature_map` function from `geometric_kernels.kernels`.\n", + "It has an optional keyword argument `num` which determines the number of features, the $M$ above.\n", + "Below we rely on the default value of `num`." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "from geometric_kernels.utils.utils import make_deterministic\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)\n", + "feature_map = make_deterministic(feature_map, key=key)\n", + "\n", + "key, features = feature_map(xs, params_32, key=key)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The resulting `feature_map` is a function that takes the array of inputs and parameters of the kernel.\n", + "There is also an optional parameter `normalize` that determines if $\\langle \\phi(x), \\phi(x) \\rangle_{\\mathbb{R}^M} \\approx 1$ or not.\n", + "For Hamming graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "\n", + "`feature_map` outputs a tuple.\n", + "Its **second** element is $\\phi(x)$ evaluated at all inputs $x$.\n", + "Its first element contains the updated `key` for randomized feature maps.\n", + "For `default_feature_map` on a `HammingGraph` space, the feature map is *randomized* (using `RandomPhaseFeatureMapCompact`), so the first element is the updated random state.\n", + "\n", + "In the next cell, we evaluate the feature map at random points, using `params_32` as kernel parameters.\n", + "We check the basic property of the feature map: $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 4)):\n", + "[[2 1 0 0]\n", + " [0 1 1 1]\n", + " [2 2 2 0]]\n", + "\n", + "emedding (shape = (3, 15000)):\n", + "[[ 0.00699769 -0.0137675 0.01248256 ... 0.01248256 -0.00563144\n", + " -0.0081862 ]\n", + " [ 0.00711193 -0.00349806 -0.00634317 ... -0.00634317 -0.00572338\n", + " 0.00415992]\n", + " [ 0.00692829 0.00681548 -0.00617938 ... -0.00617938 0.00696949\n", + " -0.00202625]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.02531349719744118\n" + ] + } + ], + "source": [ + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_32)\n", + "\n", + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\n", + "\n", + "kernel_mat_32 = kernel.K(params_32, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "\n", + "print('')\n", + "print('||k(xs, xs) - phi(xs) * phi(xs)^T|| =', np.linalg.norm(kernel_mat_32 - kernel_mat_32_alt))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Efficient Sampling using Feature Maps\n", + "\n", + "GeometricKernels provides a simple tool to efficiently sample (without incurring cubic costs) the Gaussian process $f \\sim \\mathrm{GP}(0, k)$, based on an approximate finite-dimensional feature map $\\phi$.\n", + "The underlying machinery is briefly discussed in this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/feature_maps.html).\n", + "\n", + "The function `sampler` from `geometric_kernels.sampling` takes in a feature map and, optionally, the keyword argument `s` that specifies the number of samples to generate.\n", + "It returns a function we name `sample_paths`.\n", + "\n", + "`sample_paths` operates much like `feature_map` above: it takes in the points where to evaluate the samples and kernel parameters.\n", + "Additionally, it takes in the keyword argument `key` that specifies randomness in the JAX style.\n", + "`sample_paths` returns a tuple.\n", + "Its first element is the updated `key`.\n", + "Its second element is an array containing the value of samples evaluated at the input points." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-130.9953739 -177.25877559]\n", + " [ 41.14356715 136.7170067 ]\n", + " [ 79.75263457 -217.72826631]]\n" + ] + } + ], + "source": [ + "from geometric_kernels.sampling import sampler\n", + "\n", + "sample_paths = sampler(feature_map, s=2)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = np.random.RandomState(seed=1234)\n", + "\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(xs, params_32, key=key)\n", + "\n", + "print('Two samples evaluated at the xs are:')\n", + "print(samples)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Visualizing Samples\n", + "Here we visualize samples as functions on a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "key = np.random.RandomState(seed=1234)\n", + "key, samples = sample_paths(other_points, params_32, key=key)\n", + "\n", + "sample1 = samples[:, 0]\n", + "sample2 = samples[:, 1]\n", + "\n", + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "vmin = min(sample1.min(), sample2.min())\n", + "vmax = max(sample1.max(), sample2.max())\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': pos, 'node_size': 120, 'width': 0.2}\n", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=sample1,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Sample #1: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=sample2,\n", + " vmin=vmin, vmax=vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=vmin, vmax=vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Sample #2: $f(\\cdot)$ for $\\cdot$ in nodes, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using the HammingGraph space and GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{doumont2025,\n", + " title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization},\n", + " author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss},\n", + " booktitle = {Advances in Neural Information Processing Systems},\n", + " year = {2025},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{borovitskiy2023,\n", + " title={Isotropic Gaussian Processes on Finite Spaces of Graphs},\n", + " author={Borovitskiy, Viacheslav and Karimi, Mohammad Reza and Somnath, Vignesh Ram and Krause, Andreas},\n", + " booktitle={International Conference on Artificial Intelligence and Statistics},\n", + " year={2023},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{kondor2002,\n", + " title={Diffusion Kernels on Graphs and Other Discrete Structures},\n", + " author={Kondor, Risi Imre and Lafferty, John},\n", + " booktitle={International Conference on Machine Learning},\n", + " year={2002}\n", + "}\n", + "```" + ] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "gkconda_updated_sh", + "language": "python", + "name": "gkconda_updated_sh" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.13" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/notebooks/other/HammingGraphTiming.ipynb b/notebooks/other/HammingGraphTiming.ipynb new file mode 100644 index 00000000..dde532a9 --- /dev/null +++ b/notebooks/other/HammingGraphTiming.ipynb @@ -0,0 +1,233 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install geometric_kernels\n", + "\n", + "# If you want to use a version of the library from a specific branch on GitHub,\n", + "# say, from the \"devel\" branch, uncomment the line below instead\n", + "# !pip install \"git+https://github.com/geometric-kernels/GeometricKernels@devel\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Benchmarking Speed Improvements on Hypercube/Hamming Graphs\n", + "\n", + "This notebook benchmarks two methods for the `HypercubeGraph` and `HammingGraph` spaces with $\\nu = \\infty$:\n", + "\n", + "1. \"slow\" method — based on the addition theorem presented on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/hamming_graph.html),\n", + "2. \"fast\" method — based on the closed-form equations discusssed in [Kondor and Lafferty (2002)](https://people.cs.uchicago.edu/~risi/papers/diffusion-kernels.pdf) or [Doumont et al. (2025)](https://arxiv.org/pdf/2510.26633).\n", + "\n", + "Moreover, we also double-check whether the different methods lead to equal kernels.\n" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "INFO (geometric_kernels): Numpy backend is enabled. To enable other backends, don't forget to `import geometric_kernels.*backend name*`.\n", + "INFO (geometric_kernels): We may be suppressing some logging of external libraries. To override the logging policy, call `logging.basicConfig`.\n", + "/opt/miniconda3/envs/geometrik/lib/python3.11/site-packages/spherical_harmonics/fundamental_set.py:21: UserWarning: pkg_resources is deprecated as an API. See https://setuptools.pypa.io/en/latest/pkg_resources.html. The pkg_resources package is slated for removal as early as 2025-11-30. Refrain from using this package or pin to Setuptools<81.\n", + " from pkg_resources import resource_filename\n" + ] + } + ], + "source": [ + "import time\n", + "from collections import defaultdict\n", + "\n", + "import numpy as np\n", + "\n", + "from geometric_kernels.kernels import MaternKernelHammingGraph\n", + "from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel\n", + "from geometric_kernels.spaces import HammingGraph, HypercubeGraph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "SEED = 1234\n", + "np.random.seed(SEED)\n", + "\n", + "# Configuration\n", + "SPACE_DIM = 20 # dimensionality of the space\n", + "N_CAT = 5 # number of categories (alphabet size) for Hamming graph\n", + "N_SAMPLES = 3000 # number of points to evalute the kernels on\n", + "N_RUNS = 10 # number of seeds to average over\n", + "LENGTHSCALES = [1.0, 5.0, 10.0, 20.0]" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def generate_data(space, n, seed_offset=0):\n", + " key1 = np.random.RandomState(1234 + seed_offset)\n", + " key2 = np.random.RandomState(5678 + seed_offset)\n", + " _, X1 = space.random(key1, n)\n", + " _, X2 = space.random(key2, n)\n", + " return X1, X2\n", + "\n", + "\n", + "def run_benchmark(space, kernel_type, lengthscales, n_samples, n_runs, space_dim):\n", + " results = {\"times\": defaultdict(list), \"kernels\": {}}\n", + "\n", + " for lengthscale in lengthscales:\n", + " for run_idx in range(n_runs):\n", + " if kernel_type == \"fast\":\n", + " kernel = MaternKernelHammingGraph(space, num_levels=space_dim + 1)\n", + " else:\n", + " kernel = MaternKarhunenLoeveKernel(space, num_levels=space_dim + 1)\n", + "\n", + " X1, X2 = generate_data(space, n_samples, seed_offset=run_idx * 1)\n", + " params = dict(nu=np.array([np.inf]), lengthscale=np.array([lengthscale]))\n", + "\n", + " start = time.perf_counter()\n", + " K = kernel.K(params, X1, X2)\n", + " elapsed = time.perf_counter() - start\n", + "\n", + " results[\"times\"][lengthscale].append(elapsed)\n", + " if run_idx == 0:\n", + " results[\"kernels\"][lengthscale] = K\n", + "\n", + " return results\n", + "\n", + "\n", + "def print_results(fast_results, slow_results, lengthscales, space_name):\n", + " print(f\"\\n{'='*80}\\n{space_name}\\n{'='*80}\")\n", + "\n", + " for ls in lengthscales:\n", + " fast_mean = np.mean(fast_results[\"times\"][ls])\n", + " slow_mean = np.mean(slow_results[\"times\"][ls])\n", + " speedup = slow_mean / fast_mean\n", + " is_equal = np.allclose(fast_results[\"kernels\"][ls], slow_results[\"kernels\"][ls])\n", + "\n", + " print(\n", + " f\"Lengthscale {ls:5.1f}: Fast={fast_mean:.4f}s | Slow={slow_mean:.4f}s | \"\n", + " f\"Speedup={speedup:.2f}x | Equal={is_equal}\"\n", + " )" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Running...\n", + "\n", + "\n", + "================================================================================\n", + "HYPERCUBE GRAPH\n", + "================================================================================\n", + "Lengthscale 1.0: Fast=0.6992s | Slow=1.3529s | Speedup=1.94x | Equal=True\n", + "Lengthscale 5.0: Fast=0.6834s | Slow=1.3563s | Speedup=1.98x | Equal=True\n", + "Lengthscale 10.0: Fast=0.7838s | Slow=1.3482s | Speedup=1.72x | Equal=True\n", + "Lengthscale 20.0: Fast=0.7434s | Slow=1.3582s | Speedup=1.83x | Equal=True\n", + "\n", + "================================================================================\n", + "HAMMING GRAPH\n", + "================================================================================\n", + "Lengthscale 1.0: Fast=0.6942s | Slow=1.3436s | Speedup=1.94x | Equal=True\n", + "Lengthscale 5.0: Fast=0.8381s | Slow=1.3142s | Speedup=1.57x | Equal=True\n", + "Lengthscale 10.0: Fast=0.7756s | Slow=1.3819s | Speedup=1.78x | Equal=True\n", + "Lengthscale 20.0: Fast=0.6543s | Slow=1.3453s | Speedup=2.06x | Equal=True\n", + "\n", + "Done!\n" + ] + } + ], + "source": [ + "print(\"Running...\")\n", + "print(\"\")\n", + "\n", + "# HypercubeGraph\n", + "graph = HypercubeGraph(SPACE_DIM)\n", + "fast_results = run_benchmark(graph, \"fast\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM)\n", + "slow_results = run_benchmark(graph, \"slow\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM)\n", + "print_results(fast_results, slow_results, LENGTHSCALES, \"HYPERCUBE GRAPH\")\n", + "\n", + "# HammingGraph\n", + "hamming_graph = HammingGraph(SPACE_DIM, N_CAT)\n", + "fast_results = run_benchmark(\n", + " hamming_graph, \"fast\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM\n", + ")\n", + "slow_results = run_benchmark(\n", + " hamming_graph, \"slow\", LENGTHSCALES, N_SAMPLES, N_RUNS, SPACE_DIM\n", + ")\n", + "print_results(fast_results, slow_results, LENGTHSCALES, \"HAMMING GRAPH\")\n", + "\n", + "print(\"\")\n", + "print(\"Done!\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Citation\n", + "\n", + "If you are using hypercube or Hamming graphs from GeometricKernels, please consider citing\n", + "\n", + "```\n", + "@article{mostowsky2024,\n", + " title = {The GeometricKernels Package: Heat and Matérn Kernels for Geometric Learning on Manifolds, Meshes, and Graphs},\n", + " author = {Peter Mostowsky and Vincent Dutordoir and Iskander Azangulov and Noémie Jaquier and Michael John Hutchinson and Aditya Ravuri and Leonel Rozo and Alexander Terenin and Viacheslav Borovitskiy},\n", + " year = {2024},\n", + " journal = {arXiv:2407.08086},\n", + "}\n", + "```\n", + "\n", + "```\n", + "@inproceedings{doumont2025,\n", + " title = {Omnipresent Yet Overlooked: Heat Kernels in Combinatorial Bayesian Optimization},\n", + " author = {Colin Doumont and Victor Picheny and Viacheslav Borovitskiy and Henry Moss},\n", + " booktitle = {Advances in Neural Information Processing Systems},\n", + " year = {2025},\n", + "}\n", + "```\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "geometrik", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.11" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/tests/helper.py b/tests/helper.py index 96681d5a..e0d6ab70 100644 --- a/tests/helper.py +++ b/tests/helper.py @@ -11,6 +11,7 @@ DiscreteSpectrumSpace, Graph, GraphEdges, + HammingGraph, HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, @@ -71,6 +72,10 @@ def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: HypercubeGraph(1), HypercubeGraph(3), HypercubeGraph(6), + HammingGraph(1, 2), + HammingGraph(3, 3), + HammingGraph(2, 6), + HammingGraph(6, 4), Hypersphere(2), Hypersphere(3), Hypersphere(10), diff --git a/tests/spaces/test_eigenfunctions.py b/tests/spaces/test_eigenfunctions.py index c6a98b93..ffe7b6de 100644 --- a/tests/spaces/test_eigenfunctions.py +++ b/tests/spaces/test_eigenfunctions.py @@ -5,7 +5,12 @@ from opt_einsum import contract as einsum from geometric_kernels.kernels.matern_kernel import default_num -from geometric_kernels.spaces import CompactMatrixLieGroup, Hypersphere, Mesh +from geometric_kernels.spaces import ( + CompactMatrixLieGroup, + HammingGraph, + Hypersphere, + Mesh, +) from geometric_kernels.utils.utils import chain from ..helper import check_function_with_backend, discrete_spectrum_spaces @@ -57,10 +62,9 @@ def inputs(request): def test_call_eigenfunctions(inputs, backend): space, eigenfunctions, X, _, _ = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") # Check that the eigenfunctions can be called, returning the right type and shape. check_function_with_backend( @@ -94,10 +98,9 @@ def test_numbers_of_eigenfunctions(inputs): def test_orthonormality(inputs, backend): space, eigenfunctions, _, _, _ = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") key = np.random.RandomState(0) key, xs = space.random(key, 10000) @@ -117,10 +120,9 @@ def test_orthonormality(inputs, backend): def test_weighted_outerproduct_with_addition_theorem(inputs, backend): space, eigenfunctions, X, X2, weights = inputs - if isinstance(space, CompactMatrixLieGroup): - pytest.skip( - "CompactMatrixLieGroup subclasses do not currently support eigenfunction evaluation" - ) + if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + space_name = type(space).__name__ + pytest.skip(f"{space_name} does not currently support eigenfunction evaluation") chained_weights = chain( weights.squeeze(), eigenfunctions.num_eigenfunctions_per_level diff --git a/tests/spaces/test_hamming_graph.py b/tests/spaces/test_hamming_graph.py new file mode 100644 index 00000000..55cefa34 --- /dev/null +++ b/tests/spaces/test_hamming_graph.py @@ -0,0 +1,108 @@ +import lab as B +import numpy as np +import pytest +from plum import Tuple + +from geometric_kernels.kernels import MaternGeometricKernel +from geometric_kernels.spaces import HammingGraph, HypercubeGraph +from geometric_kernels.utils.kernel_formulas import hamming_graph_heat_kernel + +from ..helper import check_function_with_backend + + +@pytest.fixture(params=[(1, 2), (2, 2), (5, 2), (10, 2), (10, 4)]) +def inputs(request) -> Tuple[B.Numeric]: + """ + Returns a tuple (space, eigenfunctions, X, X2, weights) where: + - space is a HammingGraph object with (dim, n_cat) equal to request.param, + - eigenfunctions is the respective Eigenfunctions object with at most 5 levels, + - X is a random sample of random size from the space, + - X2 is another random sample of random size from the space, + - weights is an array of positive numbers of shape (eigenfunctions.num_levels, 1). + """ + d, q = request.param + space = HammingGraph(dim=d, n_cat=q) + eigenfunctions = space.get_eigenfunctions(min(space.dim + 1, 5)) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(q**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + # These weights are used for testing the weighted outerproduct, they + # should be positive. + weights = np.random.rand(eigenfunctions.num_levels, 1) ** 2 + 1e-5 + + return space, eigenfunctions, X, X2, weights + + +def test_numbers_of_eigenfunctions(inputs): + space, eigenfunctions, _, _, _ = inputs + num_levels = eigenfunctions.num_levels + + # If the number of levels is maximal, check that the number of + # eigenfunctions is equal to the number of categorical vectors. + if num_levels == space.dim + 1: + assert eigenfunctions.num_eigenfunctions == space.n_cat**space.dim + + +@pytest.mark.parametrize("nu", [1.5, np.inf]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_reduces_to_hypercube_when_q_equals_2(inputs, nu, lengthscale, backend): + space, eigenfunctions, X, X2, _ = inputs + + if space.n_cat != 2: + pytest.skip("Only applicable when n_cat=2") + + hypercube = HypercubeGraph(space.dim) + X_bool = X.astype(bool) + X2_bool = X2.astype(bool) + + # Compare eigenvalues (backend-agnostic, only once per backend) + if lengthscale == 1.0 and nu == 1.5: + hamming_eigenvalues = space.get_eigenvalues(eigenfunctions.num_levels) + hypercube_eigenvalues = hypercube.get_eigenvalues(eigenfunctions.num_levels) + np.testing.assert_allclose( + hamming_eigenvalues, hypercube_eigenvalues, rtol=1e-10 + ) + + # Compare kernel values with backend testing + kernel_hamming = MaternGeometricKernel(space) + kernel_hypercube = MaternGeometricKernel(hypercube) + + params = {"nu": np.array([nu]), "lengthscale": np.array([lengthscale])} + K_hypercube = kernel_hypercube.K(params, X_bool, X2_bool) + + check_function_with_backend( + backend, + K_hypercube, + kernel_hamming.K, + params, + X, + X2, + atol=1e-2, + ) + + +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_against_analytic_heat_kernel(inputs, lengthscale, backend): + space, _, X, X2, _ = inputs + lengthscale = np.array([lengthscale]) + result = hamming_graph_heat_kernel(lengthscale, X, X2, q=space.n_cat) + + kernel = MaternGeometricKernel(space) + + # Check that MaternGeometricKernel on HammingGraph with nu=infinity + # coincides with the closed form expression for the heat kernel on the + # Hamming graph. + check_function_with_backend( + backend, + result, + kernel.K, + {"nu": np.array([np.inf]), "lengthscale": lengthscale}, + X, + X2, + atol=1e-2, + ) diff --git a/tests/utils/test_kernel_formulas.py b/tests/utils/test_kernel_formulas.py index 427acfc9..10cce9e2 100644 --- a/tests/utils/test_kernel_formulas.py +++ b/tests/utils/test_kernel_formulas.py @@ -4,8 +4,11 @@ import pytest from sklearn.metrics.pairwise import rbf_kernel -from geometric_kernels.spaces import HypercubeGraph -from geometric_kernels.utils.kernel_formulas import hypercube_graph_heat_kernel +from geometric_kernels.spaces import HammingGraph, HypercubeGraph +from geometric_kernels.utils.kernel_formulas import ( + hamming_graph_heat_kernel, + hypercube_graph_heat_kernel, +) from ..helper import check_function_with_backend @@ -66,3 +69,114 @@ def heat_kernel(lengthscale, X, X2): X[0:1, :], X2[0:1, :], ) + + +@pytest.mark.parametrize("d", [1, 5, 10]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hamming_graph_reduces_to_hypercube_when_q_equals_2(d, lengthscale, backend): + space = HypercubeGraph(d) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(2**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + def heat_kernel_hamming(lengthscale, X, X2): + return hamming_graph_heat_kernel( + lengthscale, X, X2, q=2, normalized_laplacian=False + ) + + # Compute reference using hypercube formula + result = hypercube_graph_heat_kernel( + np.array([lengthscale]), X, X2, normalized_laplacian=False + ) + + # Check that general Hamming formula with q=2 matches hypercube + check_function_with_backend( + backend, + result, + heat_kernel_hamming, + np.array([lengthscale]), + X, + X2, + ) + + +@pytest.mark.parametrize("d", [1, 5, 10]) +@pytest.mark.parametrize("q", [2, 5, 7]) +@pytest.mark.parametrize("lengthscale", [1.0, 5.0, 10.0]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hamming_graph_heat_kernel(d, q, lengthscale, backend): + space = HammingGraph(d, q) + + key = np.random.RandomState(0) + N, N2 = key.randint(low=1, high=min(q**d, 10) + 1, size=2) + key, X = space.random(key, N) + key, X2 = space.random(key, N2) + + def to_one_hot(X_cat, q): + """Convert categorical matrix [N, d] to one-hot [N, d*q].""" + N, d = X_cat.shape + X_onehot = np.zeros((N, d * q), dtype=float) + for i in range(N): + for j in range(d): + X_onehot[i, j * q + X_cat[i, j]] = 1.0 + return X_onehot + + X_onehot = to_one_hot(X, q) + X2_onehot = to_one_hot(X2, q) + + beta = lengthscale**2 / 2 + exp_neg_beta_q = np.exp(-beta * q) + factor_disagree = (1 - exp_neg_beta_q) / (1 + (q - 1) * exp_neg_beta_q) + gamma = -np.log(factor_disagree) / 2 # one-hot counts differences twice + + result = rbf_kernel(X_onehot, X2_onehot, gamma=gamma) + + def heat_kernel(lengthscale, X, X2): + return hamming_graph_heat_kernel( + lengthscale, X, X2, q=q, normalized_laplacian=False + ) + + # Checks that the heat kernel on the Hamming graph coincides with the RBF + # restricted onto categorical vectors, with appropriately redefined length scale. + check_function_with_backend( + backend, + result, + heat_kernel, + np.array([lengthscale]), + X, + X2, + atol=1e-2, + ) + + if d > 5: + X_first = X[0:1, :3] + X2_first = X2[0:1, :3] + X_second = X[0:1, 3:] + X2_second = X2[0:1, 3:] + + K_first = hamming_graph_heat_kernel( + np.array([lengthscale]), X_first, X2_first, q=q, normalized_laplacian=False + ) + K_second = hamming_graph_heat_kernel( + np.array([lengthscale]), + X_second, + X2_second, + q=q, + normalized_laplacian=False, + ) + + result = K_first * K_second + + # Checks that the heat kernel of the product is equal to the product + # of heat kernels. + check_function_with_backend( + backend, + result, + heat_kernel, + np.array([lengthscale]), + X[0:1, :], + X2[0:1, :], + ) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 21ce5414..61923234 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -5,7 +5,7 @@ import pytest from geometric_kernels.utils.special_functions import ( - kravchuk_normalized, + generalized_kravchuk_normalized, walsh_function, ) from geometric_kernels.utils.utils import binary_vectors_and_subsets, hamming_distance @@ -70,7 +70,9 @@ def test_kravchuk_polynomials(all_xs_and_combs, backend): ) def krav(x0, X): - return comb(d, j) * kravchuk_normalized(d, j, hamming_distance(x0, X)) + return comb(d, j) * generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2 + ) # Checks that Kravchuk polynomials coincide with certain sums of # the Walsh functions. @@ -94,10 +96,14 @@ def test_kravchuk_precomputed(all_xs_and_combs, backend): kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None for j in range(d + 1): - cur_kravchuk_normalized = kravchuk_normalized(d, j, hamming_distance(x0, X)) + cur_kravchuk_normalized = generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2 + ) def krav(x0, X, kn1, kn2): - return kravchuk_normalized(d, j, hamming_distance(x0, X), kn1, kn2) + return generalized_kravchuk_normalized( + d, j, hamming_distance(x0, X), 2, kn1, kn2 + ) # Checks that Kravchuk polynomials coincide with certain sums of # the Walsh functions.