sgptools 1.1.7__tar.gz → 1.2.0__tar.gz

{sgptools-1.1.7 → sgptools-1.2.0}/PKG-INFO

@@ -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 → sgptools-1.2.0}/README.md

@@ -3,7 +3,7 @@
 </div>
 
 # SGP-based Optimization Tools
-Software Suite for [Sensor Placement](https://itskalvik.com/publication/sgp-sp) (SP) and [Informative Path Planning](https://itskalvik.com/publication/sgp-ipp) (IPP). 
+Software Suite for [Sensor Placement](https://www.itskalvik.com/research/publication/sgp-sp/) (SP) and [Informative Path Planning](https://www.itskalvik.com/research/publication/sgp-ipp/) (IPP). 
 
 The library includes python code for the following:
 - Greedy algorithm-based approaches
@@ -56,7 +56,9 @@ Please refer to the [examples](https://www.itskalvik.com/sgp-tools/examples/IPP.
     - `obstacles.ipynb`: SP in an environment with obstacles
 - `sgptools/`: SGP-Tools library
     - `kernels/`: Kernel functions
+        - `attentive_kernel.py`: Attentive Kernel (Non-Stationary Kernel)
         - `neural_kernel.py`: Neural Non-Stationary Spectral Kernel
+        - `neural_network.py`: GPFlow compatible Neural Network
     - `models/`: Sensor placement and IPP methods
         - `core/`: GP/SGP models used for sensor placement and IPP
             - `augmented_gpr.py`: GPflow's GP that supports transforms (expansion and aggregation)
@@ -91,7 +93,7 @@ AUTHOR={Kalvik Jakkala and Srinivas Akella},
 TITLE={Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces},
 NOTE= {Preprint},
 YEAR={2023},
-URL={https://itskalvik.github.io/publication/sgp-sp},
+URL={https://www.itskalvik.com/research/publication/sgp-sp/},
 }
 
 @inproceedings{JakkalaA24IPP,
@@ -100,7 +102,16 @@ TITLE={Multi-Robot Informative Path Planning from Regression with Sparse Gaussia
 booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
 YEAR={2024},
 PUBLISHER = {{IEEE}},
-URL={https://itskalvik.github.io/publication/sgp-ipp}
+URL={https://www.itskalvik.com/research/publication/sgp-ipp/}
+}
+
+@inproceedings{JakkalaA25AIPP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Fully Differentiable Adaptive Informative Path Planning},
+booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
+YEAR={2025},
+PUBLISHER = {{IEEE}},
+URL={https://www.itskalvik.com/research/publication/sgp-aipp/}
 }
 ``` 
 

{sgptools-1.1.7 → sgptools-1.2.0}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-__version__ = "1.1.7"
+__version__ = "1.2.0"
 
 setup(
     name='sgptools',
@@ -28,6 +28,7 @@ setup(
                       'tensorflow-probability[tf]>=0.21.0',
                       'tensorflow>=2.13.0; platform_machine!="arm64"',
                       'tensorflow-aarch64>=2.13.0; platform_machine=="arm64"',
+                      'tensorflow-macos>=2.13.0; platform_system=="Darwin" and platform_machine=="arm64"',
                       'typing_extensions',
                       'gpflow>=2.7.0',
                       'pillow'

{sgptools-1.1.7 → sgptools-1.2.0}/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-1.2.0/sgptools/kernels/__init__.py

@@ -0,0 +1,9 @@
+# sgptools/kernels/__init__.py
+
+"""Special non-stationary kernel functions in this package:
+
+- `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-1.2.0/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-1.1.7 → sgptools-1.2.0}/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-1.2.0/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-1.1.7 → sgptools-1.2.0}/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-1.1.7 → sgptools-1.2.0}/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 → sgptools-1.2.0}/sgptools.egg-info/PKG-INFO

@@ -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 → sgptools-1.2.0}/sgptools.egg-info/SOURCES.txt

@@ -8,7 +8,9 @@ sgptools.egg-info/dependency_links.txt
 sgptools.egg-info/requires.txt
 sgptools.egg-info/top_level.txt
 sgptools/kernels/__init__.py
+sgptools/kernels/attentive_kernel.py
 sgptools/kernels/neural_kernel.py
+sgptools/kernels/neural_network.py
 sgptools/models/__init__.py
 sgptools/models/bo.py
 sgptools/models/cma_es.py

{sgptools-1.1.7 → sgptools-1.2.0}/sgptools.egg-info/requires.txt

@@ -20,3 +20,6 @@ tensorflow>=2.13.0
 
 [:platform_machine == "arm64"]
 tensorflow-aarch64>=2.13.0
+
+[:platform_system == "Darwin" and platform_machine == "arm64"]
+tensorflow-macos>=2.13.0

sgptools-1.1.7/sgptools/kernels/__init__.py

@@ -1,7 +0,0 @@
-# sgptools/kernels/__init__.py
-
-"""Special kernel functions in this package:
-
-- `neural_kernel`: Provides a neural spectral kernel function that uses a mixture of multilayer perceptrons
-
-"""