sgptools 1.1.7__py3-none-any.whl → 1.2.0__py3-none-any.whl

sgptools/__init__.py

@@ -12,7 +12,7 @@ The library includes python code for the following:
 
 """
 
-__version__ = "1.1.7"
+__version__ = "1.2.0"
 __author__ = 'Kalvik'
 
 from .models.core import *

sgptools/kernels/__init__.py

@@ -1,7 +1,9 @@
 # sgptools/kernels/__init__.py
 
-"""Special kernel functions in this package:
+"""Special non-stationary kernel functions in this package:
 
-- `neural_kernel`: Provides a neural spectral kernel function that uses a mixture of multilayer perceptrons
+- `neural_kernel`: Provides the neural spectral kernel that uses a mixture of multilayer perceptrons
+- `attentive_kernel`: Provides the attentive kernel that uses a multilayer perceptron to get a mixture of RBF kernels 
+- `neural_network`: Helper class that provides a multilayer perceptron compatible with GPFlow
 
 """

sgptools/kernels/attentive_kernel.py

@@ -0,0 +1,119 @@
+# Copyright 2024 The SGP-Tools Contributors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Attentive Kernel function
+"""
+
+import numpy as np
+import tensorflow as tf
+
+import gpflow
+from gpflow.config import default_float
+float_type = default_float()
+
+from .neural_network import NN
+
+
+class AttentiveKernel(gpflow.kernels.Kernel):
+    """Attentive Kernel function (non-stationary kernel function). 
+    Based on the implementation from this [repo](https://github.com/Weizhe-Chen/attentive_kernels)
+
+    Refer to the following papers for more details:
+        - AK: Attentive Kernel for Information Gathering [Chen et al., 2022]
+
+    Args:
+        lengthscales (List): List of lengthscales to use in the mixture components. The lengthscales are not trained.
+        amplitude (int): Initial amplitude of the kernel function
+        dim_hidden (int): Number of MLP hidden layer nodes (The NN will have two of these layers)
+        num_dim (int): Number of dimensions of the data points
+    """
+    def __init__(self, 
+                 lengthscales, 
+                 dim_hidden=10,
+                 amplitude=1.0,
+                 num_dim=2): 
+        super().__init__()
+        with self.name_scope:
+            self.num_lengthscales = len(lengthscales)
+            self._free_amplitude = tf.Variable(amplitude, 
+                                               shape=[],
+                                               trainable=True,
+                                               dtype=float_type)
+            self.lengthscales = tf.Variable(lengthscales, 
+                                            shape=[self.num_lengthscales], 
+                                            trainable=False,
+                                            dtype=float_type)
+            
+            self.nn = NN([num_dim, dim_hidden, dim_hidden, self.num_lengthscales])
+
+    def get_representations(self, X):
+        Z = self.nn(X)
+        representations = Z / tf.norm(Z, axis=1, keepdims=True)
+        return representations
+
+    def K(self, X, X2=None):
+        """Computes the covariances between/amongst the input variables
+
+        Args:
+            X (ndarray): Variables to compute the covariance matrix
+            X2 (ndarray): If passed, the covariance between X and X2 is computed. Otherwise, 
+                          the covariance between X and X is computed.
+
+        Returns:
+            cov (ndarray): covariance matrix
+        """
+        if X2 is None:
+            X2 = X
+
+        dist = cdist(X, X2)
+        repre1 = self.get_representations(X)
+        repre2 = self.get_representations(X2)
+
+        def get_mixture_component(i):
+            attention_lengthscales = tf.tensordot(repre1[:, i], repre2[:, i], axes=0)
+            cov_mat = rbf(dist, self.lengthscales[i]) * attention_lengthscales   
+            return cov_mat
+        
+        cov_mat = tf.map_fn(fn=get_mixture_component, 
+                            elems=tf.range(self.num_lengthscales, dtype=tf.int64), 
+                            fn_output_signature=dist.dtype)
+        cov_mat = tf.math.reduce_sum(cov_mat, axis=0)
+        attention_inputs = repre1 @ tf.transpose(repre2)
+        cov_mat *= self._free_amplitude * attention_inputs
+
+        return cov_mat
+    
+    def K_diag(self, X):
+        return self._free_amplitude * tf.ones((X.shape[0]), dtype=X.dtype)
+    
+'''
+Helper functions
+'''
+def rbf(dist, lengthscale):
+    '''
+    RBF kernel function
+    '''
+    return tf.math.exp(-0.5 * tf.math.square(dist / lengthscale))
+
+def cdist(x, y):
+    '''
+    Calculate the pairwise euclidean distances
+    '''
+    # Calculate distance for a single row of x.
+    per_x_dist = lambda i : tf.norm(x[i:(i+1),:] - y, axis=1)
+    # Compute and stack distances for all rows of x.
+    dist = tf.map_fn(fn=per_x_dist, 
+                     elems=tf.range(tf.shape(x)[0], dtype=tf.int64), 
+                     fn_output_signature=x.dtype)
+    return dist

sgptools/kernels/neural_kernel.py

@@ -15,25 +15,23 @@
 """Provides a neural spectral kernel function along with an initialization function
 """
 
+import tensorflow as tf
 import numpy as np
 import gc
 
-import tensorflow as tf
-from tensorflow import keras
-from tensorflow.keras import layers
 
 import gpflow
 from gpflow.config import default_jitter, default_float
 from gpflow.models import SGPR
 from gpflow.models.util import data_input_to_tensor
-
-gpflow.config.set_default_float(np.float32)
 float_type = default_float()
 
+from .neural_network import NN
+
 
 class NeuralSpectralKernel(gpflow.kernels.Kernel):
     """Neural Spectral Kernel function (non-stationary kernel function). 
-    Based on the implementation from the following [repo](https://github.com/sremes/nssm-gp/tree/master?tab=readme-ov-file)
+    Based on the implementation from this [repo](https://github.com/sremes/nssm-gp/tree/master?tab=readme-ov-file)
 
     Refer to the following papers for more details:
         - Neural Non-Stationary Spectral Kernel [Remes et al., 2018]
@@ -55,12 +53,12 @@ class NeuralSpectralKernel(gpflow.kernels.Kernel):
         self.length = []
         self.var = []
         for q in range(self.Q):
-            freq = keras.Sequential([layers.Dense(hidden_sizes[i], activation='selu') for i in range(self.num_hidden)] + 
-                                    [layers.Dense(input_dim, activation='softplus')])
-            length = keras.Sequential([layers.Dense(hidden_sizes[i], activation='selu') for i in range(self.num_hidden)] +
-                                   [layers.Dense(input_dim, activation='softplus')])
-            var = keras.Sequential([layers.Dense(hidden_sizes[i], activation='selu') for i in range(self.num_hidden)] +
-                                   [layers.Dense(1, activation='softplus')])
+            freq = NN([input_dim]+[hidden_sizes[i] for i in range(self.num_hidden)]+[input_dim],
+                     output_activation_fn='softplus')
+            length = NN([input_dim]+[hidden_sizes[i] for i in range(self.num_hidden)]+[input_dim],
+                        output_activation_fn='softplus')
+            var = NN([input_dim]+[hidden_sizes[i] for i in range(self.num_hidden)]+[1],
+                     output_activation_fn='softplus')
             self.freq.append(freq)
             self.length.append(length)
             self.var.append(var)
@@ -132,7 +130,7 @@ def robust_kernel(kern, shape_X):
 
 def init_neural_kernel(x, y, inducing_variable, Q, n_inits=1, hidden_sizes=None):
     """Helper function to initialize a Neural Spectral Kernel function (non-stationary kernel function). 
-    Based on the implementation from the following [repo](https://github.com/sremes/nssm-gp/tree/master?tab=readme-ov-file)
+    Based on the implementation from this [repo](https://github.com/sremes/nssm-gp/tree/master?tab=readme-ov-file)
 
     Refer to the following papers for more details:
         - Neural Non-Stationary Spectral Kernel [Remes et al., 2018]
@@ -155,9 +153,9 @@ def init_neural_kernel(x, y, inducing_variable, Q, n_inits=1, hidden_sizes=None)
     for k in range(n_inits):
         # gpflow.reset_default_graph_and_session()
         k = NeuralSpectralKernel(input_dim=input_dim, Q=Q, 
-                                    hidden_sizes=hidden_sizes)
+                                 hidden_sizes=hidden_sizes)
         model = SGPR((x, y), inducing_variable=inducing_variable, 
-                        kernel=k)
+                     kernel=k)
         loglik = model.elbo()
         if loglik > best_loglik:
             best_loglik = loglik

sgptools/kernels/neural_network.py

@@ -0,0 +1,58 @@
+# Copyright 2024 The SGP-Tools Contributors. All Rights Reserved.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+# http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Multi Layer Perceptron Model
+"""
+
+import numpy as np
+import tensorflow as tf
+
+import gpflow
+from gpflow.config import default_float
+float_type = default_float()
+
+def xavier(dim_in, dim_out):
+    return np.random.randn(dim_in, dim_out)*(2./(dim_in+dim_out))**0.5
+
+class NN(gpflow.base.Module):
+    """Multi Layer Perceptron Model that is compatible with GPFlow
+
+    Args:
+        dims (List): List of each layer's size, needs input layer dimensions as well
+        activation_fn (str): Activation function for each layer
+        output_activation_fn (str): Activation function for the last layer
+    """
+    def __init__(self, dims, 
+                 activation_fn='selu', 
+                 output_activation_fn='softmax'):
+        super().__init__()
+        self.dims = dims
+        self.activation_fn = tf.keras.activations.get(activation_fn)
+        self.output_activation_fn = tf.keras.activations.get(output_activation_fn)
+        for i, (dim_in, dim_out) in enumerate(zip(dims[:-1], dims[1:])):
+            setattr(self, 'W_{}'.format(i), tf.Variable(xavier(dim_in, dim_out),
+                                                        dtype=float_type))
+            setattr(self, 'b_{}'.format(i), tf.Variable(np.zeros(dim_out),
+                                                        dtype=float_type))
+
+    def __call__(self, X):
+        if X is not None:
+            for i in range(len(self.dims) - 2):
+                W = getattr(self, 'W_{}'.format(i))
+                b = getattr(self, 'b_{}'.format(i))
+                X = self.activation_fn(tf.matmul(X, W) + b)
+            W = getattr(self, 'W_{}'.format(i+1))
+            b = getattr(self, 'b_{}'.format(i+1))
+            X = self.output_activation_fn(tf.matmul(X, W) + b)
+            return X

sgptools/models/core/augmented_sgpr.py

@@ -79,8 +79,9 @@ class AugmentedSGPR(SGPR):
             kernel (gpflow.kernels.Kernel): gpflow kernel function
         """
         self.likelihood.variance.assign(noise_variance)
-        self.kernel.lengthscales.assign(kernel.lengthscales)
-        self.kernel.variance.assign(kernel.variance)
+        for self_var, var in zip(self.kernel.trainable_variables, 
+                                 kernel.trainable_variables):
+            self_var.assign(var)
 
     def _common_calculation(self) -> "SGPR.CommonTensors":
         """

sgptools/models/core/osgpr.py

@@ -66,21 +66,24 @@ class OSGPR_VFE(GPModel, InternalDataTrainingLossMixin):
         Z = np.vstack((old_Z, new_Z))
         return Z
 
-    def update(self, data, inducing_variable=None):
+    def update(self, data, inducing_variable=None, update_inducing=True):
         """Configure the OSGPR to adapt to a new batch of data. 
         Note: The OSGPR needs to be trained using gradient-based approaches after update.
 
         Args:
             data (tuple): (X, y) ndarrays with new batch of inputs (n, d) and labels (n, ndim)
+            inducing_variable (ndarray): (m_new, d): New initial inducing points
+            update_inducing (bool): Whether to update the inducing points
         """
         self.X, self.Y = self.data = gpflow.models.util.data_input_to_tensor(data)
         self.num_data = self.X.shape[0]
 
         # Update the inducing points        
         self.Z_old.assign(self.inducing_variable.Z.numpy())
-        if inducing_variable is None:
+        if inducing_variable is None and update_inducing:
             inducing_variable = self.init_Z()
-        self.inducing_variable.Z.assign(inducing_variable)
+        if inducing_variable is not None:
+            self.inducing_variable.Z.assign(inducing_variable)
 
         # Get posterior mean and covariance for the old inducing points
         mu_old, Su_old = self.predict_f(self.Z_old, full_cov=True)

{sgptools-1.1.7.dist-info → sgptools-1.2.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.2
 Name: sgptools
-Version: 1.1.7
+Version: 1.2.0
 Summary: Software Suite for Sensor Placement and Informative Path Planning
 Home-page: https://www.itskalvik.com/sgp-tools
 Author: Kalvik
@@ -23,8 +23,17 @@ Requires-Dist: hkb_diamondsquare
 Requires-Dist: tensorflow-probability[tf]>=0.21.0
 Requires-Dist: tensorflow>=2.13.0; platform_machine != "arm64"
 Requires-Dist: tensorflow-aarch64>=2.13.0; platform_machine == "arm64"
+Requires-Dist: tensorflow-macos>=2.13.0; platform_system == "Darwin" and platform_machine == "arm64"
 Requires-Dist: typing_extensions
 Requires-Dist: gpflow>=2.7.0
 Requires-Dist: pillow
+Dynamic: author
+Dynamic: author-email
+Dynamic: description
+Dynamic: home-page
+Dynamic: license
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
 
 Software Suite for Sensor Placement and Informative Path Planning

{sgptools-1.1.7.dist-info → sgptools-1.2.0.dist-info}/RECORD

@@ -1,6 +1,8 @@
-sgptools/__init__.py,sha256=dgJa5rLAj4qD6De6iK-MHAvh7CS7qJkPKrdj5zIXdgY,449
-sgptools/kernels/__init__.py,sha256=zRf4y-wJwjXKt1uOnmI5MbzCA6pRlyA7C-eagLfb3d0,190
-sgptools/kernels/neural_kernel.py,sha256=9XEjcwwi1Gwj4D5cAZwq5QdWqMaI-Vu2DKgYO58DmPg,6709
+sgptools/__init__.py,sha256=qT2hUpWp9XL7o7EnXNf6cxwujPSocrm3i00DrF407Uk,449
+sgptools/kernels/__init__.py,sha256=oNrHUOPJv8WriHeYoNcgfbNb3EFBXC1oitg_37Udf3c,411
+sgptools/kernels/attentive_kernel.py,sha256=crswMpc6t1fy4590R5zwj02ow6-yTSG6o7gMk702Ozg,4434
+sgptools/kernels/neural_kernel.py,sha256=QxFVhd3wmmaPHHE3-fNQzlsD12DxdT6jDp6le1YhuA8,6443
+sgptools/kernels/neural_network.py,sha256=hVr31bnjyXB5h-IGmZoby81BBufqd89zw3Ok7C-C_vE,2367
 sgptools/models/__init__.py,sha256=X2lIg9kf1-2MHUswk-VW2dHHcbSLxf6_IuV7lc_kvDc,682
 sgptools/models/bo.py,sha256=sjs18oRXL-yoNiLoaaoROjaJXqfj_CwouJPe9HgzjL0,4857
 sgptools/models/cma_es.py,sha256=LjWRcUIcARcFvAHR2F8prPDmgxLzYI0kRwYXzKp3APc,4861
@@ -9,8 +11,8 @@ sgptools/models/greedy_mi.py,sha256=06CY6tm9C3iBYEG_DOuQKDmWIww9Ah0rkeJUXsCR2YU,
 sgptools/models/greedy_sgp.py,sha256=giddMbU3ohePTdLTcH4fDx-bS9upq1T_K8KUW_Ag6HI,4490
 sgptools/models/core/__init__.py,sha256=TlUdvrM0A7vSzc5IM8C2Y2kliB1ip7YLEcHHzvuw-C4,482
 sgptools/models/core/augmented_gpr.py,sha256=NuYwlggz7ho7pvW4-so3ghos5vZ8oK7nRZqvHpAt0Zk,3497
-sgptools/models/core/augmented_sgpr.py,sha256=qMP9J4AnOUx9AEZfaPhoyb3RP_2AOhOUCUY4eh7uOi0,7185
-sgptools/models/core/osgpr.py,sha256=fyIRtNGWZeRRuojQJQAxDhMCUTKlmh5mXK3iddrPC8A,12199
+sgptools/models/core/augmented_sgpr.py,sha256=Y9CEENt--RaV611bsDMsOpWrc0bSfemlm3qXV-pSZUs,7233
+sgptools/models/core/osgpr.py,sha256=trUwUOLX82BRY2KyMWFygBQkc2PItxGlWPXaAgOhpE4,12442
 sgptools/models/core/transformations.py,sha256=X7WEKo_lFAYB5HKnFvxFsxfz6CB-jzPfVWcx1sWe2lI,18313
 sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
 sgptools/utils/data.py,sha256=ojDq6KzBXbAl5CdpA6A6me0sg5Sah9ZTl2TpFCqgR4c,7464
@@ -18,8 +20,8 @@ sgptools/utils/gpflow.py,sha256=46-_Tl-suxvuX3Y9KI_uiixfyCWQ2T-7BUn-7hesdVM,1004
 sgptools/utils/metrics.py,sha256=tu8H129n8GuxV5fQIKLcfzPUxd7sp8zEF9qZBOZjNKo,5834
 sgptools/utils/misc.py,sha256=11nsDEU3imnrvH7ywGMiwtNBcBnJfHX3KaGxFS3eq6w,6223
 sgptools/utils/tsp.py,sha256=b1Lx1Pj-sv7siX-f0S6d25C3RtvszCl3IP4QbvBckqY,8151
-sgptools-1.1.7.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.1.7.dist-info/METADATA,sha256=SE-g1VWus5SyoA0PUmEpgHcQ-UX1EUpVXHPSMW1yACU,944
-sgptools-1.1.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sgptools-1.1.7.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.1.7.dist-info/RECORD,,
+sgptools-1.2.0.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.2.0.dist-info/METADATA,sha256=PcvpJgcoDFokeQW0WmXlBMcDYk8dw77FVMLei_P8__M,1205
+sgptools-1.2.0.dist-info/WHEEL,sha256=52BFRY2Up02UkjOa29eZOS2VxUrpPORXg1pkohGGUS8,91
+sgptools-1.2.0.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.2.0.dist-info/RECORD,,

{sgptools-1.1.7.dist-info → sgptools-1.2.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.6.0)
+Generator: setuptools (76.0.0)
 Root-Is-Purelib: true
 Tag: py3-none-any