sgptools 1.2.0__tar.gz → 2.0.0__tar.gz

sgptools-2.0.0/PKG-INFO

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: sgptools
+Version: 2.0.0
+Summary: A Python library for efficient sensor placement and informative path planning
+Home-page: https://www.SGP-Tools.com
+Author: Kalvik
+Author-email: itskalvik@gmail.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+License-File: LICENSE.txt
+Requires-Dist: apricot-select
+Requires-Dist: matplotlib
+Requires-Dist: pandas
+Requires-Dist: scikit-learn
+Requires-Dist: scipy
+Requires-Dist: numpy<2.0.0
+Requires-Dist: ortools
+Requires-Dist: scikit-image
+Requires-Dist: shapely
+Requires-Dist: cma
+Requires-Dist: bayesian-optimization
+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
+Requires-Dist: geopandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="docs/assets/SGP-Tools.png#gh-light-mode-only" alt="SGP-Tools Logo" width="600"/>
+  <img src="docs/assets/logo_dark.png#gh-dark-mode-only" alt="SGP-Tools Logo" width="600"/>
+</p>
+
+<p align="center">
+  <em>A Python library for efficient sensor placement and informative path planning</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/sgptools/"><img alt="PyPI" src="https://img.shields.io/pypi/v/sgptools.svg"></a>
+  <a href="https://github.com/itskalvik/sgptools/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/sgptools.svg"></a>
+</p>
+
+<p align="center">
+  <img src="docs/assets/point_sensing.gif" width="49%">
+  <img src="docs/assets/non-point_sensing.gif" width="49%">
+  <img src="docs/assets/AIPP-4R.gif" width="49%">
+  <img src="docs/assets/AIPP-non-point_sensing.gif" width="49%">
+</p>
+
+## What is SGP-Tools?
+
+**SGP-Tools** is a powerful and flexible Python library designed for solving **Sensor Placement** and **Informative Path Planning** problems, enabling efficient and scalable solutions for environment monitoring, e.g., monitoring air/water quality, soil moisture, or temperature.
+
+### Sensor Placement
+
+**Sensor Placement** is the problem of finding ideal locations to deploy a set of static sensors to best monitor a spatial phenomenon. The goal is to select a finite number of locations from a continuous space or a discrete set of candidates to maximize the information gathered about an entire area of interest. This is crucial when deploying a limited number of sensors to cover a large field.
+
+### Informative Path Planning (IPP)
+
+**Informative Path Planning** extends this concept to mobile sensors. Instead of finding static locations, IPP aims to compute an informative path for one or more robots to travel along. The path is designed to maximize information gain about the environment, often while adhering to constraints such as a limited travel distance. This is essential for applications like aerial surveying or robotic exploration.
+
+### IPP vs. Lawnmower Paths
+
+A common approach to surveying an area is to use a "lawnmower" path, a simple back-and-forth pattern designed for complete coverage. The following table summarizes the key differences between IPP and Lawnmower Paths:
+
+| Factor | Lawnmower Path | Informative Path Planning (IPP) |
+| :--- | :--- | :--- |
+| **Primary Goal** | Complete and uniform coverage of a predefined area. | Targeted data collection in areas of high information or uncertainty. |
+| **Performance** | Slow data collection but provides a high accuracy reconstruction of the envionment. | Fast data collection but provides an approximate reconstruction of the envionment. |
+| **Prior Knowledge** | Not required; often used when no prior information is available. | Beneficial, but not required for adaptiev IPP; uses prior information to guide the sampling strategy. |
+| **Adaptability** | Non-adaptive; the path is fixed before the mission starts. | Highly adaptive; the path is updated in real-time based on sensor data. |
+| **Efficiency** | Can be inefficient if the phenomenon of interest is sparse. | Highly efficient for sparse or spatially variable phenomena. |
+| **Computational Cost** | Low; simple to plan and execute. | Medium; requires onboard processing to analyze data and update the path. |
+| **Best For** | Baseline mapping, homogenous environments, initial surveys. | Dynamic phenomena, resource-constrained missions. |
+
+## Why SGP-Tools?
+
+-   **State-of-the-Art Algorithms**: Includes a variety of optimization methods including greedy algorithms, Bayesian optimization, CMA-ES, and SGP-based optimization.
+-   **Advanced Modeling Capabilities**: Go beyond simple point sensing with tools for informative path planning for multi-robot systems and complex sensor field-of-view (FoV) models.
+-   **Non-Stationary Kernels**: Capture complex, real-world phenomena with specialized non-stationary kernels like the Neural Spectral Kernel and the Attentive Kernel.
+-   **Flexible and Extensible**: Built on GPflow and TensorFlow, the library is designed to be modular and easy to extend with your own custom methods, kernels, and objectives.
+
+## Installation
+The library is available as a ```pip``` package. To install the package, run the following command:
+
+```
+python3 -m pip install sgptools
+```
+
+Installation from source:
+
+```
+git clone https://github.com/itskalvik/sgp-tools.git
+cd sgp-tools/
+python3 -m pip install -r requirements.txt
+python3 -m pip install -e .
+```
+
+Note: The requirements.txt file contains packages and their latest versions that were last verified to be working without any issues.
+
+## Quick Start
+
+Here's an example of how to use SGP-Tools to get an informative path using the `ContinuousSGP` method:
+
+```python
+from sgptools.utils.data import Dataset # Class for loading and managing datasets
+from sgptools.utils.misc import get_inducing_pts # Utility for selecting inducing points
+from sgptools.utils.tsp import run_tsp # TSP/VRP solver for initial path planning
+from sgptools.utils.gpflow import get_model_params # For training initial GP/SGP hyperparameters
+from sgptools.methods import get_method # Gets the class for continuous SGP optimization
+from sgptools.core.transformations import IPPTransform # Transforms for IPP
+
+# 1. Load or generate a dataset
+# This will create a synthetic dataset for demonstration
+dataset = Dataset(num_train=500, num_test=10000, 
+                  shape=(100, 100))
+X_train, y_train = dataset.get_train()
+X_test, y_test = dataset.get_test()
+
+# 2. Learn the GP hyperparameters from the training data
+print("Learning GP hyperparameters...")
+_, noise_variance, kernel = get_model_params(
+    X_train, y_train, max_steps=1000, verbose=True
+)
+
+# 3. Setup the IPP model
+num_placements = 15
+
+# Initialize inducing points and get initial path
+Xu_init = get_inducing_pts(X_train, num_placements)
+Xu_init, _ = run_tsp(Xu_init, time_limit=10)
+
+# Setup IPP transform with a sampling rate for continuous sensing
+transform_continuous_sensing = IPPTransform(sampling_rate=4)
+
+# Initialize the ContinuousSGP model
+method = get_method('ContinuousSGP')
+csgp_optimizer = method(
+    num_placements, 
+    X_train, 
+    kernel,
+    noise_variance, 
+    transform_continuous_sensing,
+    X_init=Xu_init[0]
+)
+
+# 4. Run the optimization
+print("Optimizing sensor placements...")
+solution_path = csgp_optimizer.optimize(max_steps=200)
+
+print(f"Solution Path: {solution_path}")
+```
+
+<p align="center">
+  <img src="docs/assets/quick_start.png" width="600">
+</p>
+
+For more detailed instructions, please refer to our [tutorials](http://sgp-tools.com/tutorials/index.html)
+
+## SGP-based IPP
+[![Video Summary](https://res.cloudinary.com/marcomontalbano/image/upload/v1713536416/video_to_markdown/images/youtube--G-RKFa1vNHM-c05b58ac6eb4c4700831b2b3070cd403.jpg)](https://www.youtube.com/embed/G-RKFa1vNHM?si=PLmrmkCwXRj7mc4A "Video Summary")
+
+## Datasets
+High-resolution topography and bathymetry data can be downloaded from [NOAA Digital Coast](https://coast.noaa.gov/digitalcoast/)
+
+## About
+Please consider citing the following papers if you use SGP-Tools in your academic work 😄
+
+```
+@misc{JakkalaA23SP,
+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://www.itskalvik.com/research/publication/sgp-sp/},
+}
+
+@inproceedings{JakkalaA24IPP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Multi-Robot Informative Path Planning from Regression with Sparse Gaussian Processes},
+booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
+YEAR={2024},
+PUBLISHER = {{IEEE}},
+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/}
+}
+``` 
+
+## Acknowledgements
+This work was funded in part by the UNC Charlotte Office of Research and Economic Development and by NSF under Award Number IIP-1919233.

sgptools-2.0.0/README.md

@@ -0,0 +1,170 @@
+<p align="center">
+  <img src="docs/assets/SGP-Tools.png#gh-light-mode-only" alt="SGP-Tools Logo" width="600"/>
+  <img src="docs/assets/logo_dark.png#gh-dark-mode-only" alt="SGP-Tools Logo" width="600"/>
+</p>
+
+<p align="center">
+  <em>A Python library for efficient sensor placement and informative path planning</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/sgptools/"><img alt="PyPI" src="https://img.shields.io/pypi/v/sgptools.svg"></a>
+  <a href="https://github.com/itskalvik/sgptools/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/sgptools.svg"></a>
+</p>
+
+<p align="center">
+  <img src="docs/assets/point_sensing.gif" width="49%">
+  <img src="docs/assets/non-point_sensing.gif" width="49%">
+  <img src="docs/assets/AIPP-4R.gif" width="49%">
+  <img src="docs/assets/AIPP-non-point_sensing.gif" width="49%">
+</p>
+
+## What is SGP-Tools?
+
+**SGP-Tools** is a powerful and flexible Python library designed for solving **Sensor Placement** and **Informative Path Planning** problems, enabling efficient and scalable solutions for environment monitoring, e.g., monitoring air/water quality, soil moisture, or temperature.
+
+### Sensor Placement
+
+**Sensor Placement** is the problem of finding ideal locations to deploy a set of static sensors to best monitor a spatial phenomenon. The goal is to select a finite number of locations from a continuous space or a discrete set of candidates to maximize the information gathered about an entire area of interest. This is crucial when deploying a limited number of sensors to cover a large field.
+
+### Informative Path Planning (IPP)
+
+**Informative Path Planning** extends this concept to mobile sensors. Instead of finding static locations, IPP aims to compute an informative path for one or more robots to travel along. The path is designed to maximize information gain about the environment, often while adhering to constraints such as a limited travel distance. This is essential for applications like aerial surveying or robotic exploration.
+
+### IPP vs. Lawnmower Paths
+
+A common approach to surveying an area is to use a "lawnmower" path, a simple back-and-forth pattern designed for complete coverage. The following table summarizes the key differences between IPP and Lawnmower Paths:
+
+| Factor | Lawnmower Path | Informative Path Planning (IPP) |
+| :--- | :--- | :--- |
+| **Primary Goal** | Complete and uniform coverage of a predefined area. | Targeted data collection in areas of high information or uncertainty. |
+| **Performance** | Slow data collection but provides a high accuracy reconstruction of the envionment. | Fast data collection but provides an approximate reconstruction of the envionment. |
+| **Prior Knowledge** | Not required; often used when no prior information is available. | Beneficial, but not required for adaptiev IPP; uses prior information to guide the sampling strategy. |
+| **Adaptability** | Non-adaptive; the path is fixed before the mission starts. | Highly adaptive; the path is updated in real-time based on sensor data. |
+| **Efficiency** | Can be inefficient if the phenomenon of interest is sparse. | Highly efficient for sparse or spatially variable phenomena. |
+| **Computational Cost** | Low; simple to plan and execute. | Medium; requires onboard processing to analyze data and update the path. |
+| **Best For** | Baseline mapping, homogenous environments, initial surveys. | Dynamic phenomena, resource-constrained missions. |
+
+## Why SGP-Tools?
+
+-   **State-of-the-Art Algorithms**: Includes a variety of optimization methods including greedy algorithms, Bayesian optimization, CMA-ES, and SGP-based optimization.
+-   **Advanced Modeling Capabilities**: Go beyond simple point sensing with tools for informative path planning for multi-robot systems and complex sensor field-of-view (FoV) models.
+-   **Non-Stationary Kernels**: Capture complex, real-world phenomena with specialized non-stationary kernels like the Neural Spectral Kernel and the Attentive Kernel.
+-   **Flexible and Extensible**: Built on GPflow and TensorFlow, the library is designed to be modular and easy to extend with your own custom methods, kernels, and objectives.
+
+## Installation
+The library is available as a ```pip``` package. To install the package, run the following command:
+
+```
+python3 -m pip install sgptools
+```
+
+Installation from source:
+
+```
+git clone https://github.com/itskalvik/sgp-tools.git
+cd sgp-tools/
+python3 -m pip install -r requirements.txt
+python3 -m pip install -e .
+```
+
+Note: The requirements.txt file contains packages and their latest versions that were last verified to be working without any issues.
+
+## Quick Start
+
+Here's an example of how to use SGP-Tools to get an informative path using the `ContinuousSGP` method:
+
+```python
+from sgptools.utils.data import Dataset # Class for loading and managing datasets
+from sgptools.utils.misc import get_inducing_pts # Utility for selecting inducing points
+from sgptools.utils.tsp import run_tsp # TSP/VRP solver for initial path planning
+from sgptools.utils.gpflow import get_model_params # For training initial GP/SGP hyperparameters
+from sgptools.methods import get_method # Gets the class for continuous SGP optimization
+from sgptools.core.transformations import IPPTransform # Transforms for IPP
+
+# 1. Load or generate a dataset
+# This will create a synthetic dataset for demonstration
+dataset = Dataset(num_train=500, num_test=10000, 
+                  shape=(100, 100))
+X_train, y_train = dataset.get_train()
+X_test, y_test = dataset.get_test()
+
+# 2. Learn the GP hyperparameters from the training data
+print("Learning GP hyperparameters...")
+_, noise_variance, kernel = get_model_params(
+    X_train, y_train, max_steps=1000, verbose=True
+)
+
+# 3. Setup the IPP model
+num_placements = 15
+
+# Initialize inducing points and get initial path
+Xu_init = get_inducing_pts(X_train, num_placements)
+Xu_init, _ = run_tsp(Xu_init, time_limit=10)
+
+# Setup IPP transform with a sampling rate for continuous sensing
+transform_continuous_sensing = IPPTransform(sampling_rate=4)
+
+# Initialize the ContinuousSGP model
+method = get_method('ContinuousSGP')
+csgp_optimizer = method(
+    num_placements, 
+    X_train, 
+    kernel,
+    noise_variance, 
+    transform_continuous_sensing,
+    X_init=Xu_init[0]
+)
+
+# 4. Run the optimization
+print("Optimizing sensor placements...")
+solution_path = csgp_optimizer.optimize(max_steps=200)
+
+print(f"Solution Path: {solution_path}")
+```
+
+<p align="center">
+  <img src="docs/assets/quick_start.png" width="600">
+</p>
+
+For more detailed instructions, please refer to our [tutorials](http://sgp-tools.com/tutorials/index.html)
+
+## SGP-based IPP
+[![Video Summary](https://res.cloudinary.com/marcomontalbano/image/upload/v1713536416/video_to_markdown/images/youtube--G-RKFa1vNHM-c05b58ac6eb4c4700831b2b3070cd403.jpg)](https://www.youtube.com/embed/G-RKFa1vNHM?si=PLmrmkCwXRj7mc4A "Video Summary")
+
+## Datasets
+High-resolution topography and bathymetry data can be downloaded from [NOAA Digital Coast](https://coast.noaa.gov/digitalcoast/)
+
+## About
+Please consider citing the following papers if you use SGP-Tools in your academic work 😄
+
+```
+@misc{JakkalaA23SP,
+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://www.itskalvik.com/research/publication/sgp-sp/},
+}
+
+@inproceedings{JakkalaA24IPP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Multi-Robot Informative Path Planning from Regression with Sparse Gaussian Processes},
+booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
+YEAR={2024},
+PUBLISHER = {{IEEE}},
+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/}
+}
+``` 
+
+## Acknowledgements
+This work was funded in part by the UNC Charlotte Office of Research and Economic Development and by NSF under Award Number IIP-1919233.

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

@@ -1,18 +1,22 @@
 from setuptools import setup, find_packages
 
-__version__ = "1.2.0"
+__version__ = "2.0.0"
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
 
 setup(
     name='sgptools',
     version=__version__,
     packages=find_packages(),
     python_requires='>=3.6',
-    url='https://www.itskalvik.com/sgp-tools',
+    url='https://www.SGP-Tools.com',
     license='Apache-2.0',
     author_email='itskalvik@gmail.com',
     author='Kalvik',
-    description='Software Suite for Sensor Placement and Informative Path Planning',
-    long_description='Software Suite for Sensor Placement and Informative Path Planning',
+    description='A Python library for efficient sensor placement and informative path planning',
+    long_description=long_description,
+    long_description_content_type="text/markdown",
     install_requires=['apricot-select',
                       'matplotlib',
                       'pandas',
@@ -31,6 +35,12 @@ setup(
                       'tensorflow-macos>=2.13.0; platform_system=="Darwin" and platform_machine=="arm64"',
                       'typing_extensions',
                       'gpflow>=2.7.0',
-                      'pillow'
-                     ]
+                      'pillow',
+                      'geopandas'
+                     ],
+        classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: Apache Software License",
+        "Operating System :: OS Independent",
+    ]        
 )

{sgptools-1.2.0 → sgptools-2.0.0}/sgptools/__init__.py

@@ -1,5 +1,4 @@
 """
-
 SGP-Tools: SGP-based Optimization Tools
 
 Software Suite for Sensor Placement and Informative Path Planning.
@@ -12,9 +11,9 @@ The library includes python code for the following:
 
 """
 
-__version__ = "1.2.0"
+__version__ = "2.0.0"
 __author__ = 'Kalvik'
 
-from .models.core import *
-from .models import *
+from .core import *
+from .kernels import *
 from .utils import *

sgptools-2.0.0/sgptools/core/__init__.py

@@ -0,0 +1 @@
+# sgptools/core/__init__.py

{sgptools-1.2.0/sgptools/models → sgptools-2.0.0/sgptools}/core/augmented_gpr.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 # Original GP code from GPflow library (https://github.com/GPflow/GPflow)
-
 """Provides a Gaussian process model with expand and aggregate functions
 """
 
@@ -25,6 +24,7 @@ from gpflow.base import InputData, MeanAndVariance
 from gpflow.utilities import add_likelihood_noise_cov, assert_params_false
 from .transformations import Transform
 
+
 class AugmentedGPR(GPR):
     """GPR model from the GPFlow library augmented to use a transform object's
     expand and aggregate functions on the data points where necessary.  
@@ -39,24 +39,18 @@ class AugmentedGPR(GPR):
         noise_variance (float): data variance
         transform (Transform): Transform object
     """
-    def __init__(
-        self,
-        *args,
-        transform=None,
-        **kwargs
-    ):
-        super().__init__(
-            *args,
-            **kwargs
-        )
+
+    def __init__(self, *args, transform=None, **kwargs):
+        super().__init__(*args, **kwargs)
         if transform is None:
             self.transform = Transform()
         else:
             self.transform = transform
 
     def predict_f(
-        self, Xnew: InputData, 
-        full_cov: bool = True, 
+        self,
+        Xnew: InputData,
+        full_cov: bool = True,
         full_output_cov: bool = False,
         aggregate_train: bool = False,
     ) -> MeanAndVariance:
@@ -84,10 +78,10 @@ class AugmentedGPR(GPR):
             # which can when train and test data are the same size
             if kmn.shape[0] != kmn.shape[1]:
                 kmn = self.transform.aggregate(kmn)
-        
+
         conditional = gpflow.conditionals.base_conditional
         f_mean_zero, f_var = conditional(
-            kmn, kmm_plus_s, knn, err, full_cov=full_cov, white=False
-        )  # [N, P], [N, P] or [P, N, N]
+            kmn, kmm_plus_s, knn, err, full_cov=full_cov,
+            white=False)  # [N, P], [N, P] or [P, N, N]
         f_mean = f_mean_zero + self.mean_function(Xnew)
-        return f_mean, f_var
+        return f_mean, f_var

{sgptools-1.2.0/sgptools/models → sgptools-2.0.0/sgptools}/core/augmented_sgpr.py

@@ -13,7 +13,6 @@
 # limitations under the License.
 
 # Original SGP code from GPflow library (https://github.com/GPflow/GPflow)
-
 """Provides a sparse Gaussian process model with update, expand, and aggregate functions
 """
 
@@ -49,37 +48,34 @@ class AugmentedSGPR(SGPR):
         inducing_variable_time (ndarray): (m, d); Temporal dimensions of the inducing points, 
                                             used when modeling spatio-temporal IPP
     """
-    def __init__(
-        self,
-        *args,
-        transform=None,
-        inducing_variable_time=None,
-        **kwargs
-    ):
-        super().__init__(
-            *args,
-            **kwargs
-        )
+
+    def __init__(self,
+                 *args,
+                 transform=None,
+                 inducing_variable_time=None,
+                 **kwargs):
+        super().__init__(*args, **kwargs)
         if transform is None:
             self.transform = Transform()
         else:
             self.transform = transform
 
         if inducing_variable_time is not None:
-            self.inducing_variable_time = inducingpoint_wrapper(inducing_variable_time)
+            self.inducing_variable_time = inducingpoint_wrapper(
+                inducing_variable_time)
             self.transform.inducing_variable_time = self.inducing_variable_time
         else:
             self.inducing_variable_time = None
 
-    def update(self, noise_variance, kernel):
+    def update(self, kernel, noise_variance):
         """Update SGP noise variance and kernel function parameters
 
         Args:
-            noise_variance (float): data variance
             kernel (gpflow.kernels.Kernel): gpflow kernel function
+            noise_variance (float): data variance
         """
         self.likelihood.variance.assign(noise_variance)
-        for self_var, var in zip(self.kernel.trainable_variables, 
+        for self_var, var in zip(self.kernel.trainable_variables,
                                  kernel.trainable_variables):
             self_var.assign(var)
 
@@ -91,7 +87,7 @@ class AugmentedSGPR(SGPR):
             A is M x N, B is M x M, LB is M x M, AAT is M x M
         """
         x, _ = self.data
-        
+
         iv = self.inducing_variable.Z  # [M]
         iv = self.transform.expand(iv)
 
@@ -130,9 +126,10 @@ class AugmentedSGPR(SGPR):
         constraints = self.transform.constraints(self.inducing_variable.Z)
         return const + logdet + quad + constraints
 
-    def predict_f(
-        self, Xnew: InputData, full_cov: bool = False, full_output_cov: bool = False
-    ) -> MeanAndVariance:
+    def predict_f(self,
+                  Xnew: InputData,
+                  full_cov: bool = False,
+                  full_output_cov: bool = False) -> MeanAndVariance:
 
         # could copy into posterior into a fused version
         """
@@ -141,7 +138,7 @@ class AugmentedSGPR(SGPR):
         notebook.
         """
         X_data, Y_data = self.data
-        
+
         iv = self.inducing_variable.Z
         iv = self.transform.expand(iv)
 
@@ -155,8 +152,7 @@ class AugmentedSGPR(SGPR):
         L = tf.linalg.cholesky(kuu)
         A = tf.linalg.triangular_solve(L, kuf, lower=True) / sigma
         B = tf.linalg.matmul(A, A, transpose_b=True) + tf.eye(
-            num_inducing, dtype=default_float()
-        )  # cache qinv
+            num_inducing, dtype=default_float())  # cache qinv
         LB = tf.linalg.cholesky(B)
         Aerr = tf.linalg.matmul(A, err)
         c = tf.linalg.triangular_solve(LB, Aerr, lower=True) / sigma
@@ -164,18 +160,15 @@ class AugmentedSGPR(SGPR):
         tmp2 = tf.linalg.triangular_solve(LB, tmp1, lower=True)
         mean = tf.linalg.matmul(tmp2, c, transpose_a=True)
         if full_cov:
-            var = (
-                self.kernel(Xnew)
-                + tf.linalg.matmul(tmp2, tmp2, transpose_a=True)
-                - tf.linalg.matmul(tmp1, tmp1, transpose_a=True)
-            )
-            var = tf.tile(var[None, ...], [self.num_latent_gps, 1, 1])  # [P, N, N]
+            var = (self.kernel(Xnew) +
+                   tf.linalg.matmul(tmp2, tmp2, transpose_a=True) -
+                   tf.linalg.matmul(tmp1, tmp1, transpose_a=True))
+            var = tf.tile(var[None, ...],
+                          [self.num_latent_gps, 1, 1])  # [P, N, N]
         else:
-            var = (
-                self.kernel(Xnew, full_cov=False)
-                + tf.reduce_sum(tf.square(tmp2), 0)
-                - tf.reduce_sum(tf.square(tmp1), 0)
-            )
+            var = (self.kernel(Xnew, full_cov=False) +
+                   tf.reduce_sum(tf.square(tmp2), 0) -
+                   tf.reduce_sum(tf.square(tmp1), 0))
             var = tf.tile(var[:, None], [1, self.num_latent_gps])
 
         return mean + self.mean_function(Xnew), var