diff --git a/.github/workflows/code-style.yaml b/.github/workflows/code-style.yaml index 2ef049e4..24b89304 100644 --- a/.github/workflows/code-style.yaml +++ b/.github/workflows/code-style.yaml @@ -22,7 +22,7 @@ jobs: - name: Install uv uses: astral-sh/setup-uv@v6 with: - version: "0.9.6" + version: "0.11.23" #---------------------------------------------- # install #---------------------------------------------- diff --git a/.github/workflows/docs.yaml b/.github/workflows/docs.yaml index 1007d5bb..cfb0b464 100644 --- a/.github/workflows/docs.yaml +++ b/.github/workflows/docs.yaml @@ -16,7 +16,7 @@ jobs: - uses: actions/checkout@v4 - uses: astral-sh/setup-uv@v6 with: - version: "0.9.6" + version: "0.11.23" #---------------------------------------------- # install #---------------------------------------------- diff --git a/.github/workflows/quality-checks.yaml b/.github/workflows/quality-checks.yaml index 7c787550..ac0b161c 100644 --- a/.github/workflows/quality-checks.yaml +++ b/.github/workflows/quality-checks.yaml @@ -16,7 +16,7 @@ jobs: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] - python-version: ["3.10", "3.11", "3.12"] + python-version: ["3.11", "3.12", "3.13"] fail-fast: false runs-on: ${{ matrix.os }} @@ -30,7 +30,7 @@ jobs: - name: Install uv uses: astral-sh/setup-uv@v6 with: - version: "0.9.6" + version: "0.11.23" - name: Install make if: runner.os == 'Windows' run: choco install make -y diff --git a/Makefile b/Makefile index 6c3c2f5e..e3cd37b8 100644 --- a/Makefile +++ b/Makefile @@ -43,6 +43,5 @@ lint: sync test: sync ## Run the tests, start with the failing ones and break on first fail. @$(UV_RUN) pytest -v -x --ff -rN -Wignore -s --tb=short --durations=0 --cov --cov-report=xml --cov-report=html:coverage_html tests - # gpflow is ignored due to incompatibility with the recent setuptools - @$(UV_RUN) pytest --nbmake --nbmake-kernel=python3 --durations=0 --nbmake-timeout=1000 --ignore=notebooks/frontends/GPflow.ipynb notebooks/ + @$(UV_RUN) pytest --nbmake --nbmake-kernel=python3 --durations=0 --nbmake-timeout=1000 notebooks/ @echo -e "$(SUCCESS)Tests done$(RESET)" diff --git a/docs/index.rst b/docs/index.rst index 139543ab..61d73ae1 100644 --- a/docs/index.rst +++ b/docs/index.rst @@ -203,7 +203,7 @@ To install JAX, follow `these instructions =0.14.0" .. raw:: html diff --git a/geometric_kernels/feature_maps/__init__.py b/geometric_kernels/feature_maps/__init__.py index 9a42a1f9..43d80b5b 100644 --- a/geometric_kernels/feature_maps/__init__.py +++ b/geometric_kernels/feature_maps/__init__.py @@ -15,6 +15,9 @@ RandomPhaseFeatureMapCompact, RandomPhaseFeatureMapNoncompact, ) +from geometric_kernels.feature_maps.random_phase_log_domain import ( + RandomPhaseFeatureMapLogDomain, +) from geometric_kernels.feature_maps.rejection_sampling import ( RejectionSamplingFeatureMapHyperbolic, RejectionSamplingFeatureMapSPD, diff --git a/geometric_kernels/feature_maps/random_phase_log_domain.py b/geometric_kernels/feature_maps/random_phase_log_domain.py new file mode 100644 index 00000000..171863c6 --- /dev/null +++ b/geometric_kernels/feature_maps/random_phase_log_domain.py @@ -0,0 +1,83 @@ +"""Log-domain random-phase features for discrete-spectrum spaces.""" + +import lab as B +from beartype.typing import Dict, Tuple + +from geometric_kernels.feature_maps.random_phase import RandomPhaseFeatureMapCompact +from geometric_kernels.lab_extras import from_numpy, is_complex +from geometric_kernels.spaces import DiscreteSpectrumSpace + + +class RandomPhaseFeatureMapLogDomain(RandomPhaseFeatureMapCompact): + """Random-phase features with log-domain spectral weighting. + + Sampling, feature ordering, and row normalization follow + :class:`RandomPhaseFeatureMapCompact`. When the eigenfunctions support log + products, the map avoids premature spectral underflow and large + multiplicities. Otherwise it uses the standard compact feature map. + + :param space: + A discrete-spectrum space with random sampling and addition-theorem + eigenfunctions. + :param num_levels: + Number of spectral levels to include. + :param num_random_phases: + Number of sampled phases. The map returns this many features per level. + """ + + def __init__( + self, + space: DiscreteSpectrumSpace, + num_levels: int, + num_random_phases: int = 3000, + ): + super().__init__(space, num_levels, num_random_phases) + + def __call__( + self, + X: B.Numeric, + params: Dict[str, B.Numeric], + *, + key: B.RandomState, + normalize: bool = True, + **kwargs, + ) -> Tuple[B.RandomState, B.Numeric]: + """Return the updated random key and log-domain random-phase features. + + Arguments and return shapes follow ``RandomPhaseFeatureMapCompact``. + Normalization produces unit-norm feature rows; unnormalized features + can still exceed the floating-point range. + """ + if not self.eigenfunctions.supports_log_domain: + return super().__call__(X, params, key=key, normalize=normalize, **kwargs) + + from geometric_kernels.kernels.karhunen_loeve_log_domain import ( + MaternKarhunenLoeveLogDomain, + ) + + key, phases = self.space.random(key, self.num_random_phases) + log_spectrum = MaternKarhunenLoeveLogDomain.log_spectrum( + self.space.get_eigenvalues(self.num_levels), + params["nu"], + params["lengthscale"], + self.space.dimension, + ) + phases = B.cast(B.dtype(X), from_numpy(X, phases)) + return key, self._features_from_log_spectrum(log_spectrum, X, phases, normalize) + + def _features_from_log_spectrum(self, log_spectrum, X, phases, normalize): + log_phi_magnitude, signs = self.eigenfunctions.phi_product_log( + X, phases, dtype=B.dtype(log_spectrum) + ) + log_magnitude = log_phi_magnitude + B.transpose(0.5 * log_spectrum) + log_magnitude = B.reshape(log_magnitude, X.shape[0], -1) + signs = B.reshape(signs, X.shape[0], -1) + if normalize: + log_magnitude = log_magnitude - B.max(log_magnitude, axis=1, squeeze=False) + log_magnitude = log_magnitude - 0.5 * B.logsumexp( + 2 * log_magnitude, axis=1, squeeze=False + ) + features = signs * B.exp(log_magnitude) + if is_complex(features): + features = B.concat(B.real(features), B.imag(features), axis=1) + return features diff --git a/geometric_kernels/frontends/gpjax.py b/geometric_kernels/frontends/gpjax.py index 287534d5..c6ccb00c 100644 --- a/geometric_kernels/frontends/gpjax.py +++ b/geometric_kernels/frontends/gpjax.py @@ -6,14 +6,12 @@ :doc:`frontends/GPJax.ipynb ` notebook. """ -from dataclasses import dataclass - +import equinox as eqx import gpjax import jax.numpy as jnp +import lineax as lx +import paramax from beartype.typing import List, TypeVar, Union -from flax import nnx -from gpjax.kernels.computations.base import AbstractKernelComputation -from gpjax.linalg import Diagonal, psd from gpjax.parameters import NonNegativeReal, PositiveReal from gpjax.typing import Array, ScalarFloat from jaxtyping import Float, Num @@ -49,7 +47,8 @@ def cross_covariance( :return: The N x M covariance matrix. """ - nu_value = kernel.nu.value if kernel.trainable_nu else kernel.nu + kernel = paramax.unwrap(kernel) + nu_value = kernel.nu # Ensure inputs have `ndim` > 1. GPJax may squeeze shape `(1, 1)` into # `(1,)` which causes issues when passing to the base kernel. @@ -58,13 +57,13 @@ def cross_covariance( if y.ndim == 1: y = y[:, jnp.newaxis] - return kernel.variance.value * kernel.base_kernel.K( - {"lengthscale": kernel.lengthscale.value, "nu": nu_value}, x, y + return kernel.variance * kernel.base_kernel.K( + {"lengthscale": kernel.lengthscale, "nu": nu_value}, x, y ) def diagonal( self, kernel: Kernel, x: Num[Array, "N #D1 D2"] # noqa: F821 - ) -> Diagonal: + ) -> lx.AbstractLinearOperator: """ Compute the diagonal of the covariance matrix `K(x, x)` where `x` is a batch of vectors (or a batch of matrices) of inputs. @@ -79,24 +78,25 @@ def diagonal( Returns: The computed diagonal variance as a `Diagonal` linear operator. """ - nu_value = kernel.nu.value if kernel.trainable_nu else kernel.nu + kernel = paramax.unwrap(kernel) + nu_value = kernel.nu # Ensure inputs have `ndim` > 1. GPJax may squeeze shape `(1, 1)` into # `(1,)` which causes issues when passing to the base kernel. if x.ndim == 1: x = x[:, jnp.newaxis] - return psd( - Diagonal( - kernel.variance.value + return lx.TaggedLinearOperator( + lx.DiagonalLinearOperator( + kernel.variance * kernel.base_kernel.K_diag( - {"lengthscale": kernel.lengthscale.value, "nu": nu_value}, x + {"lengthscale": kernel.lengthscale, "nu": nu_value}, x ) - ) + ), + lx.positive_semidefinite_tag, ) -@dataclass class GPJaxGeometricKernel(gpjax.kernels.AbstractKernel): r""" GPJax wrapper for :class:`~.kernels.BaseGeometricKernel`. @@ -108,9 +108,8 @@ class GPJaxGeometricKernel(gpjax.kernels.AbstractKernel): .. note:: Remember that the `base_kernel` itself does not store any of its hyperparameters (like `lengthscale` and `nu`). If you do not set them - manually—when initializing the object or after, by setting the - properties—this wrapper will use the values provided by - `base_kernel.init_params`. + manually when initializing the object, this wrapper will use the values + provided by `base_kernel.init_params`. :param base_kernel: The kernel to wrap. @@ -135,29 +134,31 @@ class GPJaxGeometricKernel(gpjax.kernels.AbstractKernel): Defaults to False. """ - nu: Union[ScalarFloat, nnx.Variable[ScalarFloat], None] - lengthscale: nnx.Variable[Union[ScalarFloat, Float[Array, " D"]]] - variance: nnx.Variable[ScalarFloat] + nu: paramax.AbstractUnwrappable + lengthscale: paramax.AbstractUnwrappable + variance: paramax.AbstractUnwrappable - base_kernel: BaseGeometricKernel - compute_engine: AbstractKernelComputation = _GeometricKernelComputation() - name: str = "Geometric Kernel" + base_kernel: BaseGeometricKernel = eqx.field(static=True) + trainable_nu: bool = eqx.field(static=True) + name: str = eqx.field(static=True, default="Geometric Kernel") def __init__( self, base_kernel: BaseGeometricKernel, lengthscale: Union[ Union[ScalarFloat, Float[Array, " D"]], - nnx.Variable[Union[ScalarFloat, Float[Array, " D"]]], + paramax.AbstractUnwrappable, None, ] = None, - nu: Union[ScalarFloat, nnx.Variable[ScalarFloat], None] = None, - variance: Union[ScalarFloat, nnx.Variable[ScalarFloat]] = 1.0, + nu: Union[ScalarFloat, paramax.AbstractUnwrappable, None] = None, + variance: Union[ScalarFloat, paramax.AbstractUnwrappable] = 1.0, trainable_nu: bool = False, ): - active_dims = None - n_dims = None - super().__init__(active_dims, n_dims, self.compute_engine) + # Initialise inherited fields directly: Equinox freezes the module when + # a parent constructor returns. + self.active_dims = slice(None) + self.n_dims = None + self.compute_engine = _GeometricKernelComputation() self.base_kernel = base_kernel default_params = self.base_kernel.init_params() @@ -167,20 +168,20 @@ def __init__( if nu is None: nu = jnp.array(default_params["nu"]) - if isinstance(lengthscale, nnx.Variable): + if isinstance(lengthscale, paramax.AbstractUnwrappable): self.lengthscale = lengthscale else: self.lengthscale = PositiveReal(lengthscale) self.trainable_nu = trainable_nu if not trainable_nu: - self.nu = nu - elif isinstance(nu, nnx.Variable): + self.nu = paramax.non_trainable(jnp.asarray(paramax.unwrap(nu))) + elif isinstance(nu, paramax.AbstractUnwrappable): self.nu = nu else: self.nu = PositiveReal(nu) - if isinstance(variance, nnx.Variable): + if isinstance(variance, paramax.AbstractUnwrappable): self.variance = variance else: self.variance = NonNegativeReal(variance) diff --git a/geometric_kernels/kernels/__init__.py b/geometric_kernels/kernels/__init__.py index 890a4dec..5cf12bd1 100644 --- a/geometric_kernels/kernels/__init__.py +++ b/geometric_kernels/kernels/__init__.py @@ -11,6 +11,9 @@ 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.karhunen_loeve_log_domain import ( + MaternKarhunenLoeveLogDomain, +) from geometric_kernels.kernels.matern_kernel import ( MaternGeometricKernel, default_feature_map, diff --git a/geometric_kernels/kernels/karhunen_loeve_log_domain.py b/geometric_kernels/kernels/karhunen_loeve_log_domain.py new file mode 100644 index 00000000..e5a1a865 --- /dev/null +++ b/geometric_kernels/kernels/karhunen_loeve_log_domain.py @@ -0,0 +1,81 @@ +"""Matérn Karhunen-Loève kernels with log-domain spectral normalization.""" + +import lab as B +import numpy as np +from beartype.typing import Dict + +from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.lab_extras import from_numpy, is_complex +from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params + + +class MaternKarhunenLoeveLogDomain(MaternKarhunenLoeveKernel): + """A discrete-spectrum Matérn kernel whose weights are computed in log space. + + Eigenfunctions provide independent log multiplicities, allowing the + normalizer to be evaluated even when linear multiplicities overflow. + Eigenfunctions with ``supports_log_domain`` can also evaluate kernel + matrices without forming linear per-eigenfunction weights. + """ + + @staticmethod + def log_spectrum(s, nu, lengthscale, dimension): + """Evaluate the log Matérn spectrum without forming linear weights.""" + _check_1_vector(lengthscale, "lengthscale") + _check_1_vector(nu, "nu") + s = B.cast(B.dtype(lengthscale), s) + safe_nu = B.where(nu == np.inf, B.ones(lengthscale), nu) + safe_lengthscale = B.where(nu == np.inf, B.ones(lengthscale), lengthscale) + finite = -(safe_nu + dimension / 2.0) * B.log( + 2.0 * safe_nu / safe_lengthscale**2 + s + ) + infinite = -(lengthscale**2) * s / 2.0 + return B.where(nu == np.inf, infinite, finite) + + @staticmethod + def spectrum(s, nu, lengthscale, dimension): + return B.exp( + MaternKarhunenLoeveLogDomain.log_spectrum(s, nu, lengthscale, dimension) + ) + + def _log_weights(self, params): + _check_field_in_params(params, "lengthscale") + _check_field_in_params(params, "nu") + log_spectrum = self.log_spectrum( + self.eigenvalues_laplacian, + params["nu"], + params["lengthscale"], + self.space.dimension, + ) + log_multiplicities = B.cast( + B.dtype(log_spectrum), + from_numpy( + log_spectrum, self.eigenfunctions.log_num_eigenfunctions_per_level + ), + )[:, None] + log_levels = log_spectrum + log_multiplicities + return log_spectrum, log_levels, B.logsumexp(log_levels) + + def log_eigenvalues(self, params: Dict[str, B.Numeric]) -> B.Numeric: + """Return per-eigenfunction log weights, shape [L, 1].""" + log_spectrum, _, log_normalizer = self._log_weights(params) + return log_spectrum - log_normalizer if self.normalize else log_spectrum + + def eigenvalues(self, params: Dict[str, B.Numeric]) -> B.Numeric: + return B.exp(self.log_eigenvalues(params)) + + def K(self, params, X, X2=None, **kwargs): + if not self.eigenfunctions.supports_log_domain: + return super().K(params, X, X2, **kwargs) + result = self.eigenfunctions.weighted_outerproduct_log( + self.log_eigenvalues(params), X, X2, **kwargs + ) + return B.real(result) if is_complex(result) else result + + def K_diag(self, params, X, **kwargs): + if not self.eigenfunctions.supports_log_domain: + return super().K_diag(params, X, **kwargs) + result = self.eigenfunctions.weighted_outerproduct_diag_log( + self.log_eigenvalues(params), X, **kwargs + ) + return B.real(result) if is_complex(result) else result diff --git a/geometric_kernels/kernels/matern_kernel.py b/geometric_kernels/kernels/matern_kernel.py index 0fe8795a..967122f4 100644 --- a/geometric_kernels/kernels/matern_kernel.py +++ b/geometric_kernels/kernels/matern_kernel.py @@ -13,6 +13,7 @@ DeterministicFeatureMapCompact, HodgeDeterministicFeatureMapCompact, RandomPhaseFeatureMapCompact, + RandomPhaseFeatureMapLogDomain, RandomPhaseFeatureMapNoncompact, RejectionSamplingFeatureMapHyperbolic, RejectionSamplingFeatureMapSPD, @@ -21,8 +22,8 @@ from geometric_kernels.kernels.feature_map import MaternFeatureMapKernel from geometric_kernels.kernels.hodge_compositional import MaternHodgeCompositionalKernel from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel -from geometric_kernels.kernels.matern_kernel_hamming_graph import ( - MaternKernelHammingGraph, +from geometric_kernels.kernels.karhunen_loeve_log_domain import ( + MaternKarhunenLoeveLogDomain, ) from geometric_kernels.spaces import ( CompactMatrixLieGroup, @@ -80,7 +81,13 @@ def default_feature_map( @overload def feature_map_from_kernel(kernel: MaternKarhunenLoeveKernel): - if isinstance(kernel.space, (CompactMatrixLieGroup, HammingGraph)): + if isinstance(kernel, MaternKarhunenLoeveLogDomain): + return RandomPhaseFeatureMapLogDomain( + kernel.space, + kernel.num_levels, + MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES, + ) + elif isinstance(kernel.space, CompactMatrixLieGroup): # Because `CompactMatrixLieGroup` does not currently support explicit # eigenfunction computation (they only support addition theorem). return RandomPhaseFeatureMapCompact( @@ -140,7 +147,11 @@ def feature_map_from_kernel(kernel: BaseGeometricKernel): @overload def feature_map_from_space(space: DiscreteSpectrumSpace, num: int): - if isinstance(space, (CompactMatrixLieGroup, HammingGraph)): + if isinstance(space, (HypercubeGraph, HammingGraph)): + return RandomPhaseFeatureMapLogDomain( + space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES + ) + elif isinstance(space, CompactMatrixLieGroup): return RandomPhaseFeatureMapCompact( space, num, MaternGeometricKernel._DEFAULT_NUM_RANDOM_PHASES ) @@ -346,7 +357,7 @@ def __new__( if isinstance(space, HodgeDiscreteSpectrumSpace): kernel = MaternHodgeCompositionalKernel(space, num, normalize=normalize) elif isinstance(space, (HypercubeGraph, HammingGraph)): - kernel = MaternKernelHammingGraph(space, num, normalize=normalize) + kernel = MaternKarhunenLoeveLogDomain(space, num, normalize=normalize) else: kernel = MaternKarhunenLoeveKernel(space, num, normalize=normalize) if return_feature_map: diff --git a/geometric_kernels/kernels/matern_kernel_hamming_graph.py b/geometric_kernels/kernels/matern_kernel_hamming_graph.py index a262429c..34ef6646 100644 --- a/geometric_kernels/kernels/matern_kernel_hamming_graph.py +++ b/geometric_kernels/kernels/matern_kernel_hamming_graph.py @@ -1,29 +1,33 @@ r""" This module provides the :class:`MaternKernelHammingGraph` kernel, a subclass of -:class:`MaternKarhunenLoeveKernel` for :class:`HammingGraph` and -:class:`HypercubeGraph` spaces implementing the closed-form formula for the -heat kernel when $\nu = \infty$. +:class:`MaternKarhunenLoeveLogDomain` for :class:`HammingGraph` and +:class:`HypercubeGraph` spaces with log-domain spectral weighting and a +closed-form heat kernel when $\nu = \infty$. """ import lab as B import numpy as np from beartype.typing import Dict, Optional, Union -from geometric_kernels.kernels.karhunen_loeve import MaternKarhunenLoeveKernel +from geometric_kernels.kernels.karhunen_loeve_log_domain import ( + MaternKarhunenLoeveLogDomain, +) from geometric_kernels.spaces.eigenfunctions import Eigenfunctions from geometric_kernels.spaces.hamming_graph import HammingGraph +from geometric_kernels.spaces.hamming_graph_eigenfunctions import ( + HammingGraphEigenfunctions, +) from geometric_kernels.spaces.hypercube_graph import HypercubeGraph from geometric_kernels.utils.kernel_formulas.hamming_graph import ( - hamming_graph_heat_kernel, + _log_hamming_graph_heat_kernel, ) -from geometric_kernels.utils.utils import _check_1_vector, _check_field_in_params -class MaternKernelHammingGraph(MaternKarhunenLoeveKernel): +class MaternKernelHammingGraph(MaternKarhunenLoeveLogDomain): r""" For $\nu = \infty$, there exists a closed-form formula for the heat kernel on hamming graphs :class:`HammingGraph` (including the binary hypercube case - :class:`HypercubeGraph`). This class extends :class:`MaternKarhunenLoeveKernel` + :class:`HypercubeGraph`). This class extends :class:`MaternKarhunenLoeveLogDomain` to implement this formula in the case of $\nu = \infty$ for efficiency. .. note:: @@ -61,36 +65,34 @@ def K( X2: Optional[B.Numeric] = None, **kwargs, ) -> B.Numeric: - _check_field_in_params(params, "lengthscale") - _check_1_vector(params["lengthscale"], 'params["lengthscale"]') - - _check_field_in_params(params, "nu") - _check_1_vector(params["nu"], 'params["nu"]') - - if B.all(params["nu"] == np.inf): - d = X.shape[-1] - - # Only use fast path when we have all levels (exact computation) - if self.num_levels == d + 1: - # Get q from space (HammingGraph has n_cat, HypercubeGraph is binary q=2) - q = getattr(self.space, "n_cat", 2) - - return hamming_graph_heat_kernel(params["lengthscale"], X, X2, q=q) - - return super().K(params, X, X2, **kwargs) + if not isinstance(self.eigenfunctions, HammingGraphEigenfunctions): + return super().K(params, X, X2, **kwargs) + _, log_levels, log_normalizer = self._log_weights(params) + if ( + B.all(params["nu"] == np.inf) + and self.num_levels == self.space.dimension + 1 + ): + log_kernel = _log_hamming_graph_heat_kernel( + params["lengthscale"], X, X2, q=getattr(self.space, "n_cat", 2) + ) + return B.exp(log_kernel if self.normalize else log_kernel + log_normalizer) + + if self.normalize: + log_levels = log_levels - B.max(log_levels) + log_levels = log_levels - B.logsumexp(log_levels) + weights = B.exp(log_levels) + return self.eigenfunctions._weighted_outerproduct_from_level_weights( + weights, X, X2 + ) def K_diag(self, params: Dict[str, B.Numeric], X: B.Numeric, **kwargs) -> B.Numeric: - _check_field_in_params(params, "lengthscale") - _check_1_vector(params["lengthscale"], 'params["lengthscale"]') - - _check_field_in_params(params, "nu") - _check_1_vector(params["nu"], 'params["nu"]') - - if B.all(params["nu"] == np.inf): - d = X.shape[-1] - - # Only use fast path when we have all levels (exact computation) - if self.num_levels == d + 1: - return B.ones(B.dtype(params["nu"]), X.shape[0]) - - return super().K_diag(params, X, **kwargs) + if not isinstance(self.eigenfunctions, HammingGraphEigenfunctions): + return super().K_diag(params, X, **kwargs) + _, log_levels, log_normalizer = self._log_weights(params) + diagonal = B.ones(B.dtype(log_levels), X.shape[0]) + # Retain a differentiation graph for the constant normalized diagonal. + return ( + diagonal + 0.0 * log_normalizer + if self.normalize + else B.exp(log_normalizer) * diagonal + ) diff --git a/geometric_kernels/lab_extras/extras.py b/geometric_kernels/lab_extras/extras.py index 15f673f7..0c85ec5e 100644 --- a/geometric_kernels/lab_extras/extras.py +++ b/geometric_kernels/lab_extras/extras.py @@ -373,3 +373,9 @@ def smart_cast(dtype: B.Bool | B.Int | B.Float | B.Complex | B.Numeric, x: B.Num return B.cast(float_like(x), x) elif dtype == B.Complex: return B.cast(complex_like(x), x) + + +@dispatch +@abstract() +def expm1(x: B.Numeric): + """Compute exp(x) - 1 accurately for small x.""" diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index 6455325d..4fcd0a00 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -262,3 +262,9 @@ def bool_like(reference: B.JAXRandomState): ) # JAX .dtype returns a NumPy data type. This converts it to a JAX one. else: return jnp.bool_ + + +@dispatch +def expm1(x: B.JAXNumeric): # type: ignore + """Compute exp(x) - 1 accurately for small x.""" + return jnp.expm1(x) diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 5167823c..6a825f32 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -251,3 +251,9 @@ def bool_like(reference: B.NPNumeric): return reference_dtype else: return np.bool_ + + +@dispatch +def expm1(x: B.NPNumeric): # type: ignore + """Compute exp(x) - 1 accurately for small x.""" + return np.expm1(x) diff --git a/geometric_kernels/lab_extras/tensorflow/extras.py b/geometric_kernels/lab_extras/tensorflow/extras.py index 90606723..2e3ee7ea 100644 --- a/geometric_kernels/lab_extras/tensorflow/extras.py +++ b/geometric_kernels/lab_extras/tensorflow/extras.py @@ -262,3 +262,9 @@ def bool_like(reference: B.NPNumeric): return reference_dtype else: return tf.bool + + +@dispatch +def expm1(x: B.TFNumeric): # type: ignore + """Compute exp(x) - 1 accurately for small x.""" + return tf.math.expm1(x) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index 771aa205..a1db8364 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -269,3 +269,9 @@ def bool_like(reference: B.TorchNumeric): return reference_dtype else: return torch.bool + + +@dispatch +def expm1(x: B.TorchNumeric): # type: ignore + """Compute exp(x) - 1 accurately for small x.""" + return torch.expm1(x) diff --git a/geometric_kernels/spaces/circle.py b/geometric_kernels/spaces/circle.py index 40f1b3b0..8663c6fb 100644 --- a/geometric_kernels/spaces/circle.py +++ b/geometric_kernels/spaces/circle.py @@ -3,6 +3,8 @@ :class:`~.eigenfunctions.Eigenfunctions` subclass :class:`SinCosEigenfunctions`. """ +from math import log + import lab as B from beartype.typing import List, Optional @@ -121,6 +123,10 @@ def num_eigenfunctions_per_level(self) -> List[int]: """ return [1 if level == 0 else 2 for level in range(self.num_levels)] + @property + def log_num_eigenfunctions_per_level(self): + return [0.0 if level == 0 else log(2.0) for level in range(self.num_levels)] + class Circle(DiscreteSpectrumSpace): r""" diff --git a/geometric_kernels/spaces/eigenfunctions.py b/geometric_kernels/spaces/eigenfunctions.py index 9ecf61ef..315e573d 100644 --- a/geometric_kernels/spaces/eigenfunctions.py +++ b/geometric_kernels/spaces/eigenfunctions.py @@ -61,6 +61,11 @@ class Eigenfunctions(abc.ABC): for all $0 \leq l < L$, and all pairs $x_1$, $x_2$ provided as inputs. """ + # Set to True when weighted_outerproduct_log and + # weighted_outerproduct_diag_log are implemented without first + # exponentiating per-eigenfunction weights. + supports_log_domain = False + def weighted_outerproduct( self, weights: B.Numeric, @@ -219,6 +224,11 @@ def num_eigenfunctions_per_level(self) -> List[int]: """ raise NotImplementedError + @abc.abstractproperty + def log_num_eigenfunctions_per_level(self): + """Log number of eigenfunctions per level, computed independently.""" + raise NotImplementedError + class EigenfunctionsWithAdditionTheorem(Eigenfunctions): r""" @@ -359,3 +369,7 @@ def num_eigenfunctions_per_level(self) -> List[int]: Returns a list of J ones. """ return [1] * self.num_levels + + @property + def log_num_eigenfunctions_per_level(self): + return [0.0] * self.num_levels diff --git a/geometric_kernels/spaces/hamming_graph.py b/geometric_kernels/spaces/hamming_graph.py index 1cc46037..d2c7ecd7 100644 --- a/geometric_kernels/spaces/hamming_graph.py +++ b/geometric_kernels/spaces/hamming_graph.py @@ -15,11 +15,14 @@ Eigenfunctions, EigenfunctionsWithAdditionTheorem, ) +from geometric_kernels.spaces.hamming_graph_eigenfunctions import ( + HammingGraphEigenfunctions, +) from geometric_kernels.utils.special_functions import generalized_kravchuk_normalized -from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial +from geometric_kernels.utils.utils import chain, hamming_distance -class VilenkinFunctions(EigenfunctionsWithAdditionTheorem): +class VilenkinFunctions(HammingGraphEigenfunctions, EigenfunctionsWithAdditionTheorem): r""" Eigenfunctions of the graph Laplacian on the q-ary Hamming graph $H(d,q)$, whose nodes are indexed by categorical vectors in $\{0, 1, ..., q-1\}^d$. @@ -110,64 +113,6 @@ def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: ] return B.concat(*values, axis=1) # [N, L] - def weighted_outerproduct( - self, - weights: B.Numeric, - X: B.Numeric, - X2: Optional[B.Numeric] = None, # type: ignore - **kwargs, - ) -> B.Numeric: - if X2 is None: - X2 = X - - hamming_distances = hamming_distance(X, X2) - - result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] - kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None - for level in range(self.num_levels): - cur_kravchuk_normalized = generalized_kravchuk_normalized( - self.dim, - level, - hamming_distances, - self.n_cat, - kravchuk_normalized_j_minus_1, - kravchuk_normalized_j_minus_2, - ) - kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 - kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized - - # Instead of multiplying weights by binomial coefficients, we sum their - # logs and then exponentiate the result for numerical stability. - # Furthermore, we save the computed Kravchuk polynomials for next iterations. - result += ( - B.exp( - B.log(weights[level]) - + log_binomial(self.dim, level) - + level * B.log(self.n_cat - 1) - ) - * cur_kravchuk_normalized - ) - - return result # [N, N2] - - def weighted_outerproduct_diag( - self, weights: B.Numeric, X: B.Numeric, **kwargs - ) -> B.Numeric: - - # Instead of multiplying weights by binomial coefficients, we sum their - # logs and then exponentiate the result for numerical stability. - result = sum( - B.exp( - B.log(weights[level]) - + log_binomial(self.dim, level) - + level * B.log(self.n_cat - 1) - ) - * B.ones(float_like(X), *X.shape[:-1], 1) - for level in range(self.num_levels) - ) # [N, 1] - - return B.reshape(result, *result.shape[:-1]) # [N,] - @property def num_eigenfunctions(self) -> int: if self._num_eigenfunctions is None: @@ -279,7 +224,7 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: eigenfunctions = VilenkinFunctions(self.dim, self.n_cat, num) eigenvalues = chain( - B.squeeze(eigenvalues_per_level), + B.squeeze(eigenvalues_per_level, axis=1), eigenfunctions.num_eigenfunctions_per_level, ) # [J,] return B.reshape(eigenvalues, -1, 1) # [J, 1] diff --git a/geometric_kernels/spaces/hamming_graph_eigenfunctions.py b/geometric_kernels/spaces/hamming_graph_eigenfunctions.py new file mode 100644 index 00000000..e9255e45 --- /dev/null +++ b/geometric_kernels/spaces/hamming_graph_eigenfunctions.py @@ -0,0 +1,101 @@ +"""Shared eigenfunction computations for hypercube and Hamming graphs.""" + +from functools import cached_property + +import lab as B +import numpy as np +from scipy.special import gammaln + +from geometric_kernels.lab_extras import from_numpy +from geometric_kernels.utils.special_functions import generalized_kravchuk_normalized +from geometric_kernels.utils.utils import hamming_distance + + +class HammingGraphEigenfunctions: + """Shared eigenfunction computations for HypercubeGraph and HammingGraph. + + This mixin serves both :class:`~.hypercube_graph.WalshFunctions` on the + binary hypercube and :class:`~.hamming_graph.VilenkinFunctions` on q-ary + Hamming graphs. It evaluates their normalized Kravchuk polynomials and + combines spectral weights with level multiplicities for kernel evaluation. + Feature maps can use its log addition-theorem values without forming large + multiplicities. + + Subclasses provide ``dim`` and ``num_levels``. The alphabet size is given + by ``n_cat`` when present and defaults to two for the hypercube. + """ + + supports_log_domain = True + + @cached_property + def log_num_eigenfunctions_per_level(self): + """Log multiplicities, shape [L], without forming large integers.""" + levels = np.arange(self.num_levels, dtype=float) + return ( + gammaln(self.dim + 1) + - gammaln(levels + 1) + - gammaln(self.dim - levels + 1) + + levels * np.log(getattr(self, "n_cat", 2) - 1) + ) + + def _log_multiplicities(self, reference): + return B.cast( + B.dtype(reference), + from_numpy(reference, self.log_num_eigenfunctions_per_level), + )[:, None] + + def _normalized_kravchuk(self, X, X2, dtype): + distances = B.cast(dtype, hamming_distance(X, X2)) + previous, previous_previous = None, None + for level in range(self.num_levels): + value = generalized_kravchuk_normalized( + self.dim, + level, + distances, + getattr(self, "n_cat", 2), + previous, + previous_previous, + ) + previous_previous, previous = previous, value + yield value + + def _weighted_outerproduct_from_level_weights(self, weights, X, X2=None): + if X2 is None: + X2 = X + result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) + for level, value in enumerate( + self._normalized_kravchuk(X, X2, B.dtype(weights)) + ): + result = result + weights[level] * value + return result + + def weighted_outerproduct(self, weights, X, X2=None, **kwargs): + level_weights = B.exp(B.log(weights) + self._log_multiplicities(weights)) + return self._weighted_outerproduct_from_level_weights(level_weights, X, X2) + + def weighted_outerproduct_log(self, log_weights, X, X2=None, **kwargs): + log_levels = log_weights + self._log_multiplicities(log_weights) + level_weights = B.exp(log_levels) + return self._weighted_outerproduct_from_level_weights(level_weights, X, X2) + + def weighted_outerproduct_diag(self, weights, X, **kwargs): + diagonal = B.sum(B.exp(B.log(weights) + self._log_multiplicities(weights))) + return diagonal * B.ones(B.dtype(weights), X.shape[0]) + + def weighted_outerproduct_diag_log(self, log_weights, X, **kwargs): + diagonal = B.sum(B.exp(log_weights + self._log_multiplicities(log_weights))) + return diagonal * B.ones(B.dtype(log_weights), X.shape[0]) + + def phi_product_log(self, X, X2=None, *, dtype, **kwargs): + """Return log magnitudes and signs without forming multiplicities.""" + if X2 is None: + X2 = X + values = B.stack(*self._normalized_kravchuk(X, X2, dtype), axis=-1) + nonzero = values != 0 + magnitudes = B.abs(values) + safe_magnitudes = B.where(nonzero, magnitudes, B.ones(magnitudes)) + log_magnitudes = B.log(safe_magnitudes) + B.transpose( + self._log_multiplicities(values) + ) + log_magnitudes = B.where(nonzero, log_magnitudes, float("-inf")) + return log_magnitudes, values / safe_magnitudes diff --git a/geometric_kernels/spaces/hypercube_graph.py b/geometric_kernels/spaces/hypercube_graph.py index f0cb8030..850a811f 100644 --- a/geometric_kernels/spaces/hypercube_graph.py +++ b/geometric_kernels/spaces/hypercube_graph.py @@ -16,14 +16,17 @@ Eigenfunctions, EigenfunctionsWithAdditionTheorem, ) +from geometric_kernels.spaces.hamming_graph_eigenfunctions import ( + HammingGraphEigenfunctions, +) from geometric_kernels.utils.special_functions import ( generalized_kravchuk_normalized, walsh_function, ) -from geometric_kernels.utils.utils import chain, hamming_distance, log_binomial +from geometric_kernels.utils.utils import chain, hamming_distance -class WalshFunctions(EigenfunctionsWithAdditionTheorem): +class WalshFunctions(HammingGraphEigenfunctions, EigenfunctionsWithAdditionTheorem): r""" Eigenfunctions of graph Laplacian on the hypercube graph $C^d$ whose nodes are index by binary vectors in $\{0, 1\}^d$ are the Walsh @@ -101,56 +104,6 @@ def _addition_theorem_diag(self, X: B.Numeric, **kwargs) -> B.Numeric: ] return B.concat(*values, axis=1) # [N, L] - def weighted_outerproduct( - self, - weights: B.Numeric, - X: B.Numeric, - X2: Optional[B.Numeric] = None, # type: ignore - **kwargs, - ) -> B.Numeric: - if X2 is None: - X2 = X - - hamming_distances = hamming_distance(X, X2) - - result = B.zeros(B.dtype(weights), X.shape[0], X2.shape[0]) # [N, N2] - kravchuk_normalized_j_minus_1, kravchuk_normalized_j_minus_2 = None, None - for level in range(self.num_levels): - cur_kravchuk_normalized = generalized_kravchuk_normalized( - self.dim, - level, - hamming_distances, - 2, - kravchuk_normalized_j_minus_1, - kravchuk_normalized_j_minus_2, - ) - kravchuk_normalized_j_minus_2 = kravchuk_normalized_j_minus_1 - kravchuk_normalized_j_minus_1 = cur_kravchuk_normalized - - # Instead of multiplying weights by binomial coefficients, we sum their - # logs and then exponentiate the result for numerical stability. - # Furthermore, we save the computed Kravchuk polynomials for next iterations. - result += ( - B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) - * cur_kravchuk_normalized - ) - - return result # [N, N2] - - def weighted_outerproduct_diag( - self, weights: B.Numeric, X: B.Numeric, **kwargs - ) -> B.Numeric: - - # Instead of multiplying weights by binomial coefficients, we sum their - # logs and then exponentiate the result for numerical stability. - result = sum( - B.exp(B.log(weights[level]) + log_binomial(self.dim, level)) - * B.ones(float_like(X), *X.shape[:-1], 1) - for level in range(self.num_levels) - ) # [N, 1] - - return B.reshape(result, *result.shape[:-1]) # [N,] - @property def num_eigenfunctions(self) -> int: if self._num_eigenfunctions is None: @@ -240,7 +193,7 @@ def get_repeated_eigenvalues(self, num: int) -> B.Numeric: eigenfunctions = WalshFunctions(self.dim, num) eigenvalues = chain( - B.squeeze(eigenvalues_per_level), + B.squeeze(eigenvalues_per_level, axis=1), eigenfunctions.num_eigenfunctions_per_level, ) # [J,] return B.reshape(eigenvalues, -1, 1) # [J, 1] diff --git a/geometric_kernels/spaces/hypersphere.py b/geometric_kernels/spaces/hypersphere.py index 5aa1870a..eef9e89a 100644 --- a/geometric_kernels/spaces/hypersphere.py +++ b/geometric_kernels/spaces/hypersphere.py @@ -7,6 +7,7 @@ import lab as B import numpy as np from beartype.typing import List, Optional +from scipy.special import gammaln from spherical_harmonics import SphericalHarmonics as _SphericalHarmonics from spherical_harmonics.fundamental_set import num_harmonics @@ -117,6 +118,17 @@ def num_levels(self) -> int: def num_eigenfunctions_per_level(self) -> List[int]: return [num_harmonics(self.dim + 1, level) for level in range(self.num_levels)] + @property + def log_num_eigenfunctions_per_level(self): + levels = np.arange(self.num_levels, dtype=float) + d = self.dim + return ( + np.log(2 * levels + d - 1) + + gammaln(levels + d - 1) + - gammaln(levels + 1) + - gammaln(d) + ) + class Hypersphere(DiscreteSpectrumSpace, gs.geometry.hypersphere.Hypersphere): r""" diff --git a/geometric_kernels/spaces/lie_groups.py b/geometric_kernels/spaces/lie_groups.py index 0ee11441..821714f9 100644 --- a/geometric_kernels/spaces/lie_groups.py +++ b/geometric_kernels/spaces/lie_groups.py @@ -282,6 +282,10 @@ def num_eigenfunctions_per_level(self) -> List[int]: """ return [d**2 for d in self._dimensions] + @property + def log_num_eigenfunctions_per_level(self): + return [2.0 * np.log(d) for d in self._dimensions] + class CompactMatrixLieGroup(DiscreteSpectrumSpace): r""" diff --git a/geometric_kernels/spaces/product.py b/geometric_kernels/spaces/product.py index 14810deb..578db9fb 100644 --- a/geometric_kernels/spaces/product.py +++ b/geometric_kernels/spaces/product.py @@ -360,6 +360,20 @@ def num_eigenfunctions_per_level(self) -> List[int]: return totals + @property + def log_num_eigenfunctions_per_level(self): + factor_logs = [ + eigenfunctions.log_num_eigenfunctions_per_level + for eigenfunctions in self.eigenfunctions + ] + return [ + sum( + factor_logs[s][self.eigenindicies[level, s]] + for s in range(len(factor_logs)) + ) + for level in range(self.num_levels) + ] + class ProductDiscreteSpectrumSpace(DiscreteSpectrumSpace): r""" diff --git a/geometric_kernels/utils/kernel_formulas/hamming_graph.py b/geometric_kernels/utils/kernel_formulas/hamming_graph.py index 487752c3..fc3fc297 100644 --- a/geometric_kernels/utils/kernel_formulas/hamming_graph.py +++ b/geometric_kernels/utils/kernel_formulas/hamming_graph.py @@ -9,7 +9,7 @@ import lab as B from beartype.typing import Optional -from geometric_kernels.lab_extras import float_like +from geometric_kernels.lab_extras import expm1 from geometric_kernels.utils.utils import _check_1_vector, _check_matrix @@ -38,13 +38,20 @@ def hamming_graph_heat_kernel( :return: The kernel matrix, an array of shape [N, N2]. """ + return B.exp( + _log_hamming_graph_heat_kernel(lengthscale, X, X2, q, normalized_laplacian) + ) + + +def _log_hamming_graph_heat_kernel( + lengthscale, X, X2=None, q=2, normalized_laplacian=True +): + """Log of the unit-diagonal heat kernel, with stable small-time evaluation.""" if X2 is None: X2 = X - _check_1_vector(lengthscale, "lengthscale") _check_matrix(X, "X") _check_matrix(X2, "X2") - d = X.shape[-1] if normalized_laplacian: @@ -52,12 +59,16 @@ def hamming_graph_heat_kernel( beta = lengthscale**2 / 2 - # Compute disagreement indicator: 1 when coordinates differ, 0 when they match - # Shape: [N, N2, d] - disagreement = B.cast(float_like(X), X[:, None, :] != X2[None, :, :]) + # One for coordinates that differ, zero for coordinates that match. + # Shape: [N, N2, d]. + disagreement = B.cast(B.dtype(lengthscale), X[:, None, :] != X2[None, :, :]) exp_neg_beta_q = B.exp(-beta * q) - factor_disagree = (1 - exp_neg_beta_q) / (1 + (q - 1) * exp_neg_beta_q) - log_kernel = B.sum(B.log(factor_disagree) * disagreement, axis=-1) + # expm1 avoids cancellation in 1 - exp(-beta * q) at small lengthscales. + factor_disagree = -expm1(-beta * q) / (1 + (q - 1) * exp_neg_beta_q) + # Matching coordinates contribute log(1) = 0, including at zero lengthscale. + # Mask before taking the logarithm to avoid 0 * log(0). + safe_factor = B.where(disagreement == 0, B.ones(disagreement), factor_disagree) + log_kernel = B.sum(B.log(safe_factor) * disagreement, axis=-1) - return B.exp(log_kernel) # Shape: [N, N2] + return log_kernel diff --git a/notebooks/HypercubeGraph.ipynb b/notebooks/HypercubeGraph.ipynb index 3d3f5551..b1ce8400 100644 --- a/notebooks/HypercubeGraph.ipynb +++ b/notebooks/HypercubeGraph.ipynb @@ -487,8 +487,9 @@ "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`." + "For both hypercube and Hamming graphs, the default is `RandomPhaseFeatureMapLogDomain`, which computes weights in the log domain. It returns random-phase features, avoiding explicit enumeration of all eigenfunctions.\n", + "The number of features is the number of selected spectral levels times the number of random phases. Below we use the kernel's levels and the default number of phases.\n", + "For a small hypercube, `DeterministicFeatureMapCompact` remains available explicitly." ] }, { @@ -506,17 +507,14 @@ "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 graphs, `normalize` follows the standard behavior of `MaternKarhunenLoeveKernel`, being `True` by default.\n", + "The resulting `feature_map` takes the array of inputs, kernel parameters, and a random `key`.\n", + "The optional `normalize` parameter defaults to `True` and normalizes each feature row to unit norm.\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 `Graph` space, the first element is `None` since the feature map is *deterministic*.\n", + "`feature_map` outputs a tuple containing the updated random key and the feature matrix.\n", + "Use the same initial random state when evaluating the same feature map at different inputs, or use `make_deterministic` from `geometric_kernels.utils.utils` to fix its randomness.\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}$." + "In the next cell, we evaluate the feature map at random points using `params_32` as kernel parameters.\n", + "We check the approximate identity $k(x, x') \\approx \\langle \\phi(x), \\phi(x') \\rangle_{\\mathbb{R}^M}$." ] }, { @@ -533,48 +531,22 @@ " [ True False False False True False]\n", " [False False True False False True]]\n", "\n", - "emedding (shape = (3, 64)):\n", - "[[ 0.52479504 -0.22943667 0.22943667 -0.22943667 0.22943667 0.22943667\n", - " -0.22943667 -0.12546578 0.12546578 -0.12546578 -0.12546578 0.12546578\n", - " -0.12546578 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.12546578\n", - " 0.12546578 0.12546578 -0.12546578 -0.12546578 0.07799054 -0.07799054\n", - " -0.07799054 0.07799054 0.07799054 0.07799054 -0.07799054 -0.07799054\n", - " 0.07799054 0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", - " -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054 -0.07799054\n", - " 0.05268298 0.05268298 -0.05268298 -0.05268298 0.05268298 0.05268298\n", - " 0.05268298 -0.05268298 -0.05268298 0.05268298 -0.05268298 0.05268298\n", - " 0.05268298 -0.05268298 0.05268298 0.03772592 -0.03772592 -0.03772592\n", - " 0.03772592 -0.03772592 0.03772592 -0.02820844]\n", - " [ 0.52479504 -0.22943667 0.22943667 0.22943667 0.22943667 -0.22943667\n", - " 0.22943667 -0.12546578 -0.12546578 -0.12546578 0.12546578 -0.12546578\n", - " 0.12546578 0.12546578 -0.12546578 0.12546578 0.12546578 -0.12546578\n", - " 0.12546578 -0.12546578 0.12546578 -0.12546578 -0.07799054 -0.07799054\n", - " 0.07799054 -0.07799054 -0.07799054 0.07799054 -0.07799054 0.07799054\n", - " -0.07799054 0.07799054 0.07799054 -0.07799054 0.07799054 -0.07799054\n", - " 0.07799054 -0.07799054 -0.07799054 0.07799054 -0.07799054 -0.07799054\n", - " -0.05268298 0.05268298 -0.05268298 0.05268298 -0.05268298 0.05268298\n", - " 0.05268298 -0.05268298 0.05268298 0.05268298 -0.05268298 0.05268298\n", - " -0.05268298 -0.05268298 -0.05268298 0.03772592 -0.03772592 0.03772592\n", - " 0.03772592 0.03772592 -0.03772592 0.02820844]\n", - " [ 0.52479504 0.22943667 0.22943667 -0.22943667 0.22943667 0.22943667\n", - " -0.22943667 0.12546578 -0.12546578 0.12546578 0.12546578 -0.12546578\n", - " -0.12546578 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.12546578\n", - " 0.12546578 0.12546578 -0.12546578 -0.12546578 -0.07799054 0.07799054\n", - " 0.07799054 -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", - " -0.07799054 -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054\n", - " -0.07799054 -0.07799054 -0.07799054 0.07799054 0.07799054 -0.07799054\n", - " -0.05268298 -0.05268298 0.05268298 0.05268298 -0.05268298 -0.05268298\n", - " -0.05268298 0.05268298 0.05268298 -0.05268298 -0.05268298 0.05268298\n", - " 0.05268298 -0.05268298 0.05268298 -0.03772592 0.03772592 0.03772592\n", - " -0.03772592 0.03772592 0.03772592 0.02820844]]\n", + "emedding (shape = (3, 21000)):\n", + "[[ 0.00971383 0.0254809 0.03483511 ... -0.00097515 0.00139659\n", + " 0.00052213]\n", + " [ 0.00955347 0. -0.00685201 ... 0.00287715 0.\n", + " -0.00051351]\n", + " [ 0.00953122 0.01666794 0.01139342 ... 0.00287045 0.\n", + " -0.00051232]]\n", "\n", - "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 1.1729809684177493e-15\n" + "||k(xs, xs) - phi(xs) * phi(xs)^T|| = 0.01134220000875446\n" ] } ], "source": [ "# xs are random points from above\n", - "_, embedding = feature_map(xs, params_32)\n", + "key = np.random.RandomState(seed=1234)\n", + "key, embedding = feature_map(xs, params_32, key=key)\n", "\n", "print('xs (shape = %s):\\n%s' % (xs.shape, xs))\n", "print('')\n", @@ -616,9 +588,9 @@ "output_type": "stream", "text": [ "Two samples evaluated at the xs are:\n", - "[[-1.21817066 0.34257515]\n", - " [ 0.06262042 -1.43217014]\n", - " [-0.16312442 0.16001365]]\n" + "[[ 109.45118372 -37.18577627]\n", + " [ 248.17307823 -101.97313678]\n", + " [ 160.51006775 181.20560366]]\n" ] } ], @@ -653,9 +625,9 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, diff --git a/notebooks/frontends/GPJax.ipynb b/notebooks/frontends/GPJax.ipynb index a403bdb3..8a52d072 100644 --- a/notebooks/frontends/GPJax.ipynb +++ b/notebooks/frontends/GPJax.ipynb @@ -26,7 +26,7 @@ "\n", "This notebooks shows how to fit a [GPJax](https://jaxgaussianprocesses.com/) Gaussian process (GP) on a mesh.\n", "\n", - "This notebook is written for GPJax>=0.12.2 (Python-3.10) and GPJax<=0.13.2 (Python-3.11). GPJax is in active development and changes API frequently. We strive to support the most recent version of it, so the notebook will not work on the older versions." + "This notebook is written for GPJax>=0.14.0. GPJax is in active development and changes API frequently. We strive to support the most recent version of it, so the notebook will not work on the older versions." ] }, { @@ -463,7 +463,7 @@ } ], "source": [ - "mll = jax.jit(mll, static_argnums=(0,))\n", + "mll = gpx.objectives.conjugate_mll\n", "\n", "print(\"Starting training...\")\n", "opt_posterior, history = gpx.fit(\n", @@ -472,7 +472,6 @@ " train_data=data,\n", " optim=optax.sgd(0.01),\n", " key=key,\n", - " trainable=gpx.parameters.Parameter,\n", ")\n", "print(\"Final model:\")\n", "print(\"kernel.nu =\", opt_posterior.prior.kernel.nu)\n", diff --git a/pyproject.toml b/pyproject.toml index 564c0502..a04128b2 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -20,7 +20,7 @@ classifiers = [ keywords=[ "geometric-kernels", ] -requires-python = ">=3.10" +requires-python = ">=3.11,<3.14" dependencies = [ "backends>=1.8.0", "einops", @@ -57,11 +57,15 @@ allow_redefinition = true [tool.black] line-length = 88 -target-version = ['py310', 'py311', 'py312'] +target-version = ['py311', 'py312'] [tool.uv] default-groups = [] +# GPflow still declares NumPy <2 and the obsolete Apple Silicon TF package. +# tensorflow supplies macOS wheels directly. +override-dependencies = ["numpy>=2.0,<2.4"] +exclude-dependencies = ["tensorflow-macos"] [dependency-groups] dev = [ @@ -70,7 +74,7 @@ dev = [ "backends>=1.8.0", "plotly", "kaleido", - "black==24.3.0", + "black==24.10.0", "flake8==7.0.0", "isort==5.13.2", "autoflake", @@ -94,16 +98,16 @@ dev = [ "botorch>=0.9", # TensorFlow / GPflow / TFP split - 'tensorflow<=2.20.0', - 'tensorflow-probability<=0.25.0', - 'gpflow', - 'tf_keras<=2.20.1', + 'tensorflow>=2.20.0,<2.21', + 'tensorflow-probability>=0.25.0,<0.26', + 'gpflow>=2.10.1', + 'tf_keras>=2.20.1,<2.21', # JAX family 'jax', 'jaxlib', 'jaxtyping', 'optax', - 'gpjax>=0.12.2', + 'gpjax>=0.14.0', 'orbax-checkpoint==0.11.32; platform_system == "Windows"', # newer version depends on uvloop, unavailable in windows ] diff --git a/tests/kernels/test_hamming_log_weights.py b/tests/kernels/test_hamming_log_weights.py new file mode 100644 index 00000000..390a9524 --- /dev/null +++ b/tests/kernels/test_hamming_log_weights.py @@ -0,0 +1,380 @@ +"""Regression tests for the space-specific log-domain computation.""" + +import importlib +from math import comb + +import lab as B +import mpmath as mp +import numpy as np +import pytest + +from geometric_kernels.feature_maps import ( + DeterministicFeatureMapCompact, + RandomPhaseFeatureMapLogDomain, +) +from geometric_kernels.kernels import MaternGeometricKernel, MaternKarhunenLoeveKernel +from geometric_kernels.kernels.matern_kernel_hamming_graph import ( + MaternKernelHammingGraph, +) +from geometric_kernels.spaces import Circle, HammingGraph, HypercubeGraph + +from ..helper import np_to_backend + + +def params(nu=1.5, lengthscale=0.7, dtype=np.float64): + return dict( + nu=np.array([nu], dtype=dtype), lengthscale=np.array([lengthscale], dtype=dtype) + ) + + +def points(d): + x = np.zeros((3, d), dtype=int) + x[1, 0] = 1 + x[2, : d // 2] = 1 + return x + + +@pytest.mark.parametrize("space", [HypercubeGraph(5), HammingGraph(5, 4)]) +@pytest.mark.parametrize("levels", [3, 6]) +@pytest.mark.parametrize("normalize", [False, True]) +@pytest.mark.parametrize("nu", [0.5, 2.5, np.inf]) +def test_small_kernel_matches_standard(space, levels, normalize, nu): + kernel = MaternKernelHammingGraph(space, levels, normalize=normalize) + old = MaternKarhunenLoeveKernel(space, levels, normalize=normalize) + p = params(nu) + x = points(5) + np.testing.assert_allclose(kernel.eigenvalues(p), old.eigenvalues(p), rtol=1e-12) + np.testing.assert_allclose(kernel.K(p, x), old.K(p, x), atol=1e-12) + np.testing.assert_allclose(kernel.K_diag(p, x), np.diag(kernel.K(p, x)), atol=1e-12) + np.testing.assert_allclose(kernel.K(p, x, x[:2]), kernel.K(p, x)[:, :2], atol=1e-12) + + +@pytest.mark.parametrize("d", [32, 128, 1024]) +@pytest.mark.parametrize("q", [2, 4, 20]) +def test_high_precision_level_weights(d, q): + space = HammingGraph(d, q) + kernel = MaternKernelHammingGraph(space, d + 1) + p = params(lengthscale=0.1) + # Independent arbitrary-precision powers and exact integer multiplicities. + with mp.workdps(100): + raw = [ + (mp.mpf(300) + mp.mpf(q * j) / (d * (q - 1))) + ** (-mp.mpf("1.5") - mp.mpf(d) / 2) + for j in range(d + 1) + ] + masses = [w * comb(d, j) * (q - 1) ** j for j, w in enumerate(raw)] + z = mp.fsum(masses) + expected = np.array([float(m / z) for m in masses]) + expected_log = np.array([float(mp.log(w / z)) for w in raw])[:, None] + log_w = kernel.log_eigenvalues(p) + actual = np.exp( + log_w[:, 0] + kernel.eigenfunctions.log_num_eigenfunctions_per_level + ) + np.testing.assert_allclose(actual, expected, rtol=1e-10, atol=1e-14) + np.testing.assert_allclose(log_w, expected_log, rtol=1e-12, atol=1e-10) + # No cancellation on the diagonal, even when raw spectral values underflow. + x = points(d)[:1] + np.testing.assert_allclose(kernel.K(p, x), [[1]], atol=1e-10) + if d == 1024: + assert np.all( + kernel.spectrum(space.get_eigenvalues(d + 1), p["nu"], p["lengthscale"], d) + == 0 + ) + + +@pytest.mark.parametrize("d,q,levels", [(32, 2, 12), (128, 4, 15), (1024, 20, 20)]) +def test_high_precision_kernel(d, q, levels): + kernel = MaternKernelHammingGraph(HammingGraph(d, q), levels) + p = params(lengthscale=0.1) + x = points(d) + with mp.workdps(100): + masses = [ + (mp.mpf(300) + mp.mpf(q * j) / (d * (q - 1))) + ** (-mp.mpf("1.5") - mp.mpf(d) / 2) + for j in range(levels) + ] + z = mp.fsum(masses[j] * comb(d, j) * (q - 1) ** j for j in range(levels)) + expected = [] + for m in [0, 1, d // 2]: + terms = [] + for j in range(levels): + # Direct integer polynomial, independent of the recurrence. + polynomial = sum( + (-1) ** r * (q - 1) ** (j - r) * comb(m, r) * comb(d - m, j - r) + for r in range(max(0, j - (d - m)), min(j, m) + 1) + ) + terms.append(masses[j] * polynomial) + expected.append(float(mp.fsum(terms) / z)) + actual = kernel.K(p, x[:1], x)[0] + np.testing.assert_allclose(actual, expected, rtol=1e-10, atol=1e-12) + + +@pytest.mark.parametrize("normalize", [False, True]) +@pytest.mark.parametrize("nu", [1.5, np.inf]) +def test_deterministic_features(normalize, nu): + space = HypercubeGraph(6) + p = params(nu) + x = points(6) + for levels in [3, 7]: + fmap = DeterministicFeatureMapCompact(space, levels) + _, features = fmap(x, p, normalize=normalize) + kernel = MaternKernelHammingGraph(space, levels, normalize=normalize) + np.testing.assert_allclose(features @ features.T, kernel.K(p, x), atol=1e-12) + + +@pytest.mark.parametrize("space", [HypercubeGraph(6), HammingGraph(6, 4)]) +@pytest.mark.parametrize("normalize", [False, True]) +def test_random_features_preserve_values(space, normalize): + p = params() + x = points(6) + fmap = RandomPhaseFeatureMapLogDomain(space, 5, 11) + _, phases = space.random(np.random.RandomState(23), 11) + spectrum = MaternKarhunenLoeveKernel.spectrum( + space.get_eigenvalues(5), p["nu"], p["lengthscale"], 6 + ) + expected = ( + fmap.eigenfunctions.phi_product(x, phases) * np.sqrt(spectrum.T) + ).reshape(3, -1) + if normalize: + expected /= np.linalg.norm(expected, axis=1, keepdims=True) + _, actual = fmap(x, p, key=np.random.RandomState(23), normalize=normalize) + np.testing.assert_allclose(actual, expected, rtol=1e-12, atol=1e-14) + + +@pytest.mark.parametrize("backend", ["numpy", "torch", "tensorflow", "jax"]) +@pytest.mark.parametrize("dtype", [np.float32, np.float64]) +def test_backends(backend, dtype): + if backend != "numpy": + importlib.import_module("geometric_kernels." + backend) + if backend == "jax": + import jax + + jax.config.update("jax_enable_x64", True) + + def cast(x): + return np_to_backend(x, backend) + + p = {k: cast(v) for k, v in params(dtype=dtype).items()} + x = cast(points(32)) + kernel = MaternKernelHammingGraph(HammingGraph(32, 4), 12) + expected = kernel.K(params(), points(32)) + actual = kernel.K(p, x) + tol = 1e-5 if dtype == np.float32 else 1e-10 + np.testing.assert_allclose(B.to_numpy(actual), expected, rtol=tol, atol=tol) + assert B.to_numpy(actual).dtype == dtype + for nu in [1.5, np.inf]: + p["nu"] = cast(np.array([nu], dtype=dtype)) + full = MaternKernelHammingGraph(HammingGraph(32, 4), 33) + np.testing.assert_allclose(B.to_numpy(full.K_diag(p, x)), 1, atol=tol) + assert np.all(np.isfinite(B.to_numpy(full.K(p, x)))) + # Explicit phase locations avoid backend-specific RNG differences. + fmap = RandomPhaseFeatureMapLogDomain(HammingGraph(1024, 20), 24) + log_spectrum = kernel.log_spectrum( + cast(np.arange(24, dtype=dtype)[:, None] / 1024), + p["nu"], + p["lengthscale"], + 1024, + ) + large_x = cast(points(1024)) + f = fmap._features_from_log_spectrum(log_spectrum, large_x, large_x, True) + assert np.all(np.isfinite(B.to_numpy(f))) + np.testing.assert_allclose(np.sum(B.to_numpy(f) ** 2, axis=1), 1, atol=tol) + + +@pytest.mark.parametrize("backend", ["torch", "tensorflow", "jax"]) +@pytest.mark.parametrize("nu", [1.5, np.inf]) +@pytest.mark.parametrize("dtype", [np.float32, np.float64]) +@pytest.mark.parametrize("diagonal_only", [False, True]) +def test_gradients(backend, nu, dtype, diagonal_only): + importlib.import_module("geometric_kernels." + backend) + x = np_to_backend(points(8), backend) + kernel = MaternKernelHammingGraph(HammingGraph(8, 4), 6) + full = MaternKernelHammingGraph(HammingGraph(8, 4), 9) + fmap = RandomPhaseFeatureMapLogDomain(kernel.space, kernel.num_levels) + + def objective(theta): + p = { + "nu": ( + theta[:1] + if np.isfinite(nu) + else B.cast(B.dtype(theta), np_to_backend(np.array([np.inf]), backend)) + ), + "lengthscale": theta[1:], + } + if diagonal_only: + return B.sum(kernel.K_diag(p, x)) + log_s = kernel.log_spectrum( + kernel.eigenvalues_laplacian, p["nu"], p["lengthscale"], 8 + ) + f = fmap._features_from_log_spectrum(log_s, x, x, True) + return B.sum(kernel.K(p, x)) + B.sum(full.K(p, x)) + B.sum(f) + + theta_np = np.array([1.5, 0.7], dtype=dtype) + if backend == "torch": + import torch + + theta = torch.tensor(theta_np, requires_grad=True) + gradient = torch.autograd.grad(objective(theta), theta)[0].detach().numpy() + elif backend == "tensorflow": + import tensorflow as tf + + theta = tf.Variable(theta_np) + with tf.GradientTape() as tape: + value = objective(theta) + gradient = tape.gradient(value, theta).numpy() + else: + import jax + + jax.config.update("jax_enable_x64", True) + gradient = np.array(jax.grad(objective)(np_to_backend(theta_np, backend))) + finite_difference = [] + for i in range(2): + delta = np.zeros(2) + delta[i] = 1e-5 + finite_difference.append( + float( + B.to_numpy( + objective(np_to_backend(theta_np + delta, backend)) + - objective(np_to_backend(theta_np - delta, backend)) + ) + ) + / 2e-5 + ) + assert np.all(np.isfinite(gradient)) + np.testing.assert_allclose( + gradient, + finite_difference, + rtol=1e-5, + atol=1e-5 if dtype == np.float32 else 1e-7, + ) + + +def test_heat_small_lengthscale_and_zero(): + x = points(128) + kernel = MaternKernelHammingGraph(HammingGraph(128, 20), 129) + for lengthscale in [0, 1e-12, 0.1]: + p = params(np.inf, lengthscale) + with np.errstate(divide="ignore", invalid="ignore"): + matrix = kernel.K(p, x) + assert np.all(np.isfinite(matrix)) + np.testing.assert_allclose(np.diag(matrix), 1) + if lengthscale > 0: + a = lengthscale**2 * 20 / (2 * 128 * 19) + factor = -np.expm1(-a) / (1 + 19 * np.exp(-a)) + np.testing.assert_allclose(matrix[0, 1], factor, rtol=1e-12, atol=0) + + +def test_other_spaces_keep_standard_computation(): + kernel = MaternGeometricKernel(Circle(), num=5) + assert type(kernel) is MaternKarhunenLoeveKernel + assert not hasattr(kernel, "log_spectrum") + np.testing.assert_allclose( + kernel.eigenfunctions.log_num_eigenfunctions_per_level, + np.log(kernel.eigenfunctions.num_eigenfunctions_per_level), + ) + + +def test_explicit_feature_weights_use_linear_spectrum(): + space = HypercubeGraph(6) + fmap = DeterministicFeatureMapCompact(space, 1) + p = params(lengthscale=0.7) + x = points(6) + _, raw = fmap(x, p, normalize=False) + spectrum = MaternKarhunenLoeveKernel.spectrum( + space.get_repeated_eigenvalues(1), p["nu"], p["lengthscale"], 6 + ) + np.testing.assert_allclose(raw, np.full_like(raw, np.sqrt(spectrum)[0, 0])) + _, normalized = fmap(x, p) + np.testing.assert_array_equal(normalized, np.ones((3, 1))) + + +@pytest.mark.parametrize("q", [2, 4, 20]) +@pytest.mark.parametrize("d", [32, 128, 1024]) +def test_large_random_features_finite_spectrum(d, q): + space = HammingGraph(d, q) + fmap = RandomPhaseFeatureMapLogDomain(space, min(24, d + 1), 4) + _, f = fmap(points(d), params(lengthscale=0.1), key=np.random.RandomState(4)) + assert np.all(np.isfinite(f)) + np.testing.assert_allclose(np.sum(f**2, axis=1), 1, atol=1e-10) + + +def test_zero_linear_weights(): + for space in [HypercubeGraph(3), HammingGraph(3, 4)]: + phi = space.get_eigenfunctions(4) + x = points(3) + with np.errstate(divide="ignore"): + np.testing.assert_array_equal( + phi.weighted_outerproduct(np.zeros((4, 1)), x), np.zeros((3, 3)) + ) + np.testing.assert_array_equal( + phi.weighted_outerproduct_diag(np.zeros((4, 1)), x), np.zeros(3) + ) + + +@pytest.mark.parametrize("d", [32, 128, 1024]) +@pytest.mark.parametrize("nu", [1.5, np.inf]) +def test_binary_hamming_matches_hypercube(d, nu): + p = params(nu) + x = points(d) + hypercube = MaternKernelHammingGraph(HypercubeGraph(d), 24) + hamming = MaternKernelHammingGraph(HammingGraph(d, 2), 24) + np.testing.assert_array_equal(hypercube.K(p, x), hamming.K(p, x)) + for space in [HypercubeGraph(d), HammingGraph(d, 2)]: + np.testing.assert_array_equal(space.get_repeated_eigenvalues(1), [[0.0]]) + + +def test_explicit_generic_eigenfunctions(): + from geometric_kernels.spaces.eigenfunctions import EigenfunctionsFromEigenvectors + + space = HypercubeGraph(1) + phi = EigenfunctionsFromEigenvectors(np.array([[2.0, 0.0], [1.0, 3.0]])) + options = dict(eigenvalues_laplacian=space.get_eigenvalues(2), eigenfunctions=phi) + kernel = MaternKernelHammingGraph(space, 2, **options) + reference = MaternKarhunenLoeveKernel(space, 2, **options) + x = np.array([[0], [1]]) + p = params() + np.testing.assert_allclose(kernel.K(p, x), reference.K(p, x), atol=1e-12) + np.testing.assert_allclose(kernel.K_diag(p, x), reference.K_diag(p, x), atol=1e-12) + + +@pytest.mark.parametrize("space", [HypercubeGraph(1024), HammingGraph(1024, 4)]) +def test_default_log_random_features(space): + from geometric_kernels.kernels import default_feature_map + + kernel = MaternGeometricKernel(space, num=12) + for fmap in [ + default_feature_map(space=space, num=12), + default_feature_map(kernel=kernel), + ]: + assert type(fmap) is RandomPhaseFeatureMapLogDomain + assert fmap.num_levels == 12 + assert not hasattr(fmap.eigenfunctions, "_random_phase_features") + _, fmap = MaternGeometricKernel(space, num=12, return_feature_map=True) + assert type(fmap) is RandomPhaseFeatureMapLogDomain + + +def test_other_feature_map_defaults_unchanged(): + from geometric_kernels.feature_maps import RandomPhaseFeatureMapCompact + from geometric_kernels.kernels import default_feature_map + from geometric_kernels.spaces import SpecialOrthogonal + + assert ( + type(default_feature_map(space=Circle(), num=3)) + is DeterministicFeatureMapCompact + ) + assert ( + type(default_feature_map(space=SpecialOrthogonal(3), num=3)) + is RandomPhaseFeatureMapCompact + ) + assert RandomPhaseFeatureMapLogDomain(Circle(), 3).num_levels == 3 + + +@pytest.mark.parametrize("space", [HypercubeGraph(6), HammingGraph(6, 4)]) +def test_phi_product_log(space): + phi = space.get_eigenfunctions(5) + x = points(6) + log_magnitude, sign = phi.phi_product_log(x, dtype=np.float64) + expected = phi.phi_product(x) + with np.errstate(divide="ignore"): + np.testing.assert_allclose(log_magnitude, np.log(np.abs(expected)), atol=1e-12) + np.testing.assert_array_equal(sign, np.sign(expected)) diff --git a/tests/kernels/test_log_domain.py b/tests/kernels/test_log_domain.py new file mode 100644 index 00000000..78dce6f3 --- /dev/null +++ b/tests/kernels/test_log_domain.py @@ -0,0 +1,99 @@ +"""Tests for the space-independent log-domain kernel and feature map.""" + +import numpy as np +import pytest + +from geometric_kernels.feature_maps import RandomPhaseFeatureMapLogDomain +from geometric_kernels.kernels import ( + MaternGeometricKernel, + MaternKarhunenLoeveKernel, + MaternKarhunenLoeveLogDomain, + default_feature_map, +) +from geometric_kernels.spaces import Circle, HammingGraph, HypercubeGraph + + +def params(nu=1.5, lengthscale=0.7): + return {"nu": np.array([nu]), "lengthscale": np.array([lengthscale])} + + +def test_log_domain_support_flag(): + assert not Circle().get_eigenfunctions(4).supports_log_domain + assert HypercubeGraph(6).get_eigenfunctions(4).supports_log_domain + assert HammingGraph(6, 4).get_eigenfunctions(4).supports_log_domain + + +@pytest.mark.parametrize("space", [Circle(), HypercubeGraph(6), HammingGraph(6, 4)]) +def test_log_kernel_matches_linear_kernel_on_small_spaces(space): + levels = 4 + kernel = MaternKarhunenLoeveLogDomain(space, levels) + linear = MaternKarhunenLoeveKernel(space, levels) + key = np.random.RandomState(4) + _, x = space.random(key, 5) + for nu in [0.5, np.inf]: + p = params(nu) + np.testing.assert_allclose( + kernel.eigenvalues(p), linear.eigenvalues(p), rtol=1e-12 + ) + np.testing.assert_allclose( + kernel.K(p, x), linear.K(p, x), rtol=1e-12, atol=1e-12 + ) + np.testing.assert_allclose(kernel.K_diag(p, x), linear.K_diag(p, x), rtol=1e-12) + + +def test_large_log_kernel_avoids_underflow_and_multiplicity_overflow(): + space = HammingGraph(1024, 20) + kernel = MaternKarhunenLoeveLogDomain(space, 24) + p = params(lengthscale=0.1) + x = np.zeros((2, 1024), dtype=int) + x[1, 0] = 1 + assert np.all(np.isfinite(kernel.log_eigenvalues(p))) + matrix = kernel.K(p, x) + assert np.all(np.isfinite(matrix)) + np.testing.assert_allclose(np.diag(matrix), 1, atol=1e-11) + + +def test_log_kernel_evaluates_when_all_linear_eigenvalues_underflow(): + space = HammingGraph(1024, 20) + kernel = MaternKarhunenLoeveLogDomain(space, 1025) + p = params(lengthscale=0.1) + x = np.zeros((1, 1024), dtype=int) + assert np.all(kernel.eigenvalues(p) == 0) + np.testing.assert_allclose(kernel.K(p, x), [[1]], atol=1e-11) + np.testing.assert_allclose(kernel.K_diag(p, x), [1], atol=1e-11) + + +def test_phi_product_log_exceeds_linear_range(): + phi = HammingGraph(1024, 20).get_eigenfunctions(600) + x = np.zeros((1, 1024), dtype=int) + log_magnitude, sign = phi.phi_product_log(x, dtype=np.float64) + assert np.isfinite(log_magnitude[0, 0, 599]) + assert log_magnitude[0, 0, 599] > np.log(np.finfo(float).max) + assert sign[0, 0, 599] == 1 + + +def test_random_phase_map_works_on_non_hamming_space(): + space = Circle() + x = np.array([[0.0], [0.3], [1.4]]) + p = params() + fmap = RandomPhaseFeatureMapLogDomain(space, 4, 8) + assert ( + type(default_feature_map(kernel=MaternKarhunenLoeveLogDomain(space, 4))) + is RandomPhaseFeatureMapLogDomain + ) + _, actual = fmap(x, p, key=np.random.RandomState(8), normalize=False) + _, phases = space.random(np.random.RandomState(8), 8) + spectrum = MaternKarhunenLoeveKernel.spectrum( + space.get_eigenvalues(4), p["nu"], p["lengthscale"], space.dimension + ) + expected = ( + fmap.eigenfunctions.phi_product(x, phases) * np.sqrt(spectrum.T) + ).reshape(3, -1) + np.testing.assert_allclose(actual, expected, rtol=1e-12, atol=1e-12) + + +def test_default_hamming_kernel_and_map_use_generic_log_classes(): + space = HammingGraph(8, 4) + kernel, fmap = MaternGeometricKernel(space, num=5, return_feature_map=True) + assert type(kernel) is MaternKarhunenLoeveLogDomain + assert type(fmap) is RandomPhaseFeatureMapLogDomain diff --git a/tests/spaces/test_eigenfunctions.py b/tests/spaces/test_eigenfunctions.py index ffe7b6de..c23ab5ad 100644 --- a/tests/spaces/test_eigenfunctions.py +++ b/tests/spaces/test_eigenfunctions.py @@ -92,6 +92,12 @@ def test_numbers_of_eigenfunctions(inputs): # Check that `num_eigenfunctions_per_level` sum up to the total number of # eigenfunctions. assert num_eigenfunctions_manual == eigenfunctions.num_eigenfunctions + np.testing.assert_allclose( + eigenfunctions.log_num_eigenfunctions_per_level, + np.log(np.asarray(eigenfunctions.num_eigenfunctions_per_level, dtype=float)), + rtol=1e-12, + atol=1e-12, + ) @pytest.mark.parametrize("backend", ["numpy", "tensorflow", "torch", "jax"])