From 5b4079f2a45fb952a1aae329b080099d5db3a51e Mon Sep 17 00:00:00 2001 From: stoprightthere Date: Mon, 14 Aug 2023 23:23:06 +0300 Subject: [PATCH 01/12] Update requirements.txt Up tfp version Signed-off-by: stoprightthere --- requirements.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/requirements.txt b/requirements.txt index c93b3385..6e93ac51 100644 --- a/requirements.txt +++ b/requirements.txt @@ -3,7 +3,7 @@ torch gpflow gpjax>=0.5.2 tensorflow -tensorflow-probability==0.14.0 +tensorflow-probability==0.20.1 jax jaxlib backends==1.4.32 From 57b2f7b92787e4d472018a6df8a14d5d486029ca Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 15 Aug 2023 08:51:11 +0200 Subject: [PATCH 02/12] Fix dtype problem for graph sampler Signed-off-by: Viacheslav Borovitskiy --- geometric_kernels/sampling/samplers.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index fbeeed26..e08e12de 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -24,7 +24,7 @@ def sample_at(feature_map, s, X: B.Numeric, params, state, key=None) -> Tuple[An num_features = B.shape(features)[-1] - key, random_weights = B.randn(key, B.dtype(features), num_features, s) # [M, S] + key, random_weights = B.randn(key, B.dtype_double(key), num_features, s) # [M, S] random_sample = B.matmul(features, random_weights) # [N, S] From 1551e7c9407d03c1958266165406615e751864b1 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Tue, 15 Aug 2023 09:06:44 +0200 Subject: [PATCH 03/12] Fix dtype problem for graph sampler, attempt #2 Signed-off-by: Viacheslav Borovitskiy --- geometric_kernels/sampling/samplers.py | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index e08e12de..bbe75b54 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -7,6 +7,7 @@ import lab as B from geometric_kernels.types import FeatureMap +from geometric_kernels.lab_extras import dtype_double def sample_at(feature_map, s, X: B.Numeric, params, state, key=None) -> Tuple[Any, Any]: @@ -24,7 +25,7 @@ def sample_at(feature_map, s, X: B.Numeric, params, state, key=None) -> Tuple[An num_features = B.shape(features)[-1] - key, random_weights = B.randn(key, B.dtype_double(key), num_features, s) # [M, S] + key, random_weights = B.randn(key, dtype_double(key), num_features, s) # [M, S] random_sample = B.matmul(features, random_weights) # [N, S] From a9996fc38a2248cf45aaac5a2b08f61657bd8c26 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 15:17:33 +0200 Subject: [PATCH 04/12] Graph space example notebook and various fixes/improvements for the Graph space --- geometric_kernels/kernels/feature_maps.py | 20 +- geometric_kernels/lab_extras/extras.py | 17 + geometric_kernels/lab_extras/jax/extras.py | 23 + geometric_kernels/lab_extras/numpy/extras.py | 23 + .../lab_extras/tensorflow/extras.py | 21 + geometric_kernels/lab_extras/torch/extras.py | 21 + geometric_kernels/sampling/samplers.py | 4 +- geometric_kernels/spaces/graph.py | 6 +- notebooks/graphs.ipynb | 410 ++++++++++++++++++ 9 files changed, 531 insertions(+), 14 deletions(-) create mode 100644 notebooks/graphs.ipynb diff --git a/geometric_kernels/kernels/feature_maps.py b/geometric_kernels/kernels/feature_maps.py index da4e7c8d..4f7819ab 100644 --- a/geometric_kernels/kernels/feature_maps.py +++ b/geometric_kernels/kernels/feature_maps.py @@ -6,7 +6,7 @@ import lab as B from geometric_kernels.kernels import MaternKarhunenLoeveKernel -from geometric_kernels.lab_extras import from_numpy +from geometric_kernels.lab_extras import from_numpy, float_like from geometric_kernels.sampling.probability_densities import ( base_density_sample, hyperbolic_density_sample, @@ -64,8 +64,8 @@ def _map(X: B.Numeric, params, state, **kwargs) -> B.Numeric: eigenfunctions = Phi.__call__(X, **params) # [N, M] _context: Dict[str, str] = {} # no context - features = B.cast(B.dtype(X), eigenfunctions) * B.cast( - B.dtype(X), weights + features = B.cast(float_like(X), eigenfunctions) * B.cast( + float_like(X), weights ) # [N, M] return features, _context @@ -135,11 +135,11 @@ def _map(X: B.Numeric, params, state, key, **kwargs) -> B.Numeric: Phi = state["eigenfunctions"] # X [N, D] - random_phases_b = B.cast(B.dtype(X), from_numpy(X, random_phases)) + random_phases_b = B.cast(float_like(X), from_numpy(X, random_phases)) embedding = B.cast( - B.dtype(X), Phi.phi_product(X, random_phases_b, **params) + float_like(X), Phi.phi_product(X, random_phases_b, **params) ) # [N, O, L] - weights_t = B.cast(B.dtype(X), B.transpose(weights)) + weights_t = B.cast(float_like(X), B.transpose(weights)) features = B.reshape(embedding * weights_t, B.shape(X)[0], -1) # [N, O*L] _context: Dict[str, str] = {"key": key} @@ -208,10 +208,10 @@ def _map(X: B.Numeric, params, state, key, **kwargs) -> B.Numeric: # X [N, D] random_phases_b = B.expand_dims( - B.cast(B.dtype(X), from_numpy(X, random_phases)) + B.cast(float_like(X), from_numpy(X, random_phases)) ) # [1, O, D] random_lambda_b = B.expand_dims( - B.cast(B.dtype(X), from_numpy(X, random_lambda)) + B.cast(float_like(X), from_numpy(X, random_lambda)) ) # [1, O, P] X_b = B.expand_dims(X, axis=-2) # [N, 1, D] @@ -267,10 +267,10 @@ def _map(X: B.Numeric, params, state, key, **kwargs) -> B.Numeric: # X [N, D] random_phases_b = B.expand_dims( - B.cast(B.dtype(X), from_numpy(X, random_phases)) + B.cast(float_like(X), from_numpy(X, random_phases)) ) # [1, O, D] random_lambda_b = B.expand_dims( - B.cast(B.dtype(X), from_numpy(X, random_lambda)) + B.cast(float_like(X), from_numpy(X, random_lambda)) ) # [1, O] X_b = B.expand_dims(X, axis=-2) # [N, 1, D] diff --git a/geometric_kernels/lab_extras/extras.py b/geometric_kernels/lab_extras/extras.py index 970f0f8f..e38be3b4 100644 --- a/geometric_kernels/lab_extras/extras.py +++ b/geometric_kernels/lab_extras/extras.py @@ -94,6 +94,15 @@ def dtype_double(reference): """ +@dispatch +@abstract() +def float_like(reference: B.Numeric): + """ + Return the type of the reference if it is a floating point type. + Otherwise return `double` dtype of a backend based on the reference. + """ + + @dispatch @abstract() def dtype_integer(reference): @@ -169,3 +178,11 @@ def cumsum(a: B.Numeric, axis=None): """ Return cumulative sum (optionally along axis) """ + + +@dispatch +@abstract() +def reciprocal_no_nan(x: B.Numeric): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index 0b8c75ed..52b1fb5f 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -81,6 +81,19 @@ def dtype_double(reference: B.JAXRandomState): # type: ignore return jnp.float64 +@dispatch +def float_like(reference: B.JAXNumeric): + """ + Return the type of the reference if it is a floating point type. + Otherwise return `double` dtype of a backend based on the reference. + """ + reference_dtype = jnp.dtype(reference) + if jnp.issubdtype(reference_dtype, jnp.floating): + return reference_dtype + else: + return jnp.float64 + + @dispatch def dtype_integer(reference: B.JAXRandomState): # type: ignore """ @@ -155,3 +168,13 @@ def cumsum(x: B.JAXNumeric, axis=None): Return cumulative sum (optionally along axis) """ return jnp.cumsum(x, axis=axis) + + +@dispatch +def reciprocal_no_nan(x: B.JAXNumeric): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ + x_is_zero = jnp.equal(x, 0.) + safe_x = jnp.where(x_is_zero, 1., x) + return jnp.where(x_is_zero, 0., jnp.reciprocal(safe_x)) diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 86d22711..8bc10fed 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -68,6 +68,19 @@ def dtype_double(reference: B.NPRandomState): # type: ignore return np.float64 +@dispatch +def float_like(reference: B.NPNumeric): + """ + Return the type of the reference if it is a floating point type. + Otherwise return `double` dtype of a backend based on the reference. + """ + reference_dtype = np.dtype(reference) + if np.issubdtype(reference_dtype, np.floating): + return reference_dtype + else: + return np.float64 + + @dispatch def dtype_integer(reference: B.NPRandomState): # type: ignore """ @@ -144,3 +157,13 @@ def cumsum(a: _Numeric, axis=None): Return cumulative sum (optionally along axis) """ return np.cumsum(a, axis=axis) + + +@dispatch +def reciprocal_no_nan(x: B.NPNumeric): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ + x_is_zero = np.equal(x, 0.) + safe_x = np.where(x_is_zero, 1., x) + return np.where(x_is_zero, 0., np.reciprocal(safe_x)) diff --git a/geometric_kernels/lab_extras/tensorflow/extras.py b/geometric_kernels/lab_extras/tensorflow/extras.py index 557527eb..24f56fa0 100644 --- a/geometric_kernels/lab_extras/tensorflow/extras.py +++ b/geometric_kernels/lab_extras/tensorflow/extras.py @@ -89,6 +89,19 @@ def dtype_double(reference: B.TFRandomState): # type: ignore return tf.float64 +@dispatch +def float_like(reference: B.TFNumeric): + """ + Return the type of the reference if it is a floating point type. + Otherwise return `double` dtype of a backend based on the reference. + """ + reference_dtype = tf.dtype(reference) + if reference_dtype.is_floating: + return reference_dtype + else: + return tf.float64 + + @dispatch def dtype_integer(reference: B.TFRandomState): # type: ignore """ @@ -169,3 +182,11 @@ def cumsum(x: B.TFNumeric, axis=None): Return cumulative sum (optionally along axis) """ return tf.math.cumsum(x, axis=axis) + + +@dispatch +def reciprocal_no_nan(x: B.TFNumeric): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ + return tf.math.reciprocal_no_nan(x) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index 158b938a..4cf310b5 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -95,6 +95,18 @@ def dtype_double(reference: B.TorchRandomState): # type: ignore return torch.double +@dispatch +def float_like(reference: B.TorchNumeric): + """ + Return the type of the reference if it is a floating point type. + Otherwise return `double` dtype of a backend based on the reference. + """ + if torch.is_floating_point(reference): + return torch.dtype(reference) + else: + return torch.float64 + + @dispatch def dtype_integer(reference: B.TorchRandomState): # type: ignore """ @@ -176,3 +188,12 @@ def cumsum(x: B.TorchNumeric, axis=None): Return cumulative sum (optionally along axis) """ return torch.cumsum(x, dim=axis) + + +@dispatch +def reciprocal_no_nan(x: B.TorchNumeric): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ + safe_x = torch.where(x == 0., 1., x) + return torch.where(x == 0, 0., torch.reciprocal(safe_x)) diff --git a/geometric_kernels/sampling/samplers.py b/geometric_kernels/sampling/samplers.py index bbe75b54..877a02c1 100644 --- a/geometric_kernels/sampling/samplers.py +++ b/geometric_kernels/sampling/samplers.py @@ -6,8 +6,8 @@ import lab as B +from geometric_kernels.lab_extras import float_like from geometric_kernels.types import FeatureMap -from geometric_kernels.lab_extras import dtype_double def sample_at(feature_map, s, X: B.Numeric, params, state, key=None) -> Tuple[Any, Any]: @@ -25,7 +25,7 @@ def sample_at(feature_map, s, X: B.Numeric, params, state, key=None) -> Tuple[An num_features = B.shape(features)[-1] - key, random_weights = B.randn(key, dtype_double(key), num_features, s) # [M, S] + key, random_weights = B.randn(key, float_like(X), num_features, s) # [M, S] random_sample = B.matmul(features, random_weights) # [N, S] diff --git a/geometric_kernels/spaces/graph.py b/geometric_kernels/spaces/graph.py index 9efee045..e61c76fa 100644 --- a/geometric_kernels/spaces/graph.py +++ b/geometric_kernels/spaces/graph.py @@ -7,7 +7,9 @@ import lab as B import numpy as np -from geometric_kernels.lab_extras import degree, dtype_integer, eigenpairs, set_value +from geometric_kernels.lab_extras import ( + degree, dtype_integer, eigenpairs, set_value, reciprocal_no_nan +) from geometric_kernels.spaces.base import ( ConvertEigenvectorsToEigenfunctions, DiscreteSpectrumSpace, @@ -53,7 +55,7 @@ def set_laplacian(self, adjacency, normalize_laplacian=False): degree_matrix = degree(adjacency) self._laplacian = degree_matrix - adjacency if normalize_laplacian: - degree_inv_sqrt = B.linear_algebra.pinv(B.sqrt(degree_matrix)) + degree_inv_sqrt = reciprocal_no_nan(B.sqrt(degree_matrix)) self._laplacian = degree_inv_sqrt @ self._laplacian @ degree_inv_sqrt def get_eigensystem(self, num): diff --git a/notebooks/graphs.ipynb b/notebooks/graphs.ipynb new file mode 100644 index 00000000..4c0ab510 --- /dev/null +++ b/notebooks/graphs.ipynb @@ -0,0 +1,410 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Graph Basics\n", + "This notebook shows how define and evaluate kernels on a simple graph. It also shows how to sample from the corresponding Gaussian process prior.\n", + "\n", + "We use the **JAX** backend here." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "id": "N2YCQeyY50Xg" + }, + "outputs": [], + "source": [ + "# To run this in Google Colab, uncomment the following line\n", + "# !pip install \"git+https://github.com/GPflow/GeometricKernels.git\"\n", + "\n", + "# If you want to use a version of the library from a different git branch,\n", + "# say, from the \"devel\" branch, uncomment the line below instedad\n", + "# !pip install \"git+https://github.com/GPflow/GeometricKernels@devel#egg=GeometricKernels\"" + ] + }, + { + "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: Unable to initialize backend 'tpu_driver': NOT_FOUND: Unable to find driver in registry given worker: \n", + "INFO: Unable to initialize backend 'gpu': NOT_FOUND: Could not find registered platform with name: \"cuda\". Available platform names are: Interpreter Host\n", + "INFO: Unable to initialize backend 'tpu': INVALID_ARGUMENT: TpuPlatform is not available.\n", + "WARNING: No GPU/TPU found, falling back to CPU. (Set TF_CPP_MIN_LOG_LEVEL=0 and rerun for more info.)\n", + "INFO: Using numpy backend\n" + ] + } + ], + "source": [ + "import networkx as nx\n", + "import jax.numpy as jnp\n", + "from jax.random import PRNGKey\n", + "import numpy as onp\n", + "import geometric_kernels.jax # using jax as backend for geometric_kernels\n", + "from geometric_kernels.spaces import Graph\n", + "from geometric_kernels.kernels.geometric_kernels import MaternKarhunenLoeveKernel\n", + "from geometric_kernels.kernels.feature_maps import deterministic_feature_map_compact\n", + "from geometric_kernels.sampling import sampler\n", + "\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Create and Visualize a Graph" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "id": "PM1H-As8-KF7" + }, + "outputs": [], + "source": [ + "nx_graph = nx.star_graph(6)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 516 + }, + "id": "-J-2rY-D-rgY", + "outputId": "253b3a3d-c0ab-44c8-b507-5be25418681c", + "scrolled": true + }, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# illustrate graph\n", + "nx.draw(nx_graph, node_color = 'black')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell turns the `nx_graph` created above into a GeometricKernels `Graph` space.\n", + "\n", + "The `normalize_laplacian` parameter controls whether to use the eigenvectors\n", + "of the *unnormalized Laplacian* or the *symmetric normalized Laplacian* as\n", + "features.\n", + "You may want to try both `normalize_laplacian=False` and `normalize_laplacian=True` for your task.\n", + "The former is the default." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "id": "YJXKhf4y-tgV" + }, + "outputs": [], + "source": [ + "G = Graph(jnp.array(nx.to_numpy_array(nx_graph)), normalize_laplacian=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Define a GeometricKernels kernel" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "id": "vEZLgfp7ANV4" + }, + "outputs": [], + "source": [ + "# create a kernel\n", + "kernel = MaternKarhunenLoeveKernel(G, G.num_vertices)\n", + "\n", + "# initialize kernel with reasonable values\n", + "params, state = kernel.init_params_and_state()\n", + "# The following setting of `nu` coresponds to the heat (RBF) kernel\n", + "# for actual Matérn kernels consider finite values of `nu`\n", + "params[\"nu\"] = jnp.array([jnp.inf])\n", + "# Note: the \"reasonable\" range of length scales is different for various graphs\n", + "params[\"lengthscale\"] = jnp.array([2.])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_AxR3xsIbzDA" + }, + "source": [ + "## Define Feature Map and Obtain Two Samples" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "id": "921dJj4WbyoP" + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/vabor112/.local/lib/python3.8/site-packages/jax/_src/numpy/lax_numpy.py:4404: UserWarning: Explicitly requested dtype requested in astype is not available, and will be truncated to dtype float32. To enable more dtypes, set the jax_enable_x64 configuration option or the JAX_ENABLE_X64 shell environment variable. See https://github.com/google/jax#current-gotchas for more.\n", + " lax_internal._check_user_dtype_supported(dtype, \"astype\")\n" + ] + } + ], + "source": [ + "feature_map = deterministic_feature_map_compact(G, kernel)\n", + "\n", + "# introduce random state for reproducibility (optional)\n", + "# `key` is jax's terminology\n", + "key = PRNGKey(1234)\n", + "sample_paths = sampler(feature_map, s=2)\n", + "# new random state is returned along with the samples\n", + "key, samples = sample_paths(jnp.arange(G.num_vertices)[:, None], params, state, key=key)\n", + "\n", + "sample1 = onp.asarray(samples[:, 0])\n", + "sample2 = onp.asarray(samples[:, 1])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "nRzmjQ8rP2Mh" + }, + "source": [ + "## Visualize Kernel, Prior Variance and Two Samples" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "**Important:** the following cell **normalizes** the variances, kernel values and samples, **as if they correspond to a normalized kernel**.\n", + "\n", + "We say that the kernel is normalized if the average of k(\\*, \\*), with \\* running over all nodes, equals 1.\n", + "**By default, the kernel may fail to be normalized.**" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 472 + }, + "id": "v9dQIgYYP4ri", + "outputId": "57c69c80-1fee-4d71-f8e4-083469a6a73a" + }, + "outputs": [], + "source": [ + "highlighted_node = 1 # choosing a fixed node for kernel visualization\n", + "node_ids = jnp.arange(G.num_vertices)[:, None]\n", + "# Get prior variances k(*, *) for * in nodes:\n", + "variance = onp.asarray(kernel.K_diag(params, state, node_ids))\n", + "# Get kernel values k(highlighted_node, *) for * in nodes:\n", + "values = onp.asarray(kernel.K(params, state, jnp.array([[highlighted_node]]),\n", + " node_ids)).flatten()\n", + "\n", + "# Normalize everything\n", + "mean_variance = jnp.mean(variance)\n", + "variance /= mean_variance\n", + "values /= mean_variance\n", + "sample1 /= jnp.sqrt(mean_variance)\n", + "sample2 /= jnp.sqrt(mean_variance)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here are the actual visualization routines.\n", + "\n", + "**Note:** the top right plot shows `k(highlighted_node, *)` where `*` goes through all nodes and `highlighted_node` has red outline. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "cmap = plt.get_cmap('viridis')\n", + "\n", + "# Set the colorbar limits:\n", + "var_vmin = min(0.0, values.min())\n", + "var_vmax = max(1.0, variance.max())\n", + "val_vmin, val_vmax = var_vmin, var_vmax\n", + "val_smax = max(1., val_vmax, onp.abs(sample1.max()), onp.abs(sample2.max()),\n", + " onp.abs(sample1.min()), onp.abs(sample2.min()))\n", + "val_smin = -val_smax\n", + "\n", + "\n", + "# Red outline for the highlighted_node:\n", + "edgecolors = [(0, 0, 0, 0)]*G.num_vertices\n", + "edgecolors[highlighted_node] = (1, 0, 0, 1)\n", + "\n", + "# Save graph layout so that graph appears the same in every plot\n", + "kwargs = {'pos': nx.spring_layout(nx_graph)}\n", + "\n", + "\n", + "fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(2, 2, figsize=(12.8, 9.6))\n", + "\n", + "# Plot variance\n", + "nx.draw(nx_graph, ax=ax1, cmap=cmap, node_color=variance,\n", + " vmin=var_vmin, vmax=var_vmax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=var_vmin, vmax=var_vmax))\n", + "cbar = plt.colorbar(sm, ax=ax1)\n", + "ax1.set_title('Variance: k(*, *) for * in nodes')\n", + "\n", + "# Plot kernel values\n", + "nx.draw(nx_graph, ax=ax2, cmap=cmap, node_color=values,\n", + " vmin=val_vmin, vmax=val_vmax, edgecolors=edgecolors,\n", + " linewidths=2.0, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=val_vmin, vmax=val_vmax))\n", + "cbar = plt.colorbar(sm, ax=ax2)\n", + "ax2.set_title('Kernel: k(%d, *) for * in nodes' % highlighted_node)\n", + "\n", + "# Plot sample #1 values\n", + "nx.draw(nx_graph, ax=ax3, cmap=cmap, node_color=sample1,\n", + " vmin=val_smin, vmax=val_smax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=val_smin, vmax=val_smax))\n", + "cbar = plt.colorbar(sm, ax=ax3)\n", + "ax3.set_title('Sample #1: f(*) for * in nodes where f ~ GP(0, k)')\n", + "\n", + "# Plot sample #2 values\n", + "nx.draw(nx_graph, ax=ax4, cmap=cmap, node_color=sample2,\n", + " vmin=val_smin, vmax=val_smax, **kwargs)\n", + "sm = plt.cm.ScalarMappable(cmap=cmap,\n", + " norm=plt.Normalize(vmin=val_smin, vmax=val_smax))\n", + "cbar = plt.colorbar(sm, ax=ax4)\n", + "ax4.set_title('Sample #2: f(*) for * in nodes where f ~ GP(0, k)')\n", + "\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## A Note on Prior Variance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Note that the **variance changes from node to node** on this graph.\n", + "\n", + "For example, for the **unnormalized Laplacian**, the variance is related to the *return time of a random walk*: how many steps, on average, does it take a particle\n", + "randomly walking over the graph and starting in node x to return back to node x.\n", + "For the center node, the return time is always equal to 2.\n", + "For other nodes, it is always higher.\n", + "Hence the variance in the center is *lower* than in the other nodes.\n", + "\n", + "For the **symmetric normalized Laplacian** the sitation is different.\n", + "\n", + "This argument is inspired by [Borovitskiy et al. (2021)](https://arxiv.org/pdf/2010.15538.pdf)\n", + "See this [Jupyter notebook](https://github.com/spbu-math-cs/Graph-Gaussian-Processes/blob/main/examples/graph_variance.ipynb) for more examples of how variance differs for different graphs." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Variance in the center node is 0.60, variance in the side nodes is 1.07. The average variance is 1.00.\n" + ] + } + ], + "source": [ + "print('Variance in the center node is %0.2f,' % variance[0],\n", + " 'variance in the side nodes is %0.2f.' % variance[1],\n", + " 'The average variance is %0.2f.' % onp.mean(variance))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} From 0df5c995d42a9c2ffa0e2e9c38f7e961097621e8 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 15:18:18 +0200 Subject: [PATCH 05/12] Graph space notebook updated version --- notebooks/graphs.ipynb | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/notebooks/graphs.ipynb b/notebooks/graphs.ipynb index 4c0ab510..d5328fb9 100644 --- a/notebooks/graphs.ipynb +++ b/notebooks/graphs.ipynb @@ -96,7 +96,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -264,7 +264,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] From 2d5cb3e42924b049f31610d9d9da2b422aefe8e3 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 15:28:41 +0200 Subject: [PATCH 06/12] lint fixes --- geometric_kernels/lab_extras/jax/extras.py | 6 +++--- geometric_kernels/lab_extras/numpy/extras.py | 6 +++--- geometric_kernels/lab_extras/torch/extras.py | 4 ++-- 3 files changed, 8 insertions(+), 8 deletions(-) diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index 52b1fb5f..addf54e8 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -175,6 +175,6 @@ def reciprocal_no_nan(x: B.JAXNumeric): """ Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. """ - x_is_zero = jnp.equal(x, 0.) - safe_x = jnp.where(x_is_zero, 1., x) - return jnp.where(x_is_zero, 0., jnp.reciprocal(safe_x)) + x_is_zero = jnp.equal(x, 0.0) + safe_x = jnp.where(x_is_zero, 1.0, x) + return jnp.where(x_is_zero, 0.0, jnp.reciprocal(safe_x)) diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 8bc10fed..97a89f81 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -164,6 +164,6 @@ def reciprocal_no_nan(x: B.NPNumeric): """ Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. """ - x_is_zero = np.equal(x, 0.) - safe_x = np.where(x_is_zero, 1., x) - return np.where(x_is_zero, 0., np.reciprocal(safe_x)) + x_is_zero = np.equal(x, 0.0) + safe_x = np.where(x_is_zero, 1.0, x) + return np.where(x_is_zero, 0.0, np.reciprocal(safe_x)) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index 4cf310b5..9c9a83bd 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -195,5 +195,5 @@ def reciprocal_no_nan(x: B.TorchNumeric): """ Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. """ - safe_x = torch.where(x == 0., 1., x) - return torch.where(x == 0, 0., torch.reciprocal(safe_x)) + safe_x = torch.where(x == 0.0, 1.0, x) + return torch.where(x == 0.0, 0.0, torch.reciprocal(safe_x)) From 9277436fa44bae9f7d6490a1d6c4438ea96052a9 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 15:35:39 +0200 Subject: [PATCH 07/12] More lint fixes --- geometric_kernels/spaces/graph.py | 6 +++++- 1 file changed, 5 insertions(+), 1 deletion(-) diff --git a/geometric_kernels/spaces/graph.py b/geometric_kernels/spaces/graph.py index e61c76fa..b076afe2 100644 --- a/geometric_kernels/spaces/graph.py +++ b/geometric_kernels/spaces/graph.py @@ -8,7 +8,11 @@ import numpy as np from geometric_kernels.lab_extras import ( - degree, dtype_integer, eigenpairs, set_value, reciprocal_no_nan + degree, + dtype_integer, + eigenpairs, + set_value, + reciprocal_no_nan, ) from geometric_kernels.spaces.base import ( ConvertEigenvectorsToEigenfunctions, From 00573f7bbe98f0d12c729db38e75ccc904e5de3b Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 15:41:58 +0200 Subject: [PATCH 08/12] More lint fixes --- geometric_kernels/kernels/feature_maps.py | 2 +- geometric_kernels/spaces/graph.py | 2 +- 2 files changed, 2 insertions(+), 2 deletions(-) diff --git a/geometric_kernels/kernels/feature_maps.py b/geometric_kernels/kernels/feature_maps.py index 4f7819ab..881ab0b8 100644 --- a/geometric_kernels/kernels/feature_maps.py +++ b/geometric_kernels/kernels/feature_maps.py @@ -6,7 +6,7 @@ import lab as B from geometric_kernels.kernels import MaternKarhunenLoeveKernel -from geometric_kernels.lab_extras import from_numpy, float_like +from geometric_kernels.lab_extras import float_like, from_numpy from geometric_kernels.sampling.probability_densities import ( base_density_sample, hyperbolic_density_sample, diff --git a/geometric_kernels/spaces/graph.py b/geometric_kernels/spaces/graph.py index b076afe2..645ad933 100644 --- a/geometric_kernels/spaces/graph.py +++ b/geometric_kernels/spaces/graph.py @@ -11,8 +11,8 @@ degree, dtype_integer, eigenpairs, - set_value, reciprocal_no_nan, + set_value, ) from geometric_kernels.spaces.base import ( ConvertEigenvectorsToEigenfunctions, From f799178d0b50d21696aa9e9ce498ea8badeb8588 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Tue, 15 Aug 2023 16:04:51 +0200 Subject: [PATCH 09/12] float_like fix --- geometric_kernels/lab_extras/jax/extras.py | 2 +- geometric_kernels/lab_extras/numpy/extras.py | 2 +- geometric_kernels/lab_extras/tensorflow/extras.py | 2 +- 3 files changed, 3 insertions(+), 3 deletions(-) diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index addf54e8..99d84bc3 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -87,7 +87,7 @@ def float_like(reference: B.JAXNumeric): Return the type of the reference if it is a floating point type. Otherwise return `double` dtype of a backend based on the reference. """ - reference_dtype = jnp.dtype(reference) + reference_dtype = reference.dtype if jnp.issubdtype(reference_dtype, jnp.floating): return reference_dtype else: diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 97a89f81..b4be60df 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -74,7 +74,7 @@ def float_like(reference: B.NPNumeric): Return the type of the reference if it is a floating point type. Otherwise return `double` dtype of a backend based on the reference. """ - reference_dtype = np.dtype(reference) + reference_dtype = reference.dtype if np.issubdtype(reference_dtype, np.floating): return reference_dtype else: diff --git a/geometric_kernels/lab_extras/tensorflow/extras.py b/geometric_kernels/lab_extras/tensorflow/extras.py index 24f56fa0..09d6a4f0 100644 --- a/geometric_kernels/lab_extras/tensorflow/extras.py +++ b/geometric_kernels/lab_extras/tensorflow/extras.py @@ -95,7 +95,7 @@ def float_like(reference: B.TFNumeric): Return the type of the reference if it is a floating point type. Otherwise return `double` dtype of a backend based on the reference. """ - reference_dtype = tf.dtype(reference) + reference_dtype = reference.dtype if reference_dtype.is_floating: return reference_dtype else: From 365ac36328114bb9ade5c056ef251cd9690e7a7e Mon Sep 17 00:00:00 2001 From: vabor112 Date: Wed, 16 Aug 2023 09:49:51 +0200 Subject: [PATCH 10/12] Fixes: dtypes and handling sparse matrices --- geometric_kernels/lab_extras/extras.py | 3 ++- geometric_kernels/lab_extras/jax/extras.py | 2 +- geometric_kernels/lab_extras/numpy/extras.py | 8 ++++++++ geometric_kernels/lab_extras/torch/extras.py | 2 +- 4 files changed, 12 insertions(+), 3 deletions(-) diff --git a/geometric_kernels/lab_extras/extras.py b/geometric_kernels/lab_extras/extras.py index e38be3b4..e6bebd03 100644 --- a/geometric_kernels/lab_extras/extras.py +++ b/geometric_kernels/lab_extras/extras.py @@ -4,6 +4,7 @@ from lab import dispatch from lab.util import abstract from plum import Union +from scipy.sparse import spmatrix @dispatch @@ -182,7 +183,7 @@ def cumsum(a: B.Numeric, axis=None): @dispatch @abstract() -def reciprocal_no_nan(x: B.Numeric): +def reciprocal_no_nan(x: Union[B.Numeric, spmatrix]): """ Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. """ diff --git a/geometric_kernels/lab_extras/jax/extras.py b/geometric_kernels/lab_extras/jax/extras.py index 99d84bc3..5ed52121 100644 --- a/geometric_kernels/lab_extras/jax/extras.py +++ b/geometric_kernels/lab_extras/jax/extras.py @@ -89,7 +89,7 @@ def float_like(reference: B.JAXNumeric): """ reference_dtype = reference.dtype if jnp.issubdtype(reference_dtype, jnp.floating): - return reference_dtype + return B.dtype(reference) else: return jnp.float64 diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index b4be60df..81e60c98 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -4,6 +4,7 @@ import numpy as np from lab import dispatch from plum import Union +from scipy.sparse import spmatrix _Numeric = Union[B.Number, B.NPNumeric] @@ -167,3 +168,10 @@ def reciprocal_no_nan(x: B.NPNumeric): x_is_zero = np.equal(x, 0.0) safe_x = np.where(x_is_zero, 1.0, x) return np.where(x_is_zero, 0.0, np.reciprocal(safe_x)) + +@dispatch +def reciprocal_no_nan(x: spmatrix): + """ + Return element-wise reciprocal (1/x). Whenever x = 0 puts 1/x = 0. + """ + return x._with_data(reciprocal_no_nan(x._deduped_data().copy()), copy=True) diff --git a/geometric_kernels/lab_extras/torch/extras.py b/geometric_kernels/lab_extras/torch/extras.py index 9c9a83bd..d5df171e 100644 --- a/geometric_kernels/lab_extras/torch/extras.py +++ b/geometric_kernels/lab_extras/torch/extras.py @@ -102,7 +102,7 @@ def float_like(reference: B.TorchNumeric): Otherwise return `double` dtype of a backend based on the reference. """ if torch.is_floating_point(reference): - return torch.dtype(reference) + return B.dtype(reference) else: return torch.float64 From a20120371829344a0db0eb1dcfe5d50a73a403e5 Mon Sep 17 00:00:00 2001 From: vabor112 Date: Wed, 16 Aug 2023 09:57:33 +0200 Subject: [PATCH 11/12] Lint fixes --- geometric_kernels/lab_extras/numpy/extras.py | 1 + 1 file changed, 1 insertion(+) diff --git a/geometric_kernels/lab_extras/numpy/extras.py b/geometric_kernels/lab_extras/numpy/extras.py index 81e60c98..df2828fc 100644 --- a/geometric_kernels/lab_extras/numpy/extras.py +++ b/geometric_kernels/lab_extras/numpy/extras.py @@ -169,6 +169,7 @@ def reciprocal_no_nan(x: B.NPNumeric): safe_x = np.where(x_is_zero, 1.0, x) return np.where(x_is_zero, 0.0, np.reciprocal(safe_x)) + @dispatch def reciprocal_no_nan(x: spmatrix): """ From e5503d2605fdf49b8d94b19500127e697ec78c85 Mon Sep 17 00:00:00 2001 From: Viacheslav Borovitskiy Date: Wed, 23 Aug 2023 21:27:24 +0200 Subject: [PATCH 12/12] Change default nu from 0.5 to inf Signed-off-by: Viacheslav Borovitskiy --- geometric_kernels/kernels/geometric_kernels.py | 6 +++--- 1 file changed, 3 insertions(+), 3 deletions(-) diff --git a/geometric_kernels/kernels/geometric_kernels.py b/geometric_kernels/kernels/geometric_kernels.py index 03eacd82..4e26826c 100644 --- a/geometric_kernels/kernels/geometric_kernels.py +++ b/geometric_kernels/kernels/geometric_kernels.py @@ -61,7 +61,7 @@ def init_params_and_state(self): :return: tuple(params, state) """ - params = dict(lengthscale=np.array(1.0), nu=np.array(0.5)) + params = dict(lengthscale=np.array(1.0), nu=np.array(np.inf)) eigenvalues_laplacian = self.space.get_eigenvalues(self.num_eigenfunctions) eigenfunctions = self.space.get_eigenfunctions(self.num_eigenfunctions) @@ -162,7 +162,7 @@ def __init__(self, space: Space, feature_map, key): self.feature_map = make_deterministic(feature_map, key) def init_params_and_state(self): - params = dict(nu=np.array(0.5), lengthscale=np.array(1.0)) + params = dict(nu=np.array(np.inf), lengthscale=np.array(1.0)) state = dict() return params, state @@ -218,7 +218,7 @@ def init_params_and_state(self): :return: tuple(params, state) """ - params = dict(lengthscale=1.0, nu=0.5) + params = dict(lengthscale=1.0, nu=np.inf) state = dict() return params, state