diff --git a/docs/examples/GraphEdges.nblink b/docs/examples/GraphEdges.nblink new file mode 100644 index 00000000..7b184917 --- /dev/null +++ b/docs/examples/GraphEdges.nblink @@ -0,0 +1 @@ +{"path": "../../notebooks/GraphEdges.ipynb"} \ No newline at end of file diff --git a/docs/examples/examples.rst b/docs/examples/examples.rst index 4a442a08..df7a60b5 100644 --- a/docs/examples/examples.rst +++ b/docs/examples/examples.rst @@ -7,6 +7,7 @@ Spaces :titlesonly: Graph + GraphEdges Hyperbolic HypercubeGraph Hypersphere diff --git a/docs/theory/graphs.rst b/docs/theory/graphs.rst index 059ca471..664c9b62 100644 --- a/docs/theory/graphs.rst +++ b/docs/theory/graphs.rst @@ -3,7 +3,7 @@ #################### .. 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 `. + You can get by fine without reading this page for almost all use cases, just use the standard :class:`~.kernels.MaternGeometricKernel`, following :doc:`this example notebook ` if you are modeling a function of nodes, or :doc:`this example notebook ` if you are modeling a function of edges. This is optional material meant to explain the basic theory and based mainly on :cite:t:`borovitskiy2021`. @@ -81,11 +81,173 @@ The notation here is as follows. Edge Set of a Graph ========================== -if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the `line graph `_. The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the `line_graph `_ function from `networkx `_. +If you want to model a signal on the edges of a graph $G$, you can consider modeling the signal on the nodes of the `line graph `_. +The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. +To build the line graph, you can use the `line_graph `_ function from `networkx `_. +Alternatively, especially for the **flow-type data**, you might want to use **specialized edge kernels that we briefly describe below**. -Alternatively, especially for the flow-type data, you might want to use specialized edge kernels, see :cite:t:`yang2024` and :cite:t:`alain2023`. -These are, however, not implemented in GeometricKernels at the moment. +To define kernels for flow-type data on graph edges, the graph is extended to a *simplicial 2-complex*. +You can ignore the concept of a simplicial 2-complex and treat the space as a graph because GeometricKernels can automatically extend your graph to a simplicial 2-complex in a sensible way. +However, if you prefer to ignore this concept, you may want to disregard the rest of this section too. + +Simplicial 2-complexes +---------------------- + +A *simplicial 2-complex* is a collection of $N_0$ nodes, $N_1$ edges, and $N_2$ triangles such that each triangle is a triplet of nodes and each edge is a pair of nodes. +**The edges are not directed, but they are oriented** [#]_. +An oriented edge, denoted as $e=[i,j]$ is an ordering of $\{i,j\}$. +This is not a directed edge allowing flow only from $i$ to $j$, but rather an assignment of the sign of the flow: from $i$ to $j$ it is positive and the reverse is negative. +For $e=[i,j]$, we denote the same edge with reverse orientation by $-e=[j,i]$. +Same goes for oriented triangles, denoted as $t=[i,j,k]$, where $i, j, k$ are nodes, with +$$ +t=[i,j,k] = [j,k,i] = [k,i,j] = -[i,k,j] = -[k,j,i] = -[j,i,k] +. +$$ + +A function $f : E \to \mathbb{R}$ on the edge set $E$ of a simplicial 2-complex is required to be **alternating**, i.e. $f(-e) = -f(e)$ for all $e \in E$. +Such a function may be identified with the vector +$$ +\mathbf{f}=[f(e_1),\dots,f(e_{N_1})]^\top\in\mathbb{R}^{N_1} +$$ +of its values on all positively oriented edges $e_i$. +We call this vector an **edge flow**. + +Hodge Laplacian +--------------- + +Given a simplicial 2-complex, we can define the discrete **Hodge Laplacian**, which operates on the space of edge flows, as +$$ +\mathbf{L} = \mathbf{B}_1^\top \mathbf{B}_1 + \mathbf{B}_2 \mathbf{B}_2^\top := \mathbf{L}_{\text{d}} + \mathbf{L}_{\text{u}}, +$$ +where $\mathbf{B}_1$ is the *oriented* node-to-edge incidence matrix of dimension $N_0\times N_1$, and $\mathbf{B}_2$ is the *oriented* edge-to-triangle incidence matrix of dimension $N_1\times N_2$. +For every positively oriented edge $e=[i, j]$, we have $[ \mathbf{B}_1 ]_{i e} = -1$ and $[ \mathbf{B}_1 ]_{j e} = 1$. +All the other entries of $\mathbf{B}_1$ are zero. +If an edge $e$ is aligned with the triangle $t$, we have $[ \mathbf{B}_2 ]_{e t} = 1$, if $-e$ is aligned with $t$, we have $[ \mathbf{B}_2 ]_{e t} = -1$. +All the other entries of $\mathbf{B}_2$ are zero. + +The Hodge Laplacian $\mathbf{L}$ describes the connectivity of edges where the *down* part $\mathbf{L}_d$ and the *up* part $\mathbf{L}_u$ encode how edges are adjacent, respectively, through nodes and via triangles. +Matrix $\mathbf{L}$ is positive semi-definite, admitting an orthonormal basis of eigenvectors $\mathbf{f}_1, \ldots, \mathbf{f}_{N_1}$ with eigenvalues $\lambda_l$: +$$ +\mathbf{L} \mathbf{f}_l = \lambda_l \mathbf{f}_l +\qquad +\lambda_l \geq 0 +. +$$ +The eigenvalues are assumed to be in ascending order: $\lambda_1 \leq \ldots \leq \lambda_{N_1}$. +Each $\mathbf{f}_l$ defines a function $f_l: E \to \mathbb{R}$ with $f_l(e) = \left(\mathbf{f}_l\right)_{e}$ if $e$ is positively oriented and $f_l(e) = -f_l(-e)$ otherwise. + +Matérn Karhunen–Loève Kernel +----------------------------- + +The eigenpairs $\lambda_l, f_l$ of the Hodge Laplacian can be used to define the :class:`~.kernels.MaternKarhunenLoeveKernel` on the set $E$ of graph edges. +Much like for the node set of a graph, this kernel is given by the formula +$$ +k_{\nu, \kappa}(e,e') +\!=\! +\frac{1}{C_{\nu, \kappa}} \sum_{l=1}^{L} \Phi_{\nu, \kappa}(\lambda_l) f_l(e) f_l(e') +\quad +\Phi_{\nu, \kappa}(\lambda) += +\begin{cases} +\left(\frac{2\nu}{\kappa^2} + \lambda\right)^{-\nu} +& +\nu < \infty \text{ — Matérn} +\\ +e^{-\frac{\kappa^2}{2} \lambda} +& +\nu = \infty \text{ — Heat (RBF)} +\end{cases} +$$ + +Where $L$ is the user-defined truncation parameter, and $C_{\nu, \kappa}$ is the normalizing constant making sure that $1/N_1 \sum k_{\nu, \kappa}(e, e) = 1$ where the summation is over all edges $e$ in positive orientation. + +Matérn Hodge Compositional Kernel +--------------------------------- + +Edge flows can be thought of as discrete analogs of vector fields. +Much like for vector fields, you can define the gradient, divergence and curl of an edge flow: +$$ +\begin{aligned} +\operatorname{div} \mathbf{f} &= \mathbf{B}_1 \mathbf{f}, +&& +\mathbf{f} \in \mathbb{R}^{N_1}, +&& +\operatorname{div} \mathbf{f} \in \mathbb{R}^{N_0}, +\\ +\operatorname{curl} \mathbf{f} &= \mathbf{B}_2^{\top} \mathbf{f}, +&& +\mathbf{f} \in \mathbb{R}^{N_1}, +&& +\operatorname{curl} \mathbf{f} \in \mathbb{R}^{N_2}. +\end{aligned} +$$ +We can also define the gradient $\operatorname{grad}$, that takes a node function ($\mathbb{R}^{N_0}$ vector) returning an edge flow, and the curl-adjoint $\operatorname{curl}^*$, that takes a triangle function ($\mathbb{R}^{N_2}$ vector) returning an edge flow: +$$ +\begin{aligned} +\operatorname{grad} \mathbf{g} &= \mathbf{B}_1^{\top} \mathbf{g}, +&& +\mathbf{g} \in \mathbb{R}^{N_0}, +&& +\operatorname{grad} \mathbf{g} \in \mathbb{R}^{N_1}, +\\ +\operatorname{curl}^* \mathbf{h} &= \mathbf{B}_2 \mathbf{h}, +&& +\mathbf{h} \in \mathbb{R}^{N_2}, +&& +\operatorname{curl}^* \mathbf{h} \in \mathbb{R}^{N_1}. +\end{aligned} +$$ +In some applications, only divergence-free or curl-free flows are of interest. +The **Hodge decomposition** provides a way to decompose edge flows into gradient (curl-free), curl-adjoint (divergence-free), and harmonic (curl-free and divergence-free at the same time) components. +The curl-adjoint component we typically just call the curl component. +It motivates the :class:`~.kernels.MaternHodgeCompositionalKernel` kernel, which is the underlying kernel for the :class:`~.kernels.MaternGeometricKernel` on the :class:`~.spaces.GraphEdges` space. + +Hodge decomposition implies that eigenvectors of the Hodge Laplacian can be chosen in such a way that they form three groups. + +- The eigenvectors from the first group are denoted by $f_l^H$ and called harmonic. + They satisfy $\mathbf{L} f_l^H = \operatorname{div} f_l^H = \operatorname{curl} f_l^H = 0$, corresponding to $\lambda_l^H = 0$ eigenvalues of the Hodge Laplacian $\mathbf{L}$. +- The eigenvectors from the second group are denoted by $f_l^G$ and called gradient. + They are curl-free: $\operatorname{curl} f_l^G = 0$, corresponding to nonzero eigenvalues $\lambda_l^G$ of the down Laplacian $\mathbf{L}_d$. +- The eigenvectors from the third group are denoted by $f_l^C$ and called curl(-adjoint). + They are divergence-free: $\operatorname{div} f_l^C = 0$, corresponding to nonzero eigenvalues $\lambda_l^C$ of the up Laplacian $\mathbf{L}_u$. + +The Hodge-compositional kernel is built to enable separable control on the different Hodge subspaces. +For the truncation parameter $L$, one obtains $L$ eigenpairs of the Hodge Laplacian corresponding to the lowest eigenvalues. +Of them, $L_H$ are associated with zero eigenvalues, $L_G$ with nonzero eigenvalues of the down Laplacian, and $L_C$ with nonzero eigenvalues of the up Laplacian. +The kernel has three vector hyperparameters: $\mathbf{\nu} = (\nu_H, \nu_G, \nu_C)$; $\mathbf{\kappa} = (\kappa_H, \kappa_G, \kappa_C)$; and $\mathbf{\alpha} = (\alpha_H, \alpha_G, \alpha_C)$. +It is given by the formula +$$ +k_{\mathbf{\nu}, \mathbf{\kappa}, \mathbf{\alpha}}(e,e') +\propto +\sum_{\Box \in {H,G,C}} +\alpha_{\Box} +\sum_{l=1}^{L_{\Box}} \Phi_{\nu_{\Box}, \kappa_{\Box}}(\lambda_l^{\Box}) f_l^{\Box}(e) f_l^{\Box}(e') +$$ +where the proportionality constant is chosen to ensure that the average variance is equal to $1$. +We have +$$ +\Phi_{\Box}({\lambda}_{\Box}) += +\begin{cases} +\sigma_{\Box}^2 +\left(\frac{2\nu_{\Box}}{\kappa_{\Box}^2} + \lambda_{\Box}\right)^{-\nu_{\Box}} +& +\text{ — Matérn} +\\ +\sigma_{\Box}^2 +e^{-\frac{\kappa_{\Box}^2}{2} \lambda_{\Box}} +& +\text{ — Heat (RBF)} +\end{cases} +$$ +Each of the inner sums is a kernel whose range lies only in one Hodge subspace. + +- By setting $\alpha_{\Box} = 0$, you can effectively "turn off" the corresponding subspace. +- By using equal $\nu_{\Box}$ and $\kappa_{\Box}$ for all $\Box$ and choosing appropriate $\alpha_{\Box}$, you can recover the Matérn Karhunen–Loève kernel, which is a special case of the Hodge-compositional Matérn kernel. [#]_ +- You can also automatically infer $\mathbf{\alpha}$ from data. .. rubric:: Footnotes -.. [#] The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel` and :class:`~.Eigenfunctions` classes. \ No newline at end of file +.. [#] The notion of *levels* is discussed in the documentation of the :class:`~.kernels.MaternKarhunenLoeveKernel` and :class:`~.Eigenfunctions` classes. +.. [#] The orientation of a general simplex is an equivalence class of permutations of its labels. Two orientations are equivalent (respectively, opposite) if they differ by an even (respectively, odd) permutation. +.. [#] Although the formula on this page recovers the Matérn Karhunen–Loève kernel for $\alpha_H = \alpha_G = \alpha_C = 1$, the implementation is a bit different because of normalization considerations. \ No newline at end of file diff --git a/geometric_kernels/feature_maps/__init__.py b/geometric_kernels/feature_maps/__init__.py index fe84abf5..9a42a1f9 100644 --- a/geometric_kernels/feature_maps/__init__.py +++ b/geometric_kernels/feature_maps/__init__.py @@ -7,7 +7,10 @@ # noqa: F401 from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.feature_maps.deterministic import DeterministicFeatureMapCompact +from geometric_kernels.feature_maps.deterministic import ( + DeterministicFeatureMapCompact, + HodgeDeterministicFeatureMapCompact, +) from geometric_kernels.feature_maps.random_phase import ( RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, diff --git a/geometric_kernels/feature_maps/deterministic.py b/geometric_kernels/feature_maps/deterministic.py index 60906706..39875d79 100644 --- a/geometric_kernels/feature_maps/deterministic.py +++ b/geometric_kernels/feature_maps/deterministic.py @@ -9,7 +9,8 @@ from beartype.typing import Dict, Optional, Tuple from geometric_kernels.feature_maps.base import FeatureMap -from geometric_kernels.spaces import DiscreteSpectrumSpace +from geometric_kernels.spaces import DiscreteSpectrumSpace, HodgeDiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import Eigenfunctions class DeterministicFeatureMapCompact(FeatureMap): @@ -21,34 +22,57 @@ class DeterministicFeatureMapCompact(FeatureMap): A :class:`~.spaces.DiscreteSpectrumSpace` space. :param num_levels: Number of levels in the kernel approximation. + :param repeated_eigenvalues_laplacian: + Allowing to pass the repeated eigenvalues of the Laplacian directly, + instead of computing them from the space. If provided, `eigenfunctions` + must also be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. + :param eigenfunctions: + Allowing to pass the eigenfunctions directly, instead of computing them + from the space. If provided, `repeated_eigenvalues_laplacian` must also + be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. """ - def __init__(self, space: DiscreteSpectrumSpace, num_levels: int): - from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel - + def __init__( + self, + space: DiscreteSpectrumSpace, + num_levels: int, + repeated_eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, + ): self.space = space self.num_levels = num_levels - self.kernel = MaternKarhunenLoeveKernel(space, num_levels) - self.repeated_eigenvalues = space.get_repeated_eigenvalues( - self.kernel.num_levels - ) + + if repeated_eigenvalues_laplacian is None: + assert eigenfunctions is None + repeated_eigenvalues_laplacian = self.space.get_repeated_eigenvalues( + self.num_levels + ) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + else: + assert eigenfunctions is not None + assert repeated_eigenvalues_laplacian.shape == (num_levels, 1) + assert eigenfunctions.num_levels == num_levels + + self._repeated_eigenvalues = repeated_eigenvalues_laplacian + self._eigenfunctions = eigenfunctions def __call__( self, X: B.Numeric, params: Dict[str, B.Numeric], - normalize: Optional[bool] = None, + normalize: bool = True, **kwargs, ) -> Tuple[None, B.Numeric]: """ :param X: [N, ...] points in the space to evaluate the map on. + :param params: Parameters of the kernel (length scale and smoothness). + :param normalize: - Normalize to have unit average variance (if omitted - or None, follows the standard behavior of - :class:`~.kernels.MaternKarhunenLoeveKernel`). + Normalize to have unit average variance. If omitted, set to True. + :param ``**kwargs``: Unused. @@ -62,20 +86,116 @@ def __call__( interface: for some other subclasses of :class:`FeatureMap`, this first element may be an updated random key. """ - spectrum = self.kernel._spectrum( - self.repeated_eigenvalues, + from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel + + spectrum = MaternKarhunenLoeveKernel.spectrum( + self._repeated_eigenvalues, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) - normalize = normalize or (normalize is None and self.kernel.normalize) + if normalize: normalizer = B.sum(spectrum) spectrum = spectrum / normalizer weights = B.transpose(B.power(spectrum, 0.5)) # [1, M] - eigenfunctions = self.kernel.eigenfunctions(X, **params) # [N, M] + eigenfunctions = self._eigenfunctions(X, **kwargs) # [N, M] features = B.cast(B.dtype(params["lengthscale"]), eigenfunctions) * B.cast( B.dtype(params["lengthscale"]), weights ) # [N, M] + return None, features + + +class HodgeDeterministicFeatureMapCompact(FeatureMap): + r""" + Deterministic feature map for :class:`~.spaces.HodgeDiscreteSpectrumSpace`\ s + for which the actual eigenpairs are explicitly available. + + Corresponds to :class:`~.kernels.MaternHodgeCompositionalKernel` and takes + parameters in the same format. + """ + + def __init__(self, space: HodgeDiscreteSpectrumSpace, num_levels: int): + self.space = space + self.num_levels = num_levels + for hodge_type in ["harmonic", "curl", "gradient"]: + repeated_eigenvalues = self.space.get_repeated_eigenvalues( + self.num_levels, hodge_type + ) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) + num_levels_per_type = len( + self.space.get_eigenvalues(self.num_levels, hodge_type) + ) + setattr( + self, + f"feature_map_{hodge_type}", + DeterministicFeatureMapCompact( + space, + num_levels_per_type, + repeated_eigenvalues_laplacian=repeated_eigenvalues, + eigenfunctions=eigenfunctions, + ), + ) + + self.feature_map_harmonic: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + self.feature_map_gradient: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + self.feature_map_curl: ( + DeterministicFeatureMapCompact # for mypy to know the type + ) + + def __call__( + self, + X: B.Numeric, + params: Dict[str, Dict[str, B.Numeric]], + normalize: bool = True, + **kwargs, + ) -> Tuple[None, B.Numeric]: + """ + :param X: + [N, ...] points in the space to evaluate the map on. + + :param params: + Parameters of the kernel (length scale and smoothness). + + :param normalize: + Normalize to have unit average variance. If omitted, set to True. + + :param ``**kwargs``: + Unused. + + :return: + `Tuple(None, features)` where `features` is an [N, O] array, N + is the number of inputs and O is the dimension of the feature map. + + .. note:: + The first element of the returned tuple is the simple None and + should be ignored. It is only there to support the abstract + interface: for some other subclasses of :class:`FeatureMap`, this + first element may be an updated random key. + """ + + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, + ) + coeffs = coeffs / B.sum(coeffs) + coeffs = B.sqrt(coeffs) + + return None, B.concat( + coeffs[0] + * self.feature_map_harmonic(X, params["harmonic"], normalize, **kwargs)[1], + coeffs[1] + * self.feature_map_gradient(X, params["gradient"], normalize, **kwargs)[1], + coeffs[2] + * self.feature_map_curl(X, params["curl"], normalize, **kwargs)[1], + axis=-1, + ) diff --git a/geometric_kernels/feature_maps/random_phase.py b/geometric_kernels/feature_maps/random_phase.py index cb1d461a..2956a6a4 100644 --- a/geometric_kernels/feature_maps/random_phase.py +++ b/geometric_kernels/feature_maps/random_phase.py @@ -13,7 +13,7 @@ """ import lab as B -from beartype.typing import Dict, Optional, Tuple +from beartype.typing import Dict, Tuple from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.feature_maps.probability_densities import base_density_sample @@ -42,12 +42,10 @@ def __init__( num_levels: int, num_random_phases: int = 3000, ): - from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel - self.space = space self.num_levels = num_levels self.num_random_phases = num_random_phases - self.kernel = MaternKarhunenLoeveKernel(space, num_levels) + self.eigenfunctions = space.get_eigenfunctions(num_levels) def __call__( self, @@ -55,7 +53,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = None, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -81,9 +79,8 @@ def __call__( does this for you. :param normalize: - Normalize to have unit average variance (if omitted - or None, follows the standard behavior of - :class:`kernels.MaternKarhunenLoeveKernel`). + Normalize to have unit average variance. If omitted, set to True. + :param ``**kwargs``: Unused. @@ -93,13 +90,16 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ + from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel + key, random_phases = self.space.random(key, self.num_random_phases) # [O, D] - eigenvalues = self.kernel.eigenvalues_laplacian + eigenvalues = self.space.get_eigenvalues(self.num_levels) - spectrum = self.kernel._spectrum( + spectrum = MaternKarhunenLoeveKernel.spectrum( eigenvalues, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) if is_complex(X): @@ -111,7 +111,7 @@ def __call__( random_phases_b = B.cast(dtype, from_numpy(X, random_phases)) - phi_product = self.kernel.eigenfunctions.phi_product( + phi_product = self.eigenfunctions.phi_product( X, random_phases_b, **params ) # [N, O, L] @@ -122,7 +122,6 @@ def __call__( if is_complex(features): features = B.concat(B.real(features), B.imag(features), axis=1) - normalize = normalize or (normalize is None and self.kernel.normalize) if normalize: normalizer = B.sqrt(B.sum(features**2, axis=-1, squeeze=False)) features = features / normalizer @@ -165,7 +164,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -199,10 +198,6 @@ def __call__( state (generator) for any other backends. """ - # default behavior - if normalize is None: - normalize = True - key, random_phases = self.space.random_phases( key, self.num_random_phases ) # [O, ] diff --git a/geometric_kernels/feature_maps/rejection_sampling.py b/geometric_kernels/feature_maps/rejection_sampling.py index 3d96b91b..b445e055 100644 --- a/geometric_kernels/feature_maps/rejection_sampling.py +++ b/geometric_kernels/feature_maps/rejection_sampling.py @@ -6,7 +6,7 @@ """ import lab as B -from beartype.typing import Dict, Optional, Tuple +from beartype.typing import Dict, Tuple from geometric_kernels.feature_maps.base import FeatureMap from geometric_kernels.feature_maps.probability_densities import ( @@ -50,7 +50,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -83,9 +83,6 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ - # Default behavior - if normalize is None: - normalize = True key, random_phases = self.space.random_phases( key, self.num_random_phases @@ -151,7 +148,7 @@ def __call__( params: Dict[str, B.Numeric], *, key: B.RandomState, - normalize: Optional[bool] = True, + normalize: bool = True, **kwargs, ) -> Tuple[B.RandomState, B.Numeric]: """ @@ -184,9 +181,6 @@ def __call__( `key` is the updated random key for `jax`, or the similar random state (generator) for any other backends. """ - # Default behavior for normalization - if normalize is None: - normalize = True key, random_phases = self.space.random_phases( key, self.num_random_phases diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index ffd5b815..c404c291 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -9,6 +9,7 @@ # noqa: F401 from geometric_kernels.kernels.base import BaseGeometricKernel 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 import ( MaternGeometricKernel, diff --git a/geometric_kernels/kernels/hodge_compositional.py b/geometric_kernels/kernels/hodge_compositional.py new file mode 100644 index 00000000..1180c67d --- /dev/null +++ b/geometric_kernels/kernels/hodge_compositional.py @@ -0,0 +1,186 @@ +""" +This module provides the :class:`~.kernels.MaternHodgeCompositionalKernel` +kernel, for discrete spectrum spaces with Hodge decomposition, subclasses +of :class:`~.spaces.HodgeDiscreteSpectrumSpace`. +""" + +import lab as B +import numpy as np +from beartype.typing import Dict, Optional + +from geometric_kernels.kernels.base import BaseGeometricKernel +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.spaces import HodgeDiscreteSpectrumSpace + + +class MaternHodgeCompositionalKernel(BaseGeometricKernel): + r""" + This class is similar to :class:`~.kernels.MaternKarhunenLoeveKernel`, but + provides a more expressive family of kernels on the spaces where Hodge + decomposition is available. + + The resulting kernel is a sum of three kernels, + + .. math:: k(x, x') = a k_{\text{harmonic}}(x, x') + b k_{\text{gradient}}(x, x') + c k_{\text{curl}}(x, x'), + + where $a, b, c$ are weights $a, b, c \geq 0$ and $a + b + c = 1$, and + $k_{\text{harmonic}}$, $k_{\text{gradient}}$, $k_{\text{curl}}$ are the + instances of :class:`~.kernels.MaternKarhunenLoeveKernel` that only use the + eigenpairs of the Laplacian corresponding to a single part of the Hodge + decomposition. + + The parameters of this kernel are represented by a dict with three keys: + `"harmonic"`, `"gradient"`, `"curl"`, each corresponding to a dict with + keys `"logit"`, `"nu"`, `"lengthscale"`, where `"nu"` and `"lengthscale"` + are the parameters of the respective :class:`~.kernels.MaternKarhunenLoeveKernel`, + while the `"logit"` parameters determine the weights $a, b, c$ in the + formula above: $a, b, c$ are the `"logit"` parameters normalized to + satisfy $a + b + c = 1$. + + Same as for :class:`~.kernels.MaternKarhunenLoeveKernel`, these kernels can sometimes + be computed more efficiently using addition theorems. + + .. note:: + A brief introduction into the theory behind + :class:`~.kernels.MaternHodgeCompositionalKernel` can be found in + :doc:`this ` documentation page. + + :param space: + The space to define the kernel upon, a subclass of :class:`~.spaces.HodgeDiscreteSpectrumSpace`. + + :param num_levels: + Number of levels to include in the summation. + + :param normalize: + Whether to normalize kernel to have unit average variance. + """ + + def __init__( + self, + space: HodgeDiscreteSpectrumSpace, + num_levels: int, + normalize: bool = True, + ): + super().__init__(space) + self.num_levels = num_levels # in code referred to as `L`. + for hodge_type in ["harmonic", "curl", "gradient"]: + eigenvalues = self.space.get_eigenvalues(self.num_levels, hodge_type) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels, hodge_type) + num_levels_per_type = len(eigenvalues) + setattr( + self, + f"kernel_{hodge_type}", + MaternKarhunenLoeveKernel( + space, + num_levels_per_type, + normalize, + eigenvalues_laplacian=eigenvalues, + eigenfunctions=eigenfunctions, + ), + ) + + self.kernel_harmonic: MaternKarhunenLoeveKernel # for mypy to know the type + self.kernel_gradient: MaternKarhunenLoeveKernel # for mypy to know the type + self.kernel_curl: MaternKarhunenLoeveKernel # for mypy to know the type + + self.normalize = normalize + + @property + def space(self) -> HodgeDiscreteSpectrumSpace: + """ + The space on which the kernel is defined. + """ + self._space: HodgeDiscreteSpectrumSpace + return self._space + + def init_params(self) -> Dict[str, Dict[str, B.NPNumeric]]: + """ + Initialize the three sets of parameters for the three kernels. + """ + params = dict( + harmonic=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + gradient=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + curl=dict( + logit=np.array([1.0]), + nu=np.array([np.inf]), + lengthscale=np.array([1.0]), + ), + ) + + return params + + def K( + self, + params: Dict[str, Dict[str, B.NPNumeric]], + X: B.Numeric, + X2: Optional[B.Numeric] = None, + **kwargs, + ) -> B.Numeric: + """ + Compute the cross-covariance matrix between two batches of vectors of + inputs, or batches of matrices of inputs, depending on the space. + """ + + assert all( + key in params for key in ["harmonic", "gradient", "curl"] + ), "MaternHodgeCompositionalKernel's parameters must contain keys 'harmonic', 'gradient', 'curl'." + assert all( + B.shape(params[key]["logit"]) == (1,) + for key in ["harmonic", "gradient", "curl"] + ), "The 'logit' parameters of MaternHodgeCompositionalKernel must have shape (1,)." + + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, + ) + coeffs = coeffs / B.sum(coeffs) + + return ( + coeffs[0] * self.kernel_harmonic.K(params["harmonic"], X, X2, **kwargs) + + coeffs[1] * self.kernel_gradient.K(params["gradient"], X, X2, **kwargs) + + coeffs[2] * self.kernel_curl.K(params["curl"], X, X2, **kwargs) + ) + + def K_diag( + self, params: Dict[str, Dict[str, B.NPNumeric]], X: B.Numeric, **kwargs + ) -> B.Numeric: + """ + Returns the diagonal of the covariance matrix `self.K(params, X, X)`, + typically in a more efficient way than actually computing the full + covariance matrix with `self.K(params, X, X)` and then extracting its + diagonal. + """ + + assert all( + key in params for key in ["harmonic", "gradient", "curl"] + ), "MaternHodgeCompositionalKernel's parameters must contain keys 'harmonic', 'gradient', 'curl'." + assert all( + B.shape(params[key]["logit"]) == (1,) + for key in ["harmonic", "gradient", "curl"] + ), "The 'logit' parameters of MaternHodgeCompositionalKernel must have shape (1,)." + + # Copy the parameters to avoid modifying the original dict. + params = {key: params[key].copy() for key in ["harmonic", "gradient", "curl"]} + + coeffs = B.stack( + *[params[key].pop("logit") for key in ["harmonic", "gradient", "curl"]], + axis=0, + ) + coeffs = coeffs / B.sum(coeffs) + + return ( + coeffs[0] * self.kernel_harmonic.K_diag(params["harmonic"], X, **kwargs) + + coeffs[1] * self.kernel_gradient.K_diag(params["gradient"], X, **kwargs) + + coeffs[2] * self.kernel_curl.K_diag(params["curl"], X, **kwargs) + ) diff --git a/geometric_kernels/kernels/karhunen_loeve.py b/geometric_kernels/kernels/karhunen_loeve.py index 5157f30a..48f38e96 100644 --- a/geometric_kernels/kernels/karhunen_loeve.py +++ b/geometric_kernels/kernels/karhunen_loeve.py @@ -51,6 +51,14 @@ class MaternKarhunenLoeveKernel(BaseGeometricKernel): Number of levels to include in the summation. :param normalize: Whether to normalize kernel to have unit average variance. + :param eigenvalues_laplacian: + Allowing to pass the eigenvalues of the Laplacian directly, instead of + computing them from the space. If provided, `eigenfunctions` must also + be provided. Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. + :param eigenfunctions: + Allowing to pass the eigenfunctions directly, instead of computing them + from the space. If provided, `eigenvalues_laplacian` must also be provided. + Used for :class:`~.spaces.HodgeDiscreteSpectrumSpace`. """ def __init__( @@ -58,11 +66,23 @@ def __init__( space: DiscreteSpectrumSpace, num_levels: int, normalize: bool = True, + eigenvalues_laplacian: Optional[B.Numeric] = None, + eigenfunctions: Optional[Eigenfunctions] = None, ): super().__init__(space) self.num_levels = num_levels # in code referred to as `L`. - self._eigenvalues_laplacian = self.space.get_eigenvalues(self.num_levels) - self._eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + + if eigenvalues_laplacian is None: + assert eigenfunctions is None + eigenvalues_laplacian = self.space.get_eigenvalues(self.num_levels) + eigenfunctions = self.space.get_eigenfunctions(self.num_levels) + else: + assert eigenfunctions is not None + assert eigenvalues_laplacian.shape == (num_levels, 1) + assert eigenfunctions.num_levels == num_levels + + self._eigenvalues_laplacian = eigenvalues_laplacian + self._eigenfunctions = eigenfunctions self.normalize = normalize @property @@ -93,12 +113,14 @@ def init_params(self) -> Dict[str, B.NPNumeric]: return params - def _spectrum( - self, s: B.Numeric, nu: B.Numeric, lengthscale: B.Numeric + @staticmethod + def spectrum( + s: B.Numeric, nu: B.Numeric, lengthscale: B.Numeric, dimension: int ) -> B.Numeric: """ - The spectrum of the Matérn kernel with hyperparameters `nu` and - `lengthscale` on the space with eigenvalues `s`. + Static method computing the spectrum of the Matérn kernel with + hyperparameters `nu` and `lengthscale` on the space with eigenvalues `s` + and dimension `dimension`. :param s: The eigenvalues of the space. @@ -106,6 +128,8 @@ def _spectrum( The smoothness parameter of the kernel. :param lengthscale: The length scale parameter of the kernel. + :param dimension: + The dimension of the space. :return: The spectrum of the Matérn kernel. @@ -122,7 +146,7 @@ def _spectrum( ) # for nu < np.inf - power = -safe_nu - self.space.dimension / 2.0 + power = -safe_nu - dimension / 2.0 base = 2.0 * safe_nu / lengthscale**2 + B.cast(B.dtype(safe_nu), s) spectral_values_nu_finite = base**power @@ -144,9 +168,7 @@ def eigenvalues_laplacian(self) -> B.Numeric: """ return self._eigenvalues_laplacian - def eigenvalues( - self, params: Dict[str, B.Numeric], normalize: Optional[bool] = None - ) -> B.Numeric: + def eigenvalues(self, params: Dict[str, B.Numeric]) -> B.Numeric: """ Eigenvalues of the kernel. @@ -154,11 +176,6 @@ def eigenvalues( Parameters of the kernel. Must contain keys `"lengthscale"` and `"nu"`. The shapes of `params["lengthscale"]` and `params["nu"]` are `(1,)`. - :param normalize: - Whether to normalize kernel to have unit average variance. - If None, uses `self.normalize` to decide. - - Defaults to None. :return: An [L, 1]-shaped array. @@ -168,13 +185,14 @@ def eigenvalues( assert "nu" in params assert params["nu"].shape == (1,) - spectral_values = self._spectrum( + spectral_values = self.spectrum( self.eigenvalues_laplacian, nu=params["nu"], lengthscale=params["lengthscale"], + dimension=self.space.dimension, ) - normalize = normalize or (normalize is None and self.normalize) - if normalize: + + if self.normalize: normalizer = B.sum( spectral_values * B.cast( @@ -186,10 +204,11 @@ def eigenvalues( ) ) return spectral_values / normalizer + return spectral_values def K( - self, params, X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore + self, params: Dict[str, B.Numeric], X: B.Numeric, X2: Optional[B.Numeric] = None, **kwargs # type: ignore ) -> B.Numeric: assert "lengthscale" in params assert params["lengthscale"].shape == (1,) @@ -204,7 +223,7 @@ def K( else: return K - def K_diag(self, params, X: B.Numeric, **kwargs) -> B.Numeric: + def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: assert "lengthscale" in params assert params["lengthscale"].shape == (1,) assert "nu" in params diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index d0ef1cb0..8a63aafb 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -11,6 +11,7 @@ from geometric_kernels.feature_maps import ( DeterministicFeatureMapCompact, + HodgeDeterministicFeatureMapCompact, RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, RejectionSamplingFeatureMapHyperbolic, @@ -18,11 +19,14 @@ ) from geometric_kernels.kernels.base import BaseGeometricKernel 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.spaces import ( CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, + GraphEdges, + HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, Hypersphere, @@ -84,6 +88,11 @@ def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): return DeterministicFeatureMapCompact(kernel.space, kernel.num_levels) +@overload +def feature_map_from_kernel(kernel: MaternHodgeCompositionalKernel): + return HodgeDeterministicFeatureMapCompact(kernel.space, kernel.num_levels) + + @overload def feature_map_from_kernel(kernel: MaternFeatureMapKernel): return kernel.feature_map @@ -140,6 +149,7 @@ def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) else: + return DeterministicFeatureMapCompact(space, num) @@ -200,6 +210,8 @@ def default_num(space: DiscreteSpectrumSpace) -> int: return min( MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_vertices ) + elif isinstance(space, GraphEdges): + return min(MaternGeometricKernel._DEFAULT_NUM_EIGENFUNCTIONS, space.num_edges) elif isinstance(space, HypercubeGraph): return min(MaternGeometricKernel._DEFAULT_NUM_LEVELS, space.dim + 1) else: @@ -311,6 +323,7 @@ def __new__( from Gaussian processes) along with the kernel. Default is False. + :param ``**kwargs``: Any additional keyword arguments to be passed to the kernel (like `key`). @@ -324,7 +337,10 @@ def __new__( kernel: BaseGeometricKernel if isinstance(space, DiscreteSpectrumSpace): num = num or default_num(space) - kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) + if isinstance(space, HodgeDiscreteSpectrumSpace): + kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) + else: + kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: feature_map = default_feature_map(kernel=kernel) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index b16a5759..2f80d42c 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -258,7 +258,7 @@ def dtype_bool(reference: B.TorchRandomState): # type: ignore @dispatch -def bool_like(reference: B.NPNumeric): +def bool_like(reference: B.TorchNumeric): """ Return the type of the reference if it is of boolean type. Otherwise return `bool` dtype of a backend based on the reference. diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index afc6ec24..5d74b2b2 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -21,6 +21,7 @@ def sample_at( params: Dict[str, B.Numeric], key: B.RandomState = None, normalize: bool = None, + hodge_type: Optional[str] = None, ) -> Tuple[B.RandomState, B.Numeric]: r""" Given a `feature_map` $\phi_{\nu, \kappa}: X \to \mathbb{R}^n$, where @@ -61,6 +62,10 @@ def sample_at( average variance of the Gaussian process to be around 1 or not. If None, follows the standard behavior, typically same as normalize=True. + Defaults to None. + :param hodge_type: + The type of Hodge component to sample. Only used when using Hodge-compositional edge kernels + Defaults to None. :return: @@ -71,16 +76,26 @@ def sample_at( if key is None: key = B.global_random_state(B.dtype(X)) - _context, features = feature_map(X, params, key=key, normalize=normalize) # [N, M] + if hodge_type is None: + _context, features = feature_map( + X, params, key=key, normalize=normalize + ) # [N, M] + else: + _context, features = feature_map( + X, params, key=key, normalize=normalize, hodge_type=hodge_type + ) if _context is not None: key = _context num_features = B.shape(features)[-1] - key, random_weights = B.randn( - key, B.dtype(params["lengthscale"]), num_features, s - ) # [M, S] + if "lengthscale" in params: + dtype = B.dtype(params["lengthscale"]) + else: + dtype = B.dtype(params["gradient"]["lengthscale"]) + + key, random_weights = B.randn(key, dtype, num_features, s) # [M, S] random_sample = B.matmul(features, random_weights) # [N, S] diff --git a/geometric_kernels/spaces/__init__.py b/geometric_kernels/spaces/__init__.py index 31698b71..700b75a5 100644 --- a/geometric_kernels/spaces/__init__.py +++ b/geometric_kernels/spaces/__init__.py @@ -5,11 +5,13 @@ # noqa: F401 from geometric_kernels.spaces.base import ( DiscreteSpectrumSpace, + HodgeDiscreteSpectrumSpace, NoncompactSymmetricSpace, Space, ) 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.hyperbolic import Hyperbolic from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.spaces.hypersphere import Hypersphere diff --git a/geometric_kernels/spaces/base.py b/geometric_kernels/spaces/base.py index 9d3b7ca4..95954350 100644 --- a/geometric_kernels/spaces/base.py +++ b/geometric_kernels/spaces/base.py @@ -5,7 +5,7 @@ import abc import lab as B -from beartype.typing import List +from beartype.typing import List, Optional from geometric_kernels.spaces.eigenfunctions import Eigenfunctions @@ -157,6 +157,102 @@ def random(self, key: B.RandomState, number: int) -> B.Numeric: raise NotImplementedError +class HodgeDiscreteSpectrumSpace(DiscreteSpectrumSpace): + r""" + A Space with discrete spectrum (of the Laplacian) and Hodge decomposition. + + Separates eigenpairs according to the Hodge decomposition, into the curl + type (divergence-free), the gradient type (curl-free), and the harmonic + type (both divergence- and curl-free). + + Examples of such spaces are the edge space of a graph, or tangent bundles + of compact Riemannian manifolds. + + .. note:: + Hodge decomposition is briefly discussed on :doc:`this ` + documentation page. + + .. note:: + Typically used with :class:`~.kernels.MaternHodgeCompositionalKernel`. + """ + + @abc.abstractmethod + def get_eigenfunctions( + self, num: int, type: Optional[str] = None + ) -> Eigenfunctions: + """ + Returns the :class:`~.Eigenfunctions` object with `num` levels. + If `type` is specified, returns only the eigenfunctions of that type. + + .. warning:: + If `type` is specified, the returned :class:`~.Eigenfunctions` + object does not have to have `num` levels. It can have fewer but can + never have more. + + :param num: + Number of levels. + + :param type: + Type of the eigenfunctions to return. Can be one of "harmonic", + "curl" or "gradient". + + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + @abc.abstractmethod + def get_eigenvalues(self, num: int, type: Optional[str] = None) -> B.Numeric: + """ + Eigenvalues of the Laplacian corresponding to the first `num` levels. + If `type` is specified, returns only the eigenvalues corresponding to + the eigenfunctions of that type. + + .. warning:: + If `type` is specified, the array can have fewer than `num` elements. + + :param num: + Number of levels. + + :return: + (n, 1)-shaped array containing the eigenvalues. n <= num. + + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + @abc.abstractmethod + def get_repeated_eigenvalues( + self, num: int, type: Optional[str] = None + ) -> B.Numeric: + """ + Eigenvalues of the Laplacian corresponding to the first `num` levels, + repeated according to their multiplicity within levels. If `type` is + specified, returns only the eigenvalues corresponding to the + eigenfunctions of that type. + + :param num: + Number of levels. + + :param type: + Type of the eigenvalues to return. Can be one of "harmonic", + "curl" or "gradient". + + :return: + (J, 1)-shaped array containing the repeated eigenvalues, J is + the resulting number of the repeated eigenvalues (of the specified + type, if `type` is given). + + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + raise NotImplementedError + + class NoncompactSymmetricSpace(Space): """ Non-compact symmetric space. diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 5ad7b8f6..9ecf61ef 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -264,10 +264,15 @@ class EigenfunctionsFromEigenvectors(Eigenfunctions): :param eigenvectors: Array of shape [D, J] containing J eigenvectors of dimension D. + + :param index_from_one: + If True, the indices are assumed to be 1-based. If False, they are + assumed to be 0-based. Defaults to False. """ - def __init__(self, eigenvectors: B.Numeric): + def __init__(self, eigenvectors: B.Numeric, index_from_one: bool = False): self.eigenvectors = eigenvectors + self.index_from_one = index_from_one def weighted_outerproduct( self, @@ -323,7 +328,14 @@ def __call__(self, X: B.Numeric, **kwargs) -> B.Numeric: corresponds to the X[n]-th element of the j-th eigenvector. """ indices = B.cast(B.dtype_int(X), X) - Phi = take_along_axis(self.eigenvectors, indices, axis=0) + if self.index_from_one: + # assert B.all(indices >= 1) removed because of tensorflow's + # OperatorNotAllowedInGraphError + Phi = take_along_axis(self.eigenvectors, indices - 1, axis=0) + else: + # assert B.all(indices >= 0) removed because of tensorflow's + # OperatorNotAllowedInGraphError + Phi = take_along_axis(self.eigenvectors, indices, axis=0) return Phi @property diff --git a/geometric_kernels/spaces/graph_edges.py b/geometric_kernels/spaces/graph_edges.py new file mode 100644 index 00000000..5df4c39d --- /dev/null +++ b/geometric_kernels/spaces/graph_edges.py @@ -0,0 +1,857 @@ +""" +This module provides the :class:`EdgeGraph` space. +""" + +import lab as B +import numpy as np +from beartype.door import is_bearable +from beartype.typing import Dict, List, Optional, Tuple, Union +from scipy.sparse import csr_matrix, lil_matrix + +from geometric_kernels.lab_extras import ( + SparseArray, + count_nonzero, + dtype_integer, + eigenpairs, + float_like, + int_like, + take_along_axis, +) +from geometric_kernels.spaces.base import HodgeDiscreteSpectrumSpace +from geometric_kernels.spaces.eigenfunctions import ( + Eigenfunctions, + EigenfunctionsFromEigenvectors, +) + + +class GraphEdges(HodgeDiscreteSpectrumSpace): + """ + The GeometricKernels space representing the edge set of a user-provided + graph. The graph must be unweighted, undirected, and without loops. + However, we assume the graph is oriented: for every edge, either (i, j) + or (j, i) is chosen as the positively oriented edge, with the other one + being negatively oriented. Any function f on this space must satisfy + f(e) = -f(-e) if e is a positively oriented edge and -e is the + corresponding negatively oriented edge. + + All positively oriented edges are indexed **from 1 to the number of edges + (inclusive)**. The reason why we start indexing the edges from 1 is to + allow for edge -e to correspond to the opposite orientation of edge e. + Importantly, orientation or a particular ordering of edges does not + affect the geometry of the space. However, changing those requires the + respective change in the way you represent the data. + + For this space, each individual eigenfunction constitutes a *level*. If + possible, we recommend using num=num_edges levels. Since the current + implementation does not support sparse eigensolvers anyway, this should + not create too much time/memory overhead during the precomputations and + will also ensure that all types of eigenfunctions are present in the + eigensystem. + + .. admonition:: Tutorial + + A tutorial on how to use this space is available in the + :doc:`GraphEdges.ipynb ` notebook. + + .. admonition:: Theory + + Mathematically, this space is actually a simplicial 2-complex, and + the functions satisfying the condition f(e) = -f(-e) are called + 1-cochains. These admit a Hodge decomposition into the harmonic, + gradient, and curl parts. You can find more about Hodge decomposition + on :doc:`this page `. + + .. admonition:: Construction + + **Easy way:** construct the space from the adjacency matrix of the graph. + + The easiest way to construct an instance of this space is to use the + :meth:`from_adjacency` method, which constructs the space from the + adjacency matrix of the graph. By default, this would use all possible + triangles in the graph, but the user can also provide a list of + triangles explicitly. These triangles define the curl operator on the + graph and are thus instrumental in defining the Hodge decomposition. + If you don't know what triangles to provide, you can leave this + parameter empty, and the space will compute the maximal set of + triangles for you, which is a good solution in most cases. + + When constructing an instance this way, the orientation of the edges and + triangles is chosen automatically in such a way that (i, j) is always + positively oriented if i < j, and the triangles are of form (e1, e2, e3) + where e1 = (i, j), e2 = (j, k), e3 = -(i, k), and i < j < k. + + **Hard way:** construct the space from the oriented edges and triangles. + + When constructing an instance of this space directly via :meth:`__init__`, + the user provides an `oriented_edges` array, mapping edge indices to + ordered pairs of node indices, with order defining the positive + orientation, and an `oriented_triangles` array, mapping triangle indices + to triples of signed edge indices. These arrays must be compatible in + the sense that the edges in triangles must be connected. This way, the + user has full control over the orientation and ordering of the edges. + + .. admonition:: Complexity + + The current implementation of the GraphEdges space is supposed to occupy + O(num_edges^2) memory and take O(num_edges^3) time to compute the eigensystem. + + Currently, it does not support sparse eigensolvers, which would allow + storing the Laplacian matrices in a sparse format and potentially reduce + the O(num_edges^3) complexity to O(num_edges) with a large constant. + + :param num_nodes: + The number of nodes in the graph. + + :param oriented_edges: + A 2D array of shape [num_edges, 2], where num_edges is the number of edges + in the graph. Each row of the array represents an oriented edge, i.e., + a pair of node indices. If `oriented_edges[e]` is `[i, j]`, then the + edge with index e+1 (edge indexing starts from 1) represents an edge + from node `i` to node `j` which is considered positively oriented, while + the edge with index -e-1 represents an edge from node `j` to node `i`. + + Make sure that `oriented_edges` and `oriented_triangles` are of the + backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for + internal computations. + + :param oriented_triangles: + A 2D array of shape [num_triangles, 3], where num_triangles is the number + of triangles in the graph. Each row of the array represents an + oriented triangle, i.e., a triple of signed edge indices. If + `oriented_triangles[t]` is `[i, j, k]`, then `t` consists of the edges + `|i|`, `|j|`, and `|k|`, where the sign of the edge index indicates + the orientation of the edge. Optional. If not provided or set to + `None`, we assume that the set of triangles is empty. + + Make sure that `oriented_edges` and `oriented_triangles` are of the + backend (NumPy / JAX / TensorFlow, PyTorch) that you wish to use for + internal computations. + + :param checks_mode: + A keyword argument that determines the level of checks performed on + the oriented_edges and oriented_triangles arrays. The default value is + "simple", which performs only basic checks. The other possible values + are "comprehensive" and "skip", which perform more extensive checks + and no checks, respectively. The "comprehensive" mode is useful for + debugging but can be slow for large graphs. + + :param index: + Optional. A sparse matrix of shape [num_nodes, num_nodes] such that + `index[i, j]` is the index of the edge `(i, j)` in the `oriented_edges`. + `index[i, j]` is positive if (i, j) corresponds to positive orientation + of the edge, and negative if it corresponds to the negative orientation. + If provided, should be compatible with the `oriented_edges` array. + + .. admonition:: Citation + + If you use this GeometricKernels space in your research, please consider + citing :cite:t:`yang2024`. + """ + + def __init__( + self, + num_nodes: int, + oriented_edges: B.Int, + oriented_triangles: Optional[B.Int], + *, + checks_mode: str = "simple", + index: Optional[csr_matrix] = None, + ): + if checks_mode not in ["simple", "comprehensive", "skip"]: + raise ValueError( + "The `checks_mode` parameter must be 'simple', 'comprehensive', or 'skip'." + ) + else: + do_checks = checks_mode != "skip" + comprehensive_checks = checks_mode == "comprehensive" + + self.cache: Dict[int, Tuple[B.Numeric, B.Numeric]] = {} + self.num_nodes = num_nodes + + if do_checks: + self._checks_oriented_edges(oriented_edges, num_nodes, comprehensive_checks) + self.num_edges = oriented_edges.shape[0] + self.oriented_edges = oriented_edges + + if oriented_triangles is not None: + if do_checks: + self._checks_oriented_triangles( + oriented_triangles, comprehensive_checks + ) + if comprehensive_checks: + self._checks_compatible(oriented_triangles) + self.num_triangles = oriented_triangles.shape[0] + else: + self.num_triangles = 0 + self.oriented_triangles = oriented_triangles + + if index is not None: + if comprehensive_checks: + self._check_index(index) + self.index = index + else: + self.index = self._compute_index(num_nodes, oriented_edges) + + self._set_laplacian() + + def __str__(self): + return f"GraphEdges({self.num_edges})" + + @staticmethod + def _compute_index(num_nodes: int, oriented_edges: B.Numeric) -> csr_matrix: + """ + Construct the index matrix from the oriented edges. + + :param num_nodes: + The number of nodes in the graph. + + :param oriented_edges: + The oriented edges array. + + :return: + The index matrix. A scipy csr_matrix of shape [num_nodes, num_nodes] such + that `index[i, j]` is the index of the edge `(i, j)`. + """ + result = lil_matrix((num_nodes, num_nodes), dtype=int) + for i in range(oriented_edges.shape[0]): + result[oriented_edges[i, 0], oriented_edges[i, 1]] = i + 1 + result[oriented_edges[i, 1], oriented_edges[i, 0]] = -i - 1 + return result.tocsr() + + def _checks_oriented_edges( + self, oriented_edges: B.Numeric, num_nodes: int, comprehensive: bool = False + ): + """ + Checks if `oriented_edges` is of appropriate structure. + + :param oriented_edges: + The oriented edges array. + + :param comprehensive: + If True, perform more extensive checks. + """ + + assert ( + B.rank(oriented_edges) == 2 + ), "The oriented_edges array must be 2-dimensional." + + assert B.shape(oriented_edges)[1] == 2, "oriented_edges must have shape (*, 2)." + + assert B.dtype(oriented_edges) == int_like( + oriented_edges + ), "The oriented_edges must be an array of integers." + assert B.all( + oriented_edges >= 0 + ), "The oriented_edges array must contain only non-negative values." + assert B.all( + oriented_edges < self.num_nodes + ), "The values in the oriented_edges array must be < self.num_nodes." + assert B.all( + oriented_edges[:, 0] - oriented_edges[:, 1] != 0 + ), "Loops are not allowed." + + if comprehensive: + num_edges = oriented_edges.shape[0] + + for i in range(num_edges): + for j in range(i + 1, num_edges): + assert B.any( + oriented_edges[i, :] != oriented_edges[j, :] + ), "The oriented_edges array must not contain duplicate edges." + assert B.any( + oriented_edges[i, :] != oriented_edges[j, ::-1] + ), "The oriented_edges array must not contain duplicate edges." + + assert set(range(self.num_nodes)) == set( + B.to_numpy(B.flatten(oriented_edges)) + ), "The oriented_edges array must contain all nodes." + + def _checks_oriented_triangles( + self, oriented_triangles: B.Numeric, comprehensive=False + ): + """ + Checks if `oriented_triangles` is of appropriate structure. + + :param oriented_triangles: + The oriented triangles array. + + :param comprehensive: + If True, perform more extensive checks. + """ + + assert ( + B.rank(oriented_triangles) == 2 + ), "The oriented_triangles array must be 2-dimensional." + + assert ( + B.shape(oriented_triangles)[1] == 3 + ), "oriented_triangles must have shape (*, 3)." + + assert B.dtype(oriented_triangles) == int_like( + oriented_triangles + ), "The oriented_triangles must be an array of integers." + assert B.all( + B.abs(oriented_triangles) >= 1 + ), "The oriented_triangles array must contain only non-zero values." + assert B.all( + B.abs(oriented_triangles) <= self.num_edges + ), "The absolute values in the oriented_triangles array must be <= self.num_edges." + + assert B.all( + B.abs(oriented_triangles) < self.num_edges + ), "The absolute values in the oriented_triangles array must be less than self.num_edges." + assert ( + B.all( + B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 1]) != 0 + ) + or B.all( + B.abs(oriented_triangles[:, 0]) - B.abs(oriented_triangles[:, 2]) != 0 + ) + or B.all( + B.abs(oriented_triangles[:, 1]) - B.abs(oriented_triangles[:, 2]) != 0 + ) + ), "Triangles must consist of 3 different edges." + + if comprehensive: + num_triangles = oriented_triangles.shape[0] + + for i in range(num_triangles): + for j in range(i + 1, num_triangles): + assert B.any( + oriented_triangles[i, :] != oriented_triangles[j, :] + ), "The oriented_triangles array must not contain duplicate triangles." + + def _checks_compatible( + self, + oriented_triangles: B.Numeric, + ): + """ + Checks if `self.oriented_edges` and `oriented_triangles` are compatible. + + :param oriented_triangles: + The oriented triangles array. + """ + + assert B.dtype(self.oriented_edges) == B.dtype( + oriented_triangles + ), "The oriented_edges and oriented_triangles arrays must have the same dtype." + + num_triangles = oriented_triangles.shape[0] + for t in range(num_triangles): + resolved_edges = self.resolve_edges(oriented_triangles[t, :]) + assert ( + resolved_edges[0, 1] == resolved_edges[1, 0] + ), "The edges in the triangle must be connected." + assert ( + resolved_edges[1, 1] == resolved_edges[2, 0] + ), "The edges in the triangle must be connected." + assert ( + resolved_edges[2, 1] == resolved_edges[0, 0] + ), "The edges in the triangle must be connected." + + def _check_index(self, index: csr_matrix): + edges = [] + for e in range(1, self.oriented_edges.shape[0] + 1): + i, j = self.oriented_edges[e - 1, :] + assert ( + index[i, j] == e + ), "The index matrix must be compatible with oriented_edges." + assert ( + index[j, i] == -e + ), "The index matrix must be compatible with oriented_edges." + edges.append((min(i, j), max(i, j))) + + for i in range(self.num_nodes): + for j in range(i + 1, self.num_nodes): + if (i, j) not in edges: + assert ( + index[i, j] == 0 + ), "The index matrix must be compatible with oriented_edges." + assert ( + index[j, i] == 0 + ), "The index matrix must be compatible with oriented_edges." + + def resolve_edges(self, es: B.Int) -> B.Int: + r""" + Resolve the signed edge indices to node indices. + + :param es: + A 1-dimensional array of edge indices. Each edge index is a number + from 1 to the number of edges (incl.). + + :return: + A 2-dimensional array `result` such that `result[e, :]` is `[i, j]` + where \|e\| = (i, j) if e > 0 and \|e\| = (j, i) if e < 0. + """ + assert B.rank(es) == 1 + assert B.all(B.abs(es) >= 1) and B.all(B.abs(es) <= self.num_edges) + + result = self.oriented_edges[B.abs(es) - 1] + result = B.where(B.expand_dims(es > 0, axis=-1), result, result[:, ::-1]) + return result + + def resolve_triangles(self, ts: B.Int) -> B.Int: + """ + Resolve the triangle indices to node indices. + + :param ts: + A 1-dimensional array of triangle indices. Each triangle index is a + number from 0 to the number of triangles. + + :return: + A 3-dimensional array `result` such that `result[t, :]` is `[i, j, k]` + where i = e1[0], j = e2[0], k = e3[0], and e1, e2, e3 are the + oriented edges constituting the triangle `t`. + """ + assert B.rank(ts) == 1 + assert B.all(B.abs(ts) >= 0) and B.all(B.abs(ts) < self.num_triangles) + + edge_indices = B.flatten( + self.oriented_triangles[ts] + ) # [N,] -> [N, 3] -> [N*3,] + edges = B.reshape( + self.resolve_edges(edge_indices), len(ts), 3, 2 + ) # [N*3,] -> [N*3, 2] -> [N, 3, 2] + return edges[:, :, 0] # [N, 3, 2] -> [N, 3] + + @classmethod + def from_adjacency( # noqa: C901 + cls, + adjacency_matrix: Union[B.NPNumeric, SparseArray], + type_reference: B.RandomState, + *, + triangles: Optional[List[Tuple[int, int, int]]] = None, + checks_mode: str = "simple", + ) -> "GraphEdges": + """ + Construct the GraphEdges space from the adjacency matrix of a graph. + + :param adjacency_matrix: + Adjacency matrix of a graph. A numpy array of shape + `[num_nodes, num_nodes]` where `num_nodes` is the number of nodes in the + graph. `adjacency_matrix[i, j]` can only be 0 or 1. + + :param type_reference: + A random state object of the preferred backend to infer backend from. + + :param triangles: + A list of tuples of three integers representing the nodes of the + triangles in the graph. If not provided or set to None, the maximal + possible set of triangles will be computed and used. + + :param checks_mode: + Forwards the `checks_mode` parameter to the constructor. + + :return: + A constructed instance of the GraphEdges space. + """ + if isinstance(adjacency_matrix, np.ndarray): + index = csr_matrix(adjacency_matrix, dtype=int) + elif is_bearable(adjacency_matrix, SparseArray): + index = csr_matrix(adjacency_matrix, dtype=int, copy=True) + else: + raise ValueError( + f"The adjacency matrix must be a numpy array or a scipy sparse matrix not {type(adjacency_matrix)}. Use `type_reference` to specify the backend." + ) + + if len(index.shape) != 2: + raise ValueError("Adjacency matrix must be a square matrix.") + if (abs(index - index.T) > 1e-10).nnz != 0: + raise ValueError("Adjacency matrix must be symmetric.") + if (index.diagonal() != 0).any(): + raise ValueError("Adjacency matrix must have zeros on the diagonal.") + if np.sum(index.data == 1) + np.sum(index.data == 0) != len(index.data): + raise ValueError("Adjacency matrix can only contain zeros and ones.") + + number_of_nodes = index.shape[0] + number_of_edges = np.sum(index.data) // 2 + + oriented_edges = np.zeros((number_of_edges, 2), dtype=np.int32) + + cur_edge_ind = 1 + for i in range(number_of_nodes): + for j in range(i + 1, number_of_nodes): + if index[i, j] == 1: + oriented_edges[cur_edge_ind - 1, 0] = i + oriented_edges[cur_edge_ind - 1, 1] = j + # We also store cur_edge_ind in the index matrix for later use + index[i, j] = cur_edge_ind + index[j, i] = -index[i, j] + cur_edge_ind += 1 + assert ( + cur_edge_ind == number_of_edges + 1 + ) # double check that we have the right number of edges + oriented_edges = B.cast(dtype_integer(type_reference), oriented_edges) + + if triangles is None: + triangles = [] + for i in range(number_of_nodes): + for j in range(i + 1, number_of_nodes): + for k in range(j + 1, number_of_nodes): + if index[i, j] != 0 and index[j, k] != 0 and index[i, k] != 0: + triangles.append((i, j, k)) + + number_of_triangles = len(triangles) + oriented_triangles = np.zeros((number_of_triangles, 3), dtype=np.int32) + for triangle_index, triangle in enumerate(triangles): + i, j, k = sorted(triangle) # sort the nodes in the triangle + oriented_triangles[triangle_index, 0] = index[i, j] + oriented_triangles[triangle_index, 1] = index[j, k] + oriented_triangles[triangle_index, 2] = index[k, i] + oriented_triangles = B.cast(dtype_integer(type_reference), oriented_triangles) + + return cls( + number_of_nodes, + oriented_edges, + oriented_triangles, + checks_mode=checks_mode, + index=index, + ) + + @property + def dimension(self) -> int: + """ + :return: + 0. + """ + return 0 # this is needed for the kernel math to work out + + def _set_laplacian(self): + """ + Construct the appropriate graph Laplacian from the adjacency matrix. + """ + + # This does node_to_edge_incidence.T @ node_to_edge_incidence + # TODO: make this more efficient, avoid for loops. + self._down_laplacian = np.zeros( + (self.num_edges, self.num_edges), dtype=np.int32 + ) + for i in range(self.num_edges): + for j in range(self.num_edges): + self._down_laplacian[i, j] = ( + int(self.oriented_edges[i, 0] == self.oriented_edges[j, 0]) + + int(self.oriented_edges[i, 1] == self.oriented_edges[j, 1]) + - int(self.oriented_edges[i, 0] == self.oriented_edges[j, 1]) + - int(self.oriented_edges[i, 1] == self.oriented_edges[j, 0]) + ) + self._down_laplacian = B.cast( + float_like(self.oriented_edges), self._down_laplacian + ) + + # This does edge_to_triangle_incidence @ edge_to_triangle_incidence.T + # TODO: make this more efficient, avoid for loops. + self._up_laplacian = np.zeros((self.num_edges, self.num_edges), dtype=np.int32) + for i in range(self.num_edges): + for j in range(self.num_edges): + for t in range(self.num_triangles): + cur_triangle = set(B.to_numpy(self.oriented_triangles[t, :])) + if (i + 1 in cur_triangle and j + 1 in cur_triangle) or ( + -i - 1 in cur_triangle and -j - 1 in cur_triangle + ): + self._up_laplacian[i, j] += 1 + if (i + 1 in cur_triangle and -j - 1 in cur_triangle) or ( + -i - 1 in cur_triangle and j + 1 in cur_triangle + ): + self._up_laplacian[i, j] += -1 + self._up_laplacian = B.cast(float_like(self.oriented_edges), self._up_laplacian) + + self._hodge_laplacian = self._down_laplacian + self._up_laplacian + + def _get_eigensystem(self, num): + """ + Returns the first `num` eigenvalues and eigenvectors of the Hodge Laplacian. + Caches the solution to prevent re-computing the same values. + + :param num: + Number of eigenpairs to return. Performs the computation at the + first call. Afterwards, fetches the result from cache. + + :return: + A tuple of eigenvectors [n, num], eigenvalues [num, 1]. + """ + + # The current implementation computes the complete set of eigenpairs of + # three num_edges x num_edges Laplacian matrices. Since we don't currently + # support sparse Laplacians, this should not be a major bottleneck. + # + # Here are some important points for anyone who wants to add proper + # support for sparse Laplacians and sparse eigensolvers which allow + # computing only a few of the most important eigenpairs, like + # scipy.sparse.linalg.eigsh. + # + # 1. You cannot just compute the eigenpairs of the Hodge Laplacian and + # then filter them into the harmonic, gradient, or curl parts. This + # is because up and down edge Laplacians may have common non-zero + # eigenvalues. This means that the eigenspaces of the Hodge + # Laplacian that correspond to such eigenvalues will contain both + # gradient and curl types of eigenvectors. When an eigenspace is + # multi-dimensional, an eigensolver can return an arbitrary basis + # for it. Thus, for example, you may get a basis where all the vectors + # have non-zero grad and curl components at the same time. Thus, you + # won't be able to filter them. + # + # If you put in more effort, you can take the basis for each non-zero + # eigenvalue with multiplicity > 1, project each vector onto the + # pure-gradient and pure-curl subspaces (using up and down Laplacians), + # and then orthogonalize the projected vectors. + # + # 2. You cannot just request `num` eigenpairs from the Hodge Laplacian, + # up Laplacian and down Laplacian. Imagine that you have a space + # with 5 harmonic, 100 gradient, and 100 curl eigenpairs. Then, + # the first 105 eigenpairs of the up Laplacian will correspond to + # harmonic and gradient eigenvectors, both corresponding to zero + # eigenvalues, while only the last 100 eigenpairs will correspond + # to the actual curl eigenvectors that we are interested in getting + # from the up Laplacian. The same is true for the down Laplacian. + # + # 3. An elegant solution would be to construct + # > diff_laplacian = up_laplacian - down_laplacian + # and run a sparse eigensolver on this matrix, requesting `num` + # eigenpairs with the lowest absolute value of eigenvalues. Then, + # you get eigenpairs of the Hodge Laplacian corresponding to the + # first `num` smallest eigenvalues, but the gradient and curl + # eigenvectors would correspond to eigenvalues of different signs + # and thus would be separated. + + eps = 1e-6 + + if num not in self.cache: + # We use Hodge Laplacian to find the eigenpairs of harmonic type, + # these are the ones associated to zero eigenvalues. + evals_hodge, evecs_hodge = eigenpairs(self._hodge_laplacian, self.num_edges) + + # We use up and down Laplacians to find the eigenpairs of curl and + # gradient types. These are the ones associated to non-zero eigenvalues. + evals_up, evecs_up = eigenpairs(self._up_laplacian, self.num_edges) + evals_down, evecs_down = eigenpairs(self._down_laplacian, self.num_edges) + + # We count the number of eigenpairs of each type for future reference. + n_harm = count_nonzero(evals_hodge < eps) + n_curl, n_grad = count_nonzero(evals_up >= eps), count_nonzero( + evals_down >= eps + ) + + # We concatenate the eigenvalues and eigenvectors of harmonic, curl, and + # gradient types into a single array. + evals = B.concat( + evals_hodge[evals_hodge < eps], + evals_up[evals_up >= eps], + evals_down[evals_down >= eps], + ) + + evecs = B.concat( + B.reshape( + evecs_hodge[ + B.broadcast_to( + evals_hodge < eps, self.num_edges, self.num_edges + ) + ], + self.num_edges, + -1, + ), + B.reshape( + evecs_up[ + B.broadcast_to(evals_up >= eps, self.num_edges, self.num_edges) + ], + self.num_edges, + -1, + ), + B.reshape( + evecs_down[ + B.broadcast_to( + evals_down >= eps, self.num_edges, self.num_edges + ) + ], + self.num_edges, + -1, + ), + axis=-1, + ) + + evecs *= B.sqrt(self.num_edges) # to make sure average variance is 1. + + # We get the indices that would sort the eigenvalues in ascending order. + sorted_indices = B.argsort(evals) + # And the indices that would inverse the sorting using sorted_indices. + sorted_sorted_indices = B.argsort(sorted_indices) + + # In harmonic_idx, gradient_idx, and curl_idx, we store the indices of + # the eigenvalues and eigenvectors of harmonic, gradient, and curl types. + # We also make sure that the indices are not greater than `num`. + harmonic_idx = sorted_sorted_indices[:n_harm] + harmonic_idx = harmonic_idx[harmonic_idx < num] + curl_idx = sorted_sorted_indices[n_harm : n_harm + n_curl] + curl_idx = curl_idx[curl_idx < num] + grad_idx = sorted_sorted_indices[n_harm + n_curl : n_harm + n_curl + n_grad] + grad_idx = grad_idx[grad_idx < num] + + # We sort the eigenvalues and eigenvectors in ascending order of + # eigenvalues, keeping only `num` of the first eigenpairs. + sorted_indices = sorted_indices[:num] + + evals = take_along_axis(evals, sorted_indices) + evecs = take_along_axis(evecs, sorted_indices[None, :], axis=-1) + + self.cache[num] = { + "evals": evals, + "evecs": evecs, + "harmonic_idx": harmonic_idx, + "gradient_idx": curl_idx, + "curl_idx": grad_idx, + } + + return self.cache[num] + + def get_number_of_eigenpairs(self, num: int, hodge_type: str) -> int: + """ + Returns the number of eigenpairs of a particular type. + + :param num: + Number of levels. + + :param hodge_type: + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". + + :return: + The number of eigenpairs of the specified type. + """ + eigensystem = self._get_eigensystem(num) + return len(eigensystem[f"{hodge_type}_idx"]) + + def get_eigenfunctions( + self, num: int, hodge_type: Optional[str] = None + ) -> Eigenfunctions: + """ + Returns the :class:`~.EigenfunctionsFromEigenvectors` object with + `num` levels (i.e., in this case, `num` eigenpairs) of a particular type. + + :param num: + Number of levels. + + :param hodge_type: + The type of the eigenbasis. It can be "harmonic", "gradient", or "curl". + + :return: + EigenfunctionsFromEigenvectors object. + + .. note:: + The notion of *levels* is discussed in the documentation of the + :class:`~.kernels.MaternKarhunenLoeveKernel`. + """ + eigensystem = self._get_eigensystem(num) + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + eigenfunctions = EigenfunctionsFromEigenvectors( + take_along_axis( + eigensystem["evecs"], + B.cast(int_like(eigensystem["evecs"]), np.array(idx)[None, :]), + axis=-1, + ), + index_from_one=True, + ) + return eigenfunctions + + def get_eigenvectors(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: + """ + Eigenvectors of the Laplacian corresponding to the first `num` levels + (i.e., in this case, `num` eigenpairs). If `type` is specified, returns + only the eigenvectors of that type. + + :param num: + Number of eigenvectors to return. + + :param hodge_type: + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". + + :return: + (n, 1)-shaped array containing the eigenvalues. n <= num. + """ + eigensystem = self._get_eigensystem(num) + + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + + eigenvectors = take_along_axis( + eigensystem["evecs"], + B.cast(int_like(eigensystem["evecs"]), np.array(idx)[None, :]), + axis=-1, + ) + + return eigenvectors + + def get_eigenvalues(self, num: int, hodge_type: Optional[str] = None) -> B.Numeric: + """ + Eigenvalues of the Laplacian corresponding to the first `num` levels + (i.e., in this case, `num` eigenpairs). If `type` is specified, returns + only the eigenvalues corresponding to the eigenfunctions of that type. + + .. warning:: + If `type` is specified, the array can have fewer than `num` elements. + + :param num: + Number of levels. + + :param hodge_type: + The type of the eigenpairs. It can be "harmonic", "gradient", or "curl". + + :return: + (n, 1)-shaped array containing the eigenvalues. n <= num. + """ + eigensystem = self._get_eigensystem(num) + + idx = ( + eigensystem[f"{hodge_type}_idx"] + if hodge_type is not None + else list(range(num)) + ) + + eigenvalues = take_along_axis( + eigensystem["evals"], B.cast(int_like(eigensystem["evals"]), np.array(idx)) + ) + + return eigenvalues[:, None] + + def get_repeated_eigenvalues( + self, num: int, hodge_type: Optional[str] = None + ) -> B.Numeric: + """ + Same as :meth:`get_eigenvalues`. + + :param num: + Same as :meth:`get_eigenvalues`. + """ + return self.get_eigenvalues(num, hodge_type) + + def random(self, key, number): + key, random_edges = B.randint( + key, + dtype_integer(key), + number, + 1, + lower=1, + upper=self.num_edges + 1, + ) + + return key, random_edges + + @property + def element_shape(self): + """ + :return: + [1]. + """ + return [1] + + @property + def element_dtype(self): + """ + :return: + B.Int. + """ + return B.Int diff --git a/notebooks/Graph.ipynb b/notebooks/Graph.ipynb index 8c18fd17..4322ff23 100644 --- a/notebooks/Graph.ipynb +++ b/notebooks/Graph.ipynb @@ -30,8 +30,9 @@ "\n", "We use the **numpy** backend here.\n", "\n", - "**Important:** if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the [line graph](https://en.wikipedia.org/wiki/Line_graph). The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the [line_graph](https://networkx.org/documentation/stable/reference/generated/networkx.generators.line.line_graph.html#line-graph) function of `networkx`. Alternatively, especially for the flow-type data, you might want to use specialized edge kernels, see [Yang et al. (2023)](https://arxiv.org/abs/2310.19450) and [Alain et al. (2023)](https://arxiv.org/abs/2311.01198>).\n", - "These are not implemented in GeometricKernels at the moment.\n" + "**Important:** if you want to model a **signal on the edges** of a graph $G$, you can consider modeling the signal on the nodes of the [line graph](https://en.wikipedia.org/wiki/Line_graph). The line graph of $G$ has a node for each edge of $G$ and its two nodes are connected by an edge if the corresponding edges in $G$ used to share a common node. To build the line graph, you can use the [line_graph](https://networkx.org/documentation/stable/reference/generated/networkx.generators.line.line_graph.html#line-graph) function of `networkx`. Alternatively, especially for the flow-type data, you might want to use specialized edge kernels.\n", + "For these, take a look into [GraphEdges.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/GraphEdges.html).\n", + "If you want to model a singal on a metric graph, take a look into [Bolin et al. (2023)](https://arxiv.org/abs/2304.10372) —owever, the machinery from this paper is not currently implemented in GeometricKernels." ] }, { diff --git a/notebooks/GraphEdges.ipynb b/notebooks/GraphEdges.ipynb new file mode 100644 index 00000000..f77bbdc5 --- /dev/null +++ b/notebooks/GraphEdges.ipynb @@ -0,0 +1,1127 @@ +{ + "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 The Edge Set of a Graph (Simplicial 2-complex)\n", + "This notebook shows how to define and evaluate kernels on the edge space of a graph, i.e. kernels $k: E \\times E \\to \\mathbb{R}$ where $E$ is the edge set of some user-provided graph $G$. \n", + "Formally, we work with a simplicial 2-complex, which is essentially a graph $G = (V, E)$, where $V$ is the node set and $E$ is the edge set, together with a set of triangles $T$.\n", + "However, if you don't know how to set $T$, you don't need to worry, as we have a reasonable default for it, allowing you to regard this space as just a graph.\n", + "\n", + "The graph $G$ **must be** unweigted, undirected, and without loops.\n", + "\n", + "The edges are indexed from $1$ to $|E|$ (inclusive), i.e. $E = \\{1, 2, ..., |E|\\}$.\n", + "The graph is **oriented** (not to be confused with *directed*): for each $e \\in E$, we have $e = (i, j)$ with $i, j \\in V$, and where $(i, j)$ is an **ordered** tuple defining the positive orientation of the edge.\n", + "The edge $(j, i)$ is then considered to be negatively oriented, and is sometimes referred to as $-e$.\n", + "This is why we start indexing edges from $1$: to always be able to take $-e$.\n", + "The functions $f: E \\to \\mathbb{R}$ are assumed to be automatically extended to $E \\cup -E$ by $f(-e) = -f(e)$.\n", + "\n", + "**Note:** orientation and ordering of edges do not change the geometry of the space.\n", + "However, they affect the way in which you represent the data.\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 edge space of graphs and how to use these to efficiently sample the Gaussian processes $\\mathrm{GP}(0, k)$.\n", + "\n", + "We use the **numpy** backend here.\n", + "\n", + "**Important:** the goal of these kernels is to model the covariance between edges for the flow-type data, e.g., water flows, information flows.\n", + "If you want to model a **signal on the nodes** of a graph $G$, take a look into [Graph.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/Graph.html).\n", + "If you are interested in more general cellular complexes, you might want to look into [Alain et al. (2023)](https://arxiv.org/abs/2311.01198).\n", + "If you want to model a singal on a metric graph, take a look into [Bolin et al. (2023)](https://arxiv.org/abs/2304.10372).\n", + "However, the machinery from the latter two papers is not currently implemented in GeometricKernels." + ] + }, + { + "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 GraphEdges\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 and visualize a simple *5-node, 6-edge graph* using `networkx`" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "nx_graph = nx.Graph()\n", + "nx_graph.add_edges_from([(0, 1), (0, 2), (0, 4), (1, 2), (1, 3), (2, 3), (3, 4)])\n", + "\n", + "# explicitly set node positions for visualization\n", + "pos = {0: (0, 0), 1: (-1, 0.3), 2: (2, 0.17), 3: (4, 0.255), 4: (5, 0.03)}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Visualize the graph." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "graph_vis_options = {\n", + " \"font_size\": 12,\n", + " \"node_size\": 300,\n", + " \"node_color\": \"white\",\n", + " \"edgecolors\": \"black\",\n", + " \"linewidths\": 1,\n", + " \"width\": 2,\n", + " \"with_labels\": True, \n", + "}\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `GraphEdges` space.\n", + "\n", + "For this, we use the `GraphEdges.from_adjacency` static method, which is the easiest way to do this.\n", + "\n", + "**Note:** it requires a random generator `type_reference` which determines the backend to be used for the space's internal computations.\n", + "Here we use `numpy`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "type_reference = np.random.RandomState() # defines the backend, never used for random number generation\n", + "# \"nodelist=...\" below allows us to preserve the node labels we've used to create the graph\n", + "adj_matrix = nx.to_numpy_array(nx_graph, nodelist=range(nx_graph.number_of_nodes()))\n", + "\n", + "graph_edges = GraphEdges.from_adjacency(adj_matrix, type_reference, checks_mode=\"comprehensive\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "By default, `GraphEdges.from_adjacency` assumes that all admissible triples of nodes form triangles.\n", + "A triple of nodes $(i, j, k)$ is admissible if all edges $(i, j), (j, k), (k, i)$ exist.\n", + "\n", + "In the next cell, we fill the triangles in the resulting `graph_edges` space with gray.\n", + "The triangles are used to define the *curl* operator on $G$, and thus determine the Hodge decomposition." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can always use `resolve_edges` and `resolve_triangles` methods to determine the ordering and orientation of edges and triangles." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Edges:\n", + "Edge index 1 corresponds to the edge (0, 1), while edge index -1 corresponds to the edge (1, 0)\n", + "Edge index 2 corresponds to the edge (0, 2), while edge index -2 corresponds to the edge (2, 0)\n", + "Edge index 3 corresponds to the edge (0, 4), while edge index -3 corresponds to the edge (4, 0)\n", + "Edge index 4 corresponds to the edge (1, 2), while edge index -4 corresponds to the edge (2, 1)\n", + "Edge index 5 corresponds to the edge (1, 3), while edge index -5 corresponds to the edge (3, 1)\n", + "Edge index 6 corresponds to the edge (2, 3), while edge index -6 corresponds to the edge (3, 2)\n", + "Edge index 7 corresponds to the edge (3, 4), while edge index -7 corresponds to the edge (4, 3)\n", + "\n", + "Triangles:\n", + "Triangle index 0 corresponds to edge indices (1, 4, -2) and is composed of nodes (0, 1, 2)\n", + "Triangle index 1 corresponds to edge indices (4, 6, -5) and is composed of nodes (1, 2, 3)\n" + ] + } + ], + "source": [ + "print(\"Edges:\")\n", + "for edge_index in range(1, graph_edges.num_edges + 1):\n", + " edge = graph_edges.resolve_edges(np.array([edge_index,])).flatten() # a bit ugly because resolve_edges is supposed to work with batches\n", + " edge_opposite = graph_edges.resolve_edges(np.array([-edge_index,])).flatten()\n", + " print(f\"Edge index {edge_index} corresponds to the edge ({edge[0]}, {edge[1]})\"\n", + " f\", while edge index {-edge_index} corresponds to the edge ({edge_opposite[0]}, {edge_opposite[1]})\")\n", + "\n", + "print()\n", + "print(\"Triangles:\")\n", + "for triangle_index in range(graph_edges.num_triangles):\n", + " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", + " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", + " print(f\"Triangle index {triangle_index} corresponds to\"\n", + " f\" edge indices ({triangle_edges[0]}, {triangle_edges[1]}, {triangle_edges[2]})\"\n", + " f\" and is composed of nodes ({triangle_nodes[0]}, {triangle_nodes[1]}, {triangle_nodes[2]})\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "#### Manually Defining the Set of Triangles" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "You can also manually define the triangles and provide them as an optional argument to the `GraphEdges.from_adjacency` method.\n", + "\n", + "They should be represented by a list of triples of node indices, like below.\n", + "Note, that all triples $(i, j, k)$ must still be adissible, i.e. all edges $(i, j), (j, k), (k, i)$ must exist." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "triangles = [(0,1,2)]\n", + "graph_edges = GraphEdges.from_adjacency(adj_matrix, type_reference, triangles=triangles, checks_mode=\"comprehensive\")" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now, if we visualize the space, it will look differently. (Notice that the triangle composed of nodes (1, 2, 3) is now missing)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Triangles:\n", + "Triangle index 0 corresponds to edge indices (1, 4, -2) and is composed of nodes (0, 1, 2)\n" + ] + } + ], + "source": [ + "print(\"Triangles:\")\n", + "for triangle_index in range(graph_edges.num_triangles):\n", + " triangle_edges = graph_edges.oriented_triangles[triangle_index, :]\n", + " triangle_nodes = graph_edges.resolve_triangles(np.array([triangle_index,])).flatten() # a bit ugly because resolve_triangles is supposed to work with batches\n", + " print(f\"Triangle index {triangle_index} corresponds to\"\n", + " f\" edge indices ({triangle_edges[0]}, {triangle_edges[1]}, {triangle_edges[2]})\"\n", + " f\" and is composed of nodes ({triangle_nodes[0]}, {triangle_nodes[1]}, {triangle_nodes[2]})\")" + ] + }, + { + "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 `sc` 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 graphs can be found on this [documentation page](https://geometric-kernels.github.io/GeometricKernels/theory/graphs.html).\n", + "For graph edges specifically, the *Hodge decomposition* plays a key role, which is briefly discussed on the same documentation page." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Define a Hodge-compositional kernel by setting 'use_hodge_composition' to True; otherwise, the kernel is a Matérn kernel which does not differentiate the different Hodge subspace." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "kernel = MaternGeometricKernel(graph_edges)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "check the eigenbasis and their types being either gradient, curl or harmonic" + ] + }, + { + "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.\n", + "An example of this can be found in [frontends/GPyTorch.ipynb](https://geometric-kernels.github.io/GeometricKernels/examples/frontends/GPyTorch.html), where we use `gpytorch.kernels.ScaleKernel` for this." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "params: {'harmonic': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'gradient': {'logit': array([1.]), 'nu': array([inf]), 'lengthscale': array([1.])}, 'curl': {'logit': array([1.]), '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:** unlike the Euclidean or the manifold case, the $1/2, 3/2, 5/2$ may fail to be the reasonable values of $\\nu$.\n", + "On the other hand, the parameter $\\nu$ is optimizable in the same way in which the legnthscale is.\n", + "Keep in mind though, that the optimization problem may require finding some trial and error to find good a initialization and that reasonable $\\kappa$ and $\\nu$ will heavily depend on the specific graph in a way that is hard to predict.\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note**: for the Hodge-compositional kernel, we need to specify the parameters for each Hodge subspace. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "params[\"harmonic\"][\"lengthscale\"] = np.array([0.5])\n", + "params[\"gradient\"][\"lengthscale\"] = np.array([2.0])\n", + "params[\"curl\"][\"lengthscale\"] = np.array([1.0])\n", + "\n", + "params_hodge_1 = params.copy()\n", + "params_hodge_2 = params.copy()\n", + "del params\n", + "\n", + "params_hodge_1[\"harmonic\"][\"nu\"], params_hodge_1[\"gradient\"][\"nu\"], params_hodge_1[\"curl\"][\"nu\"] = np.array([3/2]), np.array([3/2]), np.array([3/2])\n", + "params_hodge_2[\"harmonic\"][\"nu\"], params_hodge_2[\"gradient\"][\"nu\"], params_hodge_2[\"curl\"][\"nu\"] = np.array([np.inf]), np.array([np.inf]), 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 (i.e., edges)." + ] + }, + { + "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": 14, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs:\n", + "[[4]\n", + " [7]\n", + " [6]]\n", + "\n", + "The edge indices in xs correspond to the following edges:\n", + "[[1 2]\n", + " [3 4]\n", + " [2 3]]\n" + ] + } + ], + "source": [ + "key = np.random.RandomState(1234)\n", + "\n", + "key, xs = graph_edges.random(key, 3)\n", + "\n", + "print(\"xs:\")\n", + "print(xs)\n", + "\n", + "print(\"\")\n", + "\n", + "print(\"The edge indices in xs correspond to the following edges:\")\n", + "print(graph_edges.resolve_edges(xs.squeeze()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "In the following cell, we highlight the sampled edges in green." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sampled_edges_nx = set()\n", + "for u, v in graph_edges.resolve_edges(xs.squeeze()):\n", + " sampled_edges_nx.update([(u, v), (v, u)])\n", + "edge_color = ['green' if x in sampled_edges_nx else 'black' for x in nx_graph.edges]\n", + "\n", + "plt.figure(figsize=(4,4))\n", + "nx.draw(nx_graph, ax=plt.gca(), pos=pos, **graph_vis_options, edge_color=edge_color)\n", + "\n", + "# resolve_triangles method allows to resolve a batch of triangle indices to a batch of triples of nodes.\n", + "triangles = graph_edges.resolve_triangles(np.arange(graph_edges.num_triangles))\n", + "for t in range(graph_edges.num_triangles):\n", + " i, j, k = triangles[t, :]\n", + " plt.fill(\n", + " [pos[i][0], pos[j][0], pos[k][0]],\n", + " [pos[i][1], pos[j][1], pos[k][1]],\n", + " \"gray\",\n", + " alpha=0.25\n", + " ) \n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we evaluate the two kernel matrices." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [], + "source": [ + "kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + "kernel_mat_inf = kernel.K(params_hodge_2, xs, xs)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally, we visualize these matrices using `imshow`." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "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_edge` $, x)$ for $x \\in $ `other_edges`.\n", + "We define `base_edge` and `other_edges` in the next cell." + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "base_edge_idx=1 corresponds to the edge [0 1]\n" + ] + } + ], + "source": [ + "base_edge_idx = 1\n", + "print(f\"base_edge_idx={base_edge_idx} corresponds to the edge {graph_edges.resolve_edges(np.array([base_edge_idx])).flatten()}\")\n", + "other_edges_idx = np.arange(1, graph_edges.num_edges + 1)[:, None]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The next cell evaluates $k_{\\nu, \\kappa}($ `base_edge` $, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "values_32 = kernel.K(params_hodge_1, np.array([[base_edge_idx]]), other_edges_idx).flatten()\n", + "values_inf = kernel.K(params_hodge_2, np.array([[base_edge_idx]]), other_edges_idx).flatten()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We also evaluate the variances $k_{\\nu, \\kappa}(x, x)$ for $x \\in $ `other_edges` for $\\nu$ either $3/2$ or $\\infty$." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "# Get prior variances k(*, *) for * in nodes:\n", + "variance_32 = kernel.K_diag(params_hodge_1, other_edges_idx)\n", + "variance_inf = kernel.K_diag(params_hodge_2, other_edges_idx)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(base_edge, *)` where `*` goes through all nodes and `base_edge` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "edges = [e for e in nx_graph.edges()]\n", + "\n", + "# Set the colorbar limits:\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance 32\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, edge_cmap=cmap, edge_color=np.array(variance_32),\n", + " edge_vmin=variance_32.min(), edge_vmax=values_32.max(), **graph_vis_options)\n", + "# shade the area of the triangle\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_32.min(), vmax=variance_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: $k_{3/2, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values 32\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, edge_cmap=cmap, edge_color=np.array(values_32),\n", + " edge_vmin=values_32.min(), edge_vmax=values_32.max(), **graph_vis_options)\n", + "# add a label at the base edge \n", + "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax2)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_32.min(), vmax=values_32.max()))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: $k_{3/2, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "# Plot variance inf\n", + "nx.draw(nx_graph, pos=pos, ax=ax3, edge_cmap=cmap, edge_color=np.array(variance_inf),\n", + " edge_vmin=variance_inf.min(), edge_vmax=variance_inf.max(), **graph_vis_options)\n", + "ax3.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=variance_inf.min(), vmax=variance_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Variance: $k_{\\infty, \\kappa}(\\cdot, \\cdot)$ for $\\cdot$ in edges')\n", + "\n", + "# Plot kernel values inf\n", + "nx.draw(nx_graph, pos=pos, ax=ax4, edge_cmap=cmap, edge_color=np.array(values_inf),\n", + " edge_vmin=values_inf.min(), edge_vmax=values_inf.max(),\n", + " **graph_vis_options)\n", + "nx.draw_networkx_edge_labels(nx_graph, pos, edge_labels={(edges[base_edge_idx-1][0], edges[base_edge_idx-1][1]): 'base edge'}, verticalalignment='baseline', ax=ax4)\n", + "ax4.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=values_inf.min(), vmax=values_inf.max()))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Kernel: $k_{\\infty, \\kappa}($%d$, \\cdot)$ for $\\cdot$ in edges' % base_edge_idx)\n", + "\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Note:** variance changes from edge to edge, this is normal behavior." + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the edge (0,1) is 1.21,\n", + "Variance in the edge (0,2) is 1.21,\n", + "The average variance is 1.00.\n" + ] + } + ], + "source": [ + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[0][0], edges[0][1], variance_32[0]))\n", + "print('Variance in the edge (%d,%d) is %0.2f,' % (edges[1][0], edges[1][1], variance_32[1]))\n", + "print('The average variance is %0.2f.' % np.mean(variance_32))" + ] + }, + { + "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 graphs, 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": 23, + "metadata": {}, + "outputs": [], + "source": [ + "from geometric_kernels.kernels import default_feature_map\n", + "\n", + "feature_map = default_feature_map(kernel=kernel)" + ] + }, + { + "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 the edge sapce of 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 is either `None` for determinstic feature maps, or contains the updated `key` for randomized feature maps which take `key` as a keyword argument.\n", + "For `default_feature_map` on a `GraphEdge` space, the first element is `None` since the feature map is *deterministic*.\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": 24, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "xs (shape = (3, 1)):\n", + "[[4]\n", + " [7]\n", + " [6]]\n", + "\n", + "emedding (shape = (3, 7)):\n", + "[[-3.71833679e-01 -2.37031980e-01 8.81917104e-01 4.85467264e-16\n", + " -3.06078844e-16 -4.41934324e-01 5.38535320e-17]\n", + " [-3.35213842e-01 5.25852231e-01 0.00000000e+00 5.94921063e-01\n", + " 3.27620242e-01 -3.65194704e-16 -1.98711721e-01]\n", + " [-7.25357439e-01 -9.26218550e-02 0.00000000e+00 2.97460531e-01\n", + " -3.27620242e-01 2.20967162e-01 1.98711721e-01]]\n", + "\n", + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 3.178777788932899e-16\n" + ] + } + ], + "source": [ + "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", + "print('')\n", + "\n", + "# xs are random points from above\n", + "_, embedding = feature_map(xs, params_hodge_1)\n", + "kernel_mat_32 = kernel.K(params_hodge_1, xs, xs)\n", + "kernel_mat_32_alt = np.matmul(embedding, embedding.T)\n", + "print('emedding (shape = %s):\\n%s' % (embedding.shape, embedding))\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": 25, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Two samples evaluated at the xs are:\n", + "[[-1.21678079 0.37588116]\n", + " [ 1.13606525 -0.30789406]\n", + " [-0.04717773 1.58900573]]\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_hodge_1, 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 the edges of a graph." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "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_edges_idx, params_hodge_1, 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", + "\n", + "fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12.8, 4.8))\n", + "\n", + "# Plot sample #1\n", + "nx.draw(nx_graph, pos=pos, ax=ax1, edge_cmap=cmap, edge_color=sample1,\n", + " edge_vmin=vmin, edge_vmax=vmax, **graph_vis_options)\n", + "ax1.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\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 edges, $f \\sim \\mathrm{GP}(0, k_{3/2, \\kappa})$')\n", + "\n", + "\n", + "# Plot sample #2\n", + "nx.draw(nx_graph, pos=pos, ax=ax2, edge_cmap=cmap, edge_color=sample2,\n", + " edge_vmin=vmin, edge_vmax=vmax, **graph_vis_options)\n", + "ax2.fill([0, -1, 2], [0, 0.3, 0.17], \"gray\", alpha=0.15)\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 edges, $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 graphs 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{yang2024,\n", + " title = {Hodge-Compositional Edge Gaussian Processes},\n", + " author = {Yang, Maosheng and Borovitskiy, Viacheslav and Isufi, Elvin},\n", + " booktitle={International Conference on Artificial Intelligence and Statistics},\n", + " year = {2024},\n", + "}\n", + "```" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "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/frontends/GPflow.ipynb b/notebooks/frontends/GPflow.ipynb index 73177699..c0975f39 100644 --- a/notebooks/frontends/GPflow.ipynb +++ b/notebooks/frontends/GPflow.ipynb @@ -27,7 +27,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "metadata": { "tags": [] }, @@ -36,7 +36,8 @@ "name": "stderr", "output_type": "stream", "text": [ - "INFO (geometric_kernels): Numpy backend is enabled, as always. To enable other backends, don't forget `import geometric_kernels.*backend name*`.\n", + "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", "INFO (geometric_kernels): Tensorflow backend enabled.\n" ] } @@ -82,7 +83,7 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "metadata": { "tags": [] }, @@ -135,7 +136,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "metadata": { "tags": [] }, @@ -162,7 +163,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 5, "metadata": { "tags": [] }, @@ -208,7 +209,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 6, "metadata": { "tags": [] }, @@ -232,7 +233,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 7, "metadata": { "tags": [] }, @@ -278,7 +279,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 8, "metadata": { "tags": [] }, @@ -301,7 +302,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 9, "metadata": { "tags": [] }, @@ -321,7 +322,7 @@ "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────────────────┤\n", "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 0.00010000000000000011 │\n", "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧════════════════════════╛\n", - "Initial negative log marginal likelihood: 37.38342468456912\n" + "Initial negative log marginal likelihood: 139298.86264833246\n" ] } ], @@ -346,7 +347,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 10, "metadata": { "tags": [] }, @@ -357,16 +358,16 @@ "text": [ "Starting training...\n", "Final model:\n", - "╒═════════════════════════╤═══════════╤══════════════════╤═════════╤═════════════╤═════════╤═════════╤═══════════════════════╕\n", - "│ name │ class │ transform │ prior │ trainable │ shape │ dtype │ value │\n", - "╞═════════════════════════╪═══════════╪══════════════════╪═════════╪═════════════╪═════════╪═════════╪═══════════════════════╡\n", - "│ GPR.kernel.lengthscales │ Parameter │ Softplus │ │ True │ (1,) │ float64 │ [5.72748] │\n", - "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼───────────────────────┤\n", - "│ GPR.kernel.variance │ Parameter │ Softplus │ │ True │ () │ float64 │ 0.922966133049915 │\n", - "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼───────────────────────┤\n", - "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 0.0009066831659221346 │\n", - "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧═══════════════════════╛\n", - "Final negative log marginal likelihood: 36.34231795388164\n" + "╒═════════════════════════╤═══════════╤══════════════════╤═════════╤═════════════╤═════════╤═════════╤════════════╕\n", + "│ name │ class │ transform │ prior │ trainable │ shape │ dtype │ value │\n", + "╞═════════════════════════╪═══════════╪══════════════════╪═════════╪═════════════╪═════════╪═════════╪════════════╡\n", + "│ GPR.kernel.lengthscales │ Parameter │ Softplus │ │ True │ (1,) │ float64 │ [5.16664] │\n", + "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────┤\n", + "│ GPR.kernel.variance │ Parameter │ Softplus │ │ True │ () │ float64 │ 5895.29149 │\n", + "├─────────────────────────┼───────────┼──────────────────┼─────────┼─────────────┼─────────┼─────────┼────────────┤\n", + "│ GPR.likelihood.variance │ Parameter │ Softplus + Shift │ │ True │ () │ float64 │ 1e-06 │\n", + "╘═════════════════════════╧═══════════╧══════════════════╧═════════╧═════════════╧═════════╧═════════╧════════════╛\n", + "Final negative log marginal likelihood: 256.78736390084214\n" ] } ], @@ -391,7 +392,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 11, "metadata": { "tags": [] }, @@ -408,14 +409,14 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "tags": [] }, "outputs": [ { "data": { - "image/png": "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" + "image/png": "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" }, "metadata": {}, "output_type": "display_data" @@ -560,11 +561,6 @@ "}\n", "```" ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [] } ], "metadata": { diff --git a/tests/data.py b/tests/data.py index b267e894..6205ecae 100644 --- a/tests/data.py +++ b/tests/data.py @@ -45,3 +45,66 @@ ).astype( np.float64 ) # corresponds to TEST_GRAPH_ADJACENCY, normalized Laplacian + +TEST_GRAPH_EDGES_NUM_NODES = 5 + +TEST_GRAPH_EDGES_ADJACENCY = np.array( + [ + [0, 1, 1, 0, 1], + [1, 0, 1, 1, 0], + [1, 1, 0, 1, 0], + [0, 1, 1, 0, 1], + [1, 0, 0, 1, 0], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_UP_LAPLACIAN = np.array( + [ + [1, -1, 0, 1, 0, 0, 0], + [-1, 1, 0, -1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [1, -1, 0, 1, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + [0, 0, 0, 0, 0, 0, 0], + ] +).astype(np.float64) + +TEST_GRAPH_EDGES_DOWN_LAPLACIAN = np.array( + [ + [2, 1, 1, -1, -1, 0, 0], + [1, 2, 1, 1, 0, -1, 0], + [1, 1, 2, 0, 0, 0, 1], + [-1, 1, 0, 2, 1, -1, 0], + [-1, 0, 0, 1, 2, 1, -1], + [0, -1, 0, -1, 1, 2, -1], + [0, 0, 1, 0, -1, -1, 2], + ] +).astype(np.float64) + +TEST_GRAPH_EDGES_ORIENTED_EDGES = np.array( + [ + [0, 1], + [0, 2], + [0, 4], + [1, 2], + [1, 3], + [2, 3], + [3, 4], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_TRIANGLES = [(0, 1, 2)] + +TEST_GRAPH_EDGES_ORIENTED_TRIANGLES = np.array( + [ + [1, 4, -2], + ] +).astype(np.int32) + +TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO = np.array( + [ + [1, 4, -2], + [4, 6, -5], + ] +).astype(np.int32) diff --git a/tests/helper.py b/tests/helper.py index 9c3613ad..f0f67af5 100644 --- a/tests/helper.py +++ b/tests/helper.py @@ -10,6 +10,8 @@ CompactMatrixLieGroup, DiscreteSpectrumSpace, Graph, + GraphEdges, + HodgeDiscreteSpectrumSpace, Hyperbolic, HypercubeGraph, Hypersphere, @@ -22,7 +24,13 @@ SymmetricPositiveDefiniteMatrices, ) -from .data import TEST_GRAPH_ADJACENCY, TEST_MESH_PATH +from .data import ( + TEST_GRAPH_ADJACENCY, + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + TEST_MESH_PATH, +) EagerTensor = ModuleType("tensorflow.python.framework.ops", "EagerTensor") @@ -46,6 +54,16 @@ def product_discrete_spectrum_spaces() -> List[ProductDiscreteSpectrumSpace]: ] +def hodge_discrete_spectrum_spaces() -> List[HodgeDiscreteSpectrumSpace]: + return [ + GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ), + ] + + def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: return ( [ @@ -62,6 +80,7 @@ def discrete_spectrum_spaces() -> List[DiscreteSpectrumSpace]: ] + compact_matrix_lie_groups() + product_discrete_spectrum_spaces() + + hodge_discrete_spectrum_spaces() ) diff --git a/tests/spaces/test_basics.py b/tests/spaces/test_basics.py index a0e300ee..74477feb 100644 --- a/tests/spaces/test_basics.py +++ b/tests/spaces/test_basics.py @@ -7,6 +7,7 @@ from ..helper import ( compact_matrix_lie_groups, discrete_spectrum_spaces, + hodge_discrete_spectrum_spaces, noncompact_symmetric_spaces, product_discrete_spectrum_spaces, spaces, @@ -16,6 +17,10 @@ @pytest.mark.parametrize( "fun, cls", [ + ( + hodge_discrete_spectrum_spaces, + geometric_kernels.spaces.HodgeDiscreteSpectrumSpace, + ), (compact_matrix_lie_groups, geometric_kernels.spaces.CompactMatrixLieGroup), ( product_discrete_spectrum_spaces, diff --git a/tests/spaces/test_graph.py b/tests/spaces/test_graph.py index a31fa42a..887a2ca2 100644 --- a/tests/spaces/test_graph.py +++ b/tests/spaces/test_graph.py @@ -68,6 +68,7 @@ def eigendiff(adj): eigvals_x_eigvecs = eigenvectors @ eigenvalue_mat return laplace_x_eigvecs - eigvals_x_eigvecs + # Check that the computed eigenpairs are actually eigenpairs check_function_with_backend( backend, np.zeros((TEST_GRAPH_ADJACENCY.shape[0], L)), @@ -112,6 +113,7 @@ def evaluate_kernel(adj, nu, lengthscale): K = evecs_np @ np.diag(np.exp(-(lengthscale**2) / 2 * evals_np)) @ evecs_np.T K = K / np.mean(K.diagonal()) + # Check that the kernel matrix is correctly computed check_function_with_backend( backend, K, diff --git a/tests/spaces/test_graph_edges.py b/tests/spaces/test_graph_edges.py new file mode 100644 index 00000000..89eb6104 --- /dev/null +++ b/tests/spaces/test_graph_edges.py @@ -0,0 +1,334 @@ +import lab as B +import numpy as np +import pytest + +from geometric_kernels.jax import * # noqa +from geometric_kernels.kernels import ( + MaternGeometricKernel, + MaternHodgeCompositionalKernel, + MaternKarhunenLoeveKernel, +) +from geometric_kernels.spaces import GraphEdges +from geometric_kernels.tensorflow import * # noqa +from geometric_kernels.torch import * # noqa + +from ..data import ( + TEST_GRAPH_EDGES_ADJACENCY, + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO, + TEST_GRAPH_EDGES_TRIANGLES, + TEST_GRAPH_EDGES_UP_LAPLACIAN, +) +from ..helper import check_function_with_backend, create_random_state, np_to_backend + + +@pytest.mark.parametrize( + "triangles, oriented_triangles", + [ + (None, TEST_GRAPH_EDGES_ORIENTED_TRIANGLES_AUTO), + (TEST_GRAPH_EDGES_TRIANGLES, TEST_GRAPH_EDGES_ORIENTED_TRIANGLES), + ], +) +@pytest.mark.parametrize( + "backend", ["numpy", "tensorflow", "torch", "jax", "scipy_sparse"] +) +def test_from_adjacency(backend, triangles, oriented_triangles): + + type_reference = create_random_state(backend) + + # check that oriented_edges array is correctly computed from adjacency + B.all( + TEST_GRAPH_EDGES_ORIENTED_EDGES + == GraphEdges.from_adjacency( + TEST_GRAPH_EDGES_ADJACENCY, type_reference, triangles=triangles + ).oriented_edges + ) + + # check that oriented_triangles array is correctly computed from adjacency + B.all( + oriented_triangles + == GraphEdges.from_adjacency( + TEST_GRAPH_EDGES_ADJACENCY, type_reference, triangles=triangles + ).oriented_triangles + ) + + +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_laplacian(backend): + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_UP_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._up_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._down_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + check_function_with_backend( + backend, + TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + lambda or_e, or_t: GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t + )._hodge_laplacian, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + +@pytest.mark.parametrize( + "L", + [ + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] // 2, + ], +) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_eigendecomposition(L, backend): + hodge_laplacian = np_to_backend( + TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN, + backend, + ) + + def eigendiff(or_e, or_t): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + + eigenvalue_mat = B.diag_construct(graph_edges.get_eigenvalues(L)[:, 0]) + eigenvectors = graph_edges.get_eigenvectors(L) + + laplace_x_eigvecs = hodge_laplacian @ eigenvectors + eigvals_x_eigvecs = eigenvectors @ eigenvalue_mat + return laplace_x_eigvecs - eigvals_x_eigvecs + + check_function_with_backend( + backend, + np.zeros((TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], L)), + eigendiff, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ) + + +@pytest.mark.parametrize( + "hodge_type, projection_matrix, projection_matrix_id", + [ + ("harmonic", TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ("harmonic", TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ("gradient", TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ("curl", TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ], + ids=lambda x: x if isinstance(x, str) else "", +) +@pytest.mark.parametrize( + "L", + [ + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], + TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] // 2, + ], +) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_hodge_decomposition( + hodge_type, projection_matrix, projection_matrix_id, L, backend +): + # projection_matrix_id we only use for the ids of the test + + n = GraphEdges( + TEST_GRAPH_EDGES_NUM_NODES, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + ).get_number_of_eigenpairs(L, hodge_type=hodge_type) + + def proj(or_e, or_t, proj_mat): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + proj_mat = np_to_backend(proj_mat, backend) + + eigenvectors = graph_edges.get_eigenvectors(L, hodge_type=hodge_type) + + result = proj_mat @ eigenvectors + return result + + # Check that the eigenvectors of type `hodge_type` lie in the null space + # of the projection matrix (are harmonic / divergence-free / curl-free). + check_function_with_backend( + backend, + np.zeros((TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0], n)), + proj, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + projection_matrix, + ) + + +@pytest.mark.parametrize("nu, lengthscale", [(1.0, 1.0), (2.0, 1.0), (np.inf, 1.0)]) +@pytest.mark.parametrize("sparse_adj", [True, False]) +@pytest.mark.parametrize("hodge_compositional", [True, False]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_matern_kernels(nu, lengthscale, hodge_compositional, sparse_adj, backend): + + hodge_laplacian = TEST_GRAPH_EDGES_UP_LAPLACIAN + TEST_GRAPH_EDGES_DOWN_LAPLACIAN + num_edges = hodge_laplacian.shape[0] + + evals_np, evecs_np = np.linalg.eigh(hodge_laplacian) + evecs_np *= np.sqrt(hodge_laplacian.shape[0]) + + type_reference = create_random_state(backend) + + def evaluate_kernel(nu, lengthscale, xs): + adj = TEST_GRAPH_EDGES_ADJACENCY + if sparse_adj: + adj = np_to_backend(B.to_numpy(TEST_GRAPH_EDGES_ADJACENCY), "scipy_sparse") + graph_edges = GraphEdges.from_adjacency( + adj, type_reference, triangles=TEST_GRAPH_EDGES_TRIANGLES + ) + + if hodge_compositional: + kernel = MaternHodgeCompositionalKernel(graph_edges, num_levels=num_edges) + + # We want MaternHodgeCompositionalKernel to coincide with + # MaternKarhunenLoeveKernel in this case. For this, we need to + # set the right coefficients for the three hodge types. + + a = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(num_edges, hodge_type="harmonic"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + b = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(num_edges, hodge_type="gradient"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + c = B.reshape( + B.sum( + MaternKarhunenLoeveKernel.spectrum( + graph_edges.get_eigenvalues(num_edges, hodge_type="curl"), + nu, + lengthscale, + 0, + ) + ), + 1, + ) + + params = { + "harmonic": {"logit": a, "nu": nu, "lengthscale": lengthscale}, + "gradient": {"logit": b, "nu": nu, "lengthscale": lengthscale}, + "curl": {"logit": c, "nu": nu, "lengthscale": lengthscale}, + } + else: + kernel = MaternKarhunenLoeveKernel(graph_edges, num_levels=num_edges) + params = {"nu": nu, "lengthscale": lengthscale} + + return kernel.K(params, xs) + + if nu < np.inf: + K = ( + evecs_np + @ np.diag(np.power(evals_np + 2 * nu / lengthscale**2, -nu)) + @ evecs_np.T + ) + else: + K = evecs_np @ np.diag(np.exp(-(lengthscale**2) / 2 * evals_np)) @ evecs_np.T + K = K / np.mean(K.diagonal()) + + # Check that the kernel matrix is correctly computed. For the Hodge + # compositional kernel, we only check the case when the hyperparameters + # make it coincide with the Karhunen-Loève kernel. + check_function_with_backend( + backend, + K, + evaluate_kernel, + np.array([nu]), + np.array([lengthscale]), + np.arange(1, num_edges + 1)[:, None], + ) + + +@pytest.mark.parametrize( + "coeffs, projection_matrix, projection_matrix_id", + [ + ([1.0, 0.0, 0.0], TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ([1.0, 0.0, 0.0], TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ([0.0, 1.0, 0.0], TEST_GRAPH_EDGES_DOWN_LAPLACIAN, "down"), + ([0.0, 0.0, 1.0], TEST_GRAPH_EDGES_UP_LAPLACIAN, "up"), + ], + ids=lambda x: x if isinstance(x, str) else "", +) +@pytest.mark.parametrize("nu, lengthscale", [(1.0, 1.0), (2.0, 1.0), (np.inf, 1.0)]) +@pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"]) +def test_kernels_hodge_type( + coeffs, projection_matrix, projection_matrix_id, nu, lengthscale, backend +): + # projection_matrix_id we only use for the ids of the test + + def proj_kernel( + or_e, + or_t, + coeff_harmonic, + coeff_gradient, + coeff_curl, + nu, + lengthscale, + xs, + projection_matrix, + ): + graph_edges = GraphEdges(TEST_GRAPH_EDGES_NUM_NODES, or_e, or_t) + + kernel = MaternGeometricKernel(graph_edges) + + params = { + "harmonic": {"logit": coeff_harmonic, "nu": nu, "lengthscale": lengthscale}, + "gradient": {"logit": coeff_gradient, "nu": nu, "lengthscale": lengthscale}, + "curl": {"logit": coeff_curl, "nu": nu, "lengthscale": lengthscale}, + } + + return projection_matrix @ kernel.K(params, xs) + + num_edges = TEST_GRAPH_EDGES_ORIENTED_EDGES.shape[0] + + # Check that the image of the Hodge compositional kernel lies in the null + # space of the projection matrix. Makes sure that buy setting the + # coefficients of the other two types to zero, the kernel is harmonic / + # divergence-free / curl-free. + check_function_with_backend( + backend, + np.zeros((num_edges, num_edges)), + proj_kernel, + TEST_GRAPH_EDGES_ORIENTED_EDGES, + TEST_GRAPH_EDGES_ORIENTED_TRIANGLES, + np.array([coeffs[0]]), + np.array([coeffs[1]]), + np.array([coeffs[2]]), + np.array([nu]), + np.array([lengthscale]), + np.arange(1, num_edges + 1)[:, None], + projection_matrix, + ) diff --git a/tests/utils/test_special_functions.py b/tests/utils/test_special_functions.py index 72f8f398..21ce5414 100644 --- a/tests/utils/test_special_functions.py +++ b/tests/utils/test_special_functions.py @@ -46,7 +46,10 @@ def test_walsh_functions(all_xs_and_combs, backend): # Check that Walsh functions only take values in the set {-1, 1}. check_function_with_backend( - backend, np.ones((2**d, 2**d)), lambda X: B.abs(walsh_matrix(d, combs, X)), X + backend, + np.ones((2**d, 2**d)), + lambda X: B.abs(walsh_matrix(d, combs, X)), + X, )