sgptools 1.0.6__tar.gz → 1.1.0__tar.gz

{sgptools-1.0.6 → sgptools-1.1.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgptools
-Version: 1.0.6
+Version: 1.1.0
 Summary: Software Suite for Sensor Placement and Informative Path Planning
 Home-page: https://www.itskalvik.com/sgp-tools
 Author: Kalvik

{sgptools-1.0.6 → sgptools-1.1.0}/README.md

@@ -18,6 +18,11 @@ The library includes python code for the following:
        
   <img alt="Dark" src="docs/assets/AIPP-non-point_sensing.gif" width="45%"></p>
 
+## Related Packages
+
+- The [ros_sgp_tools](https://github.com/itskalvik/ros_sgp_tools) package provides a ROS2 companion package for SGP-Tools that can be deployed on ArduPilot-based vehicles. 
+- The [docker-sgp-tools](https://github.com/itskalvik/docker-sgp-tools) package provides docker containers for running SGP-Tools in simulation and on ArduPilot-based vehicles.
+
 ## Installation
 The library is available as a ```pip``` package. To install the package, run the following command:
 

{sgptools-1.0.6 → sgptools-1.1.0}/setup.py

@@ -1,6 +1,6 @@
 from setuptools import setup, find_packages
 
-__version__ = "1.0.6"
+__version__ = "1.1.0"
 
 setup(
     name='sgptools',

{sgptools-1.0.6 → sgptools-1.1.0}/sgptools/models/bo.py

@@ -29,67 +29,90 @@ class BayesianOpt:
         X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
         noise_variance (float): data variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
+        transform (Transform): Transform object
     """
-    def __init__(self, X_train, noise_variance, kernel):
+    def __init__(self, X_train, noise_variance, kernel,
+                 transform=None):
         self.X_train = X_train
         self.noise_variance = noise_variance
         self.kernel = kernel
         self.num_dim = X_train.shape[-1]
-        
+        self.transform = transform
+
         # use the boundaries of the region as the search space
         self.pbounds_dim = []
         for i in range(self.num_dim):
             self.pbounds_dim.append((np.min(X_train[:, i]), np.max(X_train[:, i])))
-
+  
     def objective(self, **kwargs):
-        """Computes the objective function (mutual information) for the sensor placement problem
+        """Objective function (GP-based Mutual Information)
+
+        Args:
+            x<i> (ndarray): (1, d); Current solution sensor placement location i
         """
+        # MI does not depend on waypoint order (reshape to -1, num_dim)
         X = []
         for i in range(len(kwargs)):
             X.append(kwargs['x{}'.format(i)])
         X = np.array(X).reshape(-1, self.num_dim)
-        return -get_mi(X, self.noise_variance, self.kernel, self.X_train)
-    
+        if self.transform is not None:
+            X = self.transform.expand(X)
+            constraints_loss = self.transform.constraints(X)
+
+        try:
+            mi = get_mi(X, self.X_train, self.noise_variance, self.kernel)
+            mi += constraints_loss
+            mi = mi.numpy()
+        except:
+            mi = -1e4 # if the cholskey decomposition fails
+        return mi
+
     def optimize(self, 
                  num_sensors=10, 
                  max_steps=100,  
                  X_init=None,
-                 init_points=10):
+                 init_points=10,
+                 verbose=0, 
+                 seed=1234):
         """Optimizes the sensor placements using Bayesian Optimization without any constraints
 
         Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps 
-            X_init (ndarray): (m, d); Initial inducing points
-            init_points (int): How many steps of random exploration you want to perform. 
+            num_sensors (int): Number of sensor locations to optimize.
+            max_steps (int): Maximum number of optimization steps. 
+            X_init (ndarray): (m, d); Initial inducing points.
+            init_points (int): Number of random solutions used for initial exploration. 
                                Random exploration can help by diversifying the exploration space. 
+            verbose (int): The level of verbosity.
+            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
 
         Returns:
             Xu (ndarray): (m, d); Solution sensor placement locations
         """
         if X_init is None:
             X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
+        else:
+            num_sensors = len(X_init.reshape(-1, self.num_dim))
         X_init = X_init.reshape(-1)
 
         pbounds = {}
         for i in range(self.num_dim*num_sensors):
             pbounds['x{}'.format(i)] = self.pbounds_dim[i%self.num_dim]
 
-        optimizer = BayesianOptimization(
-            f=self.objective,
-            pbounds=pbounds,
-            verbose=0,
-            random_state=1,
-            allow_duplicate_points=True
-        )
-
-        optimizer.maximize(
-            init_points=init_points,
-            n_iter=max_steps,
-        )
+        optimizer = BayesianOptimization(f=self.objective,
+                                         pbounds=pbounds,
+                                         verbose=verbose,
+                                         random_state=seed,
+                                         allow_duplicate_points=True)
+        optimizer.maximize(init_points=init_points,
+                           n_iter=max_steps)
 
         sol = []
         for i in range(self.num_dim*num_sensors):
             sol.append(optimizer.max['params']['x{}'.format(i)])
-        return np.array(sol).reshape(-1, self.num_dim)
-
+        sol = np.array(sol).reshape(-1, self.num_dim)
+        if self.transform is not None:
+            sol = self.transform.expand(sol,
+                                        expand_sensor_model=False)
+            if not isinstance(sol, np.ndarray):
+                sol = sol.numpy()
+        return sol.reshape(-1, self.num_dim)

sgptools-1.1.0/sgptools/models/cma_es.py

@@ -0,0 +1,121 @@
+# 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.
+
+import cma
+import numpy as np
+from shapely import geometry
+from ..utils.metrics import get_mi
+from ..utils.data import get_inducing_pts
+
+
+class CMA_ES:
+    """Class for optimizing sensor placements using CMA-ES (a genetic algorithm)
+
+    Refer to the following paper for more details:
+        - Adaptive Continuous-Space Informative Path Planning for Online Environmental Monitoring [Hitz et al., 2017]
+
+    Args:
+        X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
+        noise_variance (float): data variance
+        kernel (gpflow.kernels.Kernel): gpflow kernel function
+        distance_budget (float): Distance budget for when treating the inducing points 
+                                 as waypoints of a path
+        num_robots (int): Number of robots, used when modeling 
+                          multi-robot IPP with a distance budget
+        transform (Transform): Transform object
+    """
+    def __init__(self, X_train, noise_variance, kernel,
+                 distance_budget=None,
+                 num_robots=1,
+                 transform=None):
+        self.boundaries = geometry.MultiPoint([[p[0], p[1]] for p in X_train]).convex_hull
+        self.X_train = X_train
+        self.noise_variance = noise_variance
+        self.kernel = kernel
+        self.num_dim = X_train.shape[-1]
+        self.distance_budget = distance_budget
+        self.num_robots = num_robots
+        self.transform = transform
+
+    def update(self, noise_variance, kernel):
+        """Update GP noise variance and kernel function parameters
+
+        Args:
+            noise_variance (float): data variance
+            kernel (gpflow.kernels.Kernel): gpflow kernel function
+        """
+        self.noise_variance = noise_variance
+        self.kernel = kernel
+    
+    def objective(self, X):
+        """Objective function (GP-based Mutual Information)
+
+        Args:
+            X (ndarray): (n, d); Current solution sensor placement locations
+        """
+        # MI does not depend on waypoint order (reshape to -1, num_dim)
+        X = np.array(X).reshape(-1, self.num_dim)
+        constraints_loss = 0.0
+        if self.transform is not None:
+            X = self.transform.expand(X)
+            constraints_loss = self.transform.constraints(X)
+
+        try:
+            mi = -get_mi(X, self.X_train, self.noise_variance, self.kernel)
+            mi -= constraints_loss
+            mi = mi.numpy()
+        except:
+            mi = 0.0 # if the cholskey decomposition fails
+        return mi
+    
+    def optimize(self, 
+                 num_sensors=10, 
+                 max_steps=5000, 
+                 tol=1e-6, 
+                 X_init=None,
+                 verbose=0,
+                 seed=1234):
+        """Optimizes the sensor placements using CMA-ES without any constraints
+
+        Args:
+            num_sensors (int): Number of sensor locations to optimize
+            max_steps (int): Maximum number of optimization steps
+            tol (float): Convergence tolerance to decide when to stop optimization
+            X_init (ndarray): (m, d); Initial inducing points
+            verbose (int): The level of verbosity.
+            seed (int): The algorithm will use it to seed the randomnumber generator, ensuring replicability.
+            
+        Returns:
+            Xu (ndarray): (m, d); Solution sensor placement locations
+        """
+        sigma0 = 1.0
+        
+        if X_init is None:
+            X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
+        X_init = X_init.reshape(-1)
+
+        xopt, _ = cma.fmin2(self.objective, X_init, sigma0, 
+                            options={'maxfevals': max_steps,
+                                     'verb_disp': verbose,
+                                     'tolfun': tol,
+                                     'seed': seed},
+                            restarts=5)
+        
+        xopt = np.array(xopt).reshape(-1, self.num_dim)
+        if self.transform is not None:
+            xopt = self.transform.expand(xopt, 
+                                         expand_sensor_model=False)
+            if not isinstance(xopt, np.ndarray):
+                xopt = xopt.numpy()
+        return xopt.reshape(-1, self.num_dim)

{sgptools-1.0.6 → sgptools-1.1.0}/sgptools/models/greedy_mi.py

@@ -12,8 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
-from .core.augmented_gpr import AugmentedGPR
 from apricot import CustomSelection
+from gpflow.models.gpr import GPR
 import numpy as np
 
 
@@ -32,15 +32,24 @@ class GreedyMI:
         kernel (gpflow.kernels.Kernel): gpflow kernel function
         transform (Transform): Transform object
     """
-    def __init__(self, S, V, noise_variance, kernel, transform=None):
+    def __init__(self, S, V, noise_variance, kernel, 
+                 transform=None):
         self.S = S
         self.V = V
         self.kernel = kernel
         self.input_dim = S.shape[1]
         self.noise_variance = noise_variance
         self.transform = transform
-                                 
+
     def mutual_info(self, x):
+        """Computes mutual information using the points `x` 
+
+        Args:
+            x (ndarray): (n); Indices of the solution placement locations
+
+        Returns:
+            MI (float): Mutual information between the placement x and candidate locations
+        """
         x = np.array(x).reshape(-1).astype(int)
         A = self.S[x[:-1]].reshape(-1, self.input_dim)
         y = self.S[x[-1]].reshape(-1, self.input_dim)
@@ -50,26 +59,27 @@ class GreedyMI:
         else:
             if self.transform is not None:
                 A = self.transform.expand(A)
-            a_gp = AugmentedGPR(data=(A, np.zeros((len(A), 1))),
-                                kernel=self.kernel,
-                                noise_variance=self.noise_variance,
-                                transform=self.transform)
-            _, sigma_a = a_gp.predict_f(y, aggregate_train=True)
+            a_gp = GPR(data=(A, np.zeros((len(A), 1))),
+                       kernel=self.kernel,
+                       noise_variance=self.noise_variance)
+            _, sigma_a = a_gp.predict_f(y)
 
-        # Remove locations in A to build A bar
+        # Remove locations in A∪y from V to build A bar (Refer to Krause et al., 2008)
         V_ = self.V.copy()
         V_rows = V_.view([('', V_.dtype)] * V_.shape[1])
+
         if self.transform is not None:
-            A_ = self.transform.expand(self.S[x]).numpy()
+            solution = self.S[x].reshape(-1, self.input_dim)
+            A_ = self.transform.expand(solution)
         else:
             A_ = self.S[x]
         A_rows = A_.view([('', V_.dtype)] * A_.shape[1])
+
         V_ = np.setdiff1d(V_rows, A_rows).view(V_.dtype).reshape(-1, V_.shape[1])
 
-        self.v_gp = AugmentedGPR(data=(V_, np.zeros((len(V_), 1))), 
-                                 kernel=self.kernel,
-                                 noise_variance=self.noise_variance,
-                                 transform=self.transform)
+        self.v_gp = GPR(data=(V_, np.zeros((len(V_), 1))), 
+                        kernel=self.kernel,
+                        noise_variance=self.noise_variance)
         _, sigma_v = self.v_gp.predict_f(y)
 
         return (sigma_a/sigma_v).numpy().squeeze()

{sgptools-1.0.6 → sgptools-1.1.0}/sgptools/models/greedy_sgp.py

@@ -30,20 +30,16 @@ class GreedySGP:
         V (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
         noise_variance (float): Data noise variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
-        Xu_fixed (ndarray): (m, d); Inducing points that are not optimized and are always 
-                                    added to the inducing points set during loss function computation
         transform (Transform): Transform object
     """
     def __init__(self, num_inducing, S, V, noise_variance, kernel, 
-                 Xu_fixed=None, 
                  transform=None):
-        self.gp = AugmentedSGPR((V, np.zeros((len(V), 1))),
-                                noise_variance=noise_variance,
-                                kernel=kernel, 
-                                inducing_variable=S[:num_inducing],
-                                transform=transform)
+        self.sgp = AugmentedSGPR((V, np.zeros((len(V), 1))),
+                                 noise_variance=noise_variance,
+                                 kernel=kernel, 
+                                 inducing_variable=S[:num_inducing],
+                                 transform=transform)
         self.locs = S
-        self.Xu_fixed = Xu_fixed
         self.num_inducing = num_inducing
         self.inducing_dim = S.shape[1]
 
@@ -51,21 +47,25 @@ class GreedySGP:
         """Computes the SGP's optimization bound using the inducing points `x` 
 
         Args:
-            x (ndarray): (n, d); Inducing points
+            x (ndarray): (n); Indices of the solution placement locations
 
         Returns:
             elbo (float): Evidence lower bound/SGP's optimization bound value
         """
         x = np.array(x).reshape(-1).astype(int)
         Xu = np.ones((self.num_inducing, self.inducing_dim), dtype=np.float32)
+
+        # Initialize all inducing points at the first solution placement location.
+        # Ensures that the number of inducing points is always fixed and no additional
+        # information is passed to the SGP
         Xu *= self.locs[x][0]
-        Xu[-len(x):] = self.locs[x]
 
-        if self.Xu_fixed is not None:
-            Xu[:len(self.Xu_fixed)] = self.Xu_fixed
+        # Copy all given solution placements to the inducing points set
+        Xu[-len(x):] = self.locs[x]
 
-        self.gp.inducing_variable.Z.assign(Xu)
-        return self.gp.elbo().numpy()
+        # Update the SGP inducing points
+        self.sgp.inducing_variable.Z.assign(Xu)
+        return self.sgp.elbo().numpy() # return the ELBO
 
 
 def get_greedy_sgp_sol(num_sensors, candidates, X_train, noise_variance, kernel, 

{sgptools-1.0.6 → sgptools-1.1.0}/sgptools/utils/misc.py

@@ -86,6 +86,7 @@ def plot_paths(paths, candidates=None, title=None):
             plt.legend(bbox_to_anchor=(1.0, 1.02))
     if title is not None:
         plt.title(title)
+    plt.gca().set_aspect('equal')
     plt.xlabel('X')
     plt.ylabel('Y')
 

{sgptools-1.0.6 → sgptools-1.1.0}/sgptools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgptools
-Version: 1.0.6
+Version: 1.1.0
 Summary: Software Suite for Sensor Placement and Informative Path Planning
 Home-page: https://www.itskalvik.com/sgp-tools
 Author: Kalvik

sgptools-1.0.6/sgptools/models/cma_es.py

@@ -1,189 +0,0 @@
-# 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.
-
-import cma
-import numpy as np
-from shapely import geometry
-from ..utils.metrics import get_mi
-from ..utils.data import get_inducing_pts
-
-
-class CMA_ES:
-    """Class for optimizing sensor placements using CMA-ES (a genetic algorithm)
-
-    Refer to the following paper for more details:
-        - Adaptive Continuous-Space Informative Path Planning for Online Environmental Monitoring [Hitz et al., 2017]
-
-    Args:
-        X_train (ndarray): (n, d); Locations in the environment used to approximate the monitoring regions
-        noise_variance (float): data variance
-        kernel (gpflow.kernels.Kernel): gpflow kernel function
-        distance_budget (float): Distance budget for when treating the inducing points 
-                                 as waypoints of a path
-        num_robots (int): Number of robots, used when modeling 
-                          multi-robot IPP with a distance budget
-        transform (Transform): Transform object
-    """
-    def __init__(self, X_train, noise_variance, kernel,
-                 distance_budget=None,
-                 num_robots=1,
-                 transform=None):
-        self.boundaries = geometry.MultiPoint([[p[0], p[1]] for p in X_train]).convex_hull
-        self.X_train = X_train
-        self.noise_variance = noise_variance
-        self.kernel = kernel
-        self.num_dim = X_train.shape[-1]
-        self.distance_budget = distance_budget
-        self.num_robots = num_robots
-        self.transform = transform
-
-    def update(self, noise_variance, kernel):
-        """Update GP noise variance and kernel function parameters
-
-        Args:
-            noise_variance (float): data variance
-            kernel (gpflow.kernels.Kernel): gpflow kernel function
-        """
-        self.noise_variance = noise_variance
-        self.kernel = kernel
-
-    def constraint(self, X):
-        """Constraint function for the optimization problem (constraint to limit the boundary of the region)
-        Does not work well with CMA-ES as it is a step function and is not continuous
-
-        Args:
-            X (ndarray): (n, d); Current sensor placement locations
-        """
-        X = np.array(X).reshape(-1, self.num_dim)
-        lagrangian = [self.boundaries.contains(geometry.Point(x[0], x[1])) for x in X]
-        lagrangian = np.logical_not(lagrangian).astype(float)
-        return lagrangian
-    
-    def distance_constraint(self, X):
-        """Constraint function for the optimization problem (constraint to limit the total travel distance)
-        Does not work well with CMA-ES as it is a step function and is not continuous
-
-        Args:
-            X (ndarray): (n, d); Current sensor placement locations
-        """
-        X = np.array(X).reshape(self.num_robots, -1, self.num_dim)
-        dists = np.linalg.norm(X[:, 1:] - X[:, :-1], axis=-1)
-        lagrangian = dists - self.distance_budget
-        lagrangian_mask = np.logical_not(lagrangian <= 0)
-        lagrangian[lagrangian_mask] = 0
-        lagrangian = np.sum(lagrangian)
-        return lagrangian
-    
-    def objective(self, X):
-        """Objective function (GP-based Mutual Information)
-
-        Args:
-            X (ndarray): (n, d); Initial sensor placement locations
-        """
-        # MI does not depend on waypoint order (reshape to -1, num_dim)
-        X = np.array(X).reshape(-1, self.num_dim)
-        if self.transform is not None:
-            X = self.transform.expand(X, 
-                                      expand_sensor_model=False).numpy()
-
-        try:
-            mi = -get_mi(X, self.noise_variance, self.kernel, self.X_train)
-        except:
-            mi = 0.0 # if the cholskey decomposition fails
-        return mi
-    
-    def optimize(self, 
-                 num_sensors=10, 
-                 max_steps=5000, 
-                 tol=1e-11, 
-                 X_init=None):
-        """Optimizes the SP objective function using CMA-ES without any constraints
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-            X_init (ndarray): (m, d); Initial inducing points
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        
-        if X_init is None:
-            X_init = get_inducing_pts(self.X_train, num_sensors, random=True)
-        X_init = X_init.reshape(-1)
-
-        xopt, _ = cma.fmin2(self.objective, X_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
-                                     'tolfun': tol,
-                                     'seed': 1234},
-                            restarts=5)
-        
-        xopt = np.array(xopt).reshape(-1, self.num_dim)
-        if self.transform is not None:
-            xopt = self.transform.expand(xopt, 
-                                         expand_sensor_model=False).numpy()
-
-        return xopt.reshape(-1, self.num_dim)
-    
-    def doptimize(self, num_sensors=10, max_steps=100, tol=1e-11):
-        """Optimizes the SP objective function using CMA-ES with a distance budget constraint
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        idx = np.random.randint(len(self.X_train), size=num_sensors)
-        x_init = self.X_train[idx].reshape(-1)
-        cfun = cma.ConstrainedFitnessAL(self.objective, self.distance_constraint)
-        xopt, _ = cma.fmin2(cfun, x_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
-                                     'tolfun': tol,
-                                     'seed': 1234},
-                            callback=cfun.update,
-                            restarts=5)
-        return xopt.reshape(-1, self.num_dim)
-
-    def coptimize(self, num_sensors=10, max_steps=100, tol=1e-11):
-        """Optimizes the SP objective function using CMA-ES with the constraints
-        to ensure that the sensors are placed within the boundaries of the region
-
-        Args:
-            num_sensors (int): Number of sensor locations to optimize
-            max_steps (int): Maximum number of optimization steps
-            tol (float): Convergence tolerance to decide when to stop optimization
-
-        Returns:
-            Xu (ndarray): (m, d); Solution sensor placement locations
-        """
-        sigma0 = 1.0
-        idx = np.random.randint(len(self.X_train), size=num_sensors*self.num_robots)
-        x_init = self.X_train[idx].reshape(-1)
-        cfun = cma.ConstrainedFitnessAL(self.objective, self.constraint)
-        xopt, _ = cma.fmin2(cfun, x_init, sigma0, 
-                            options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
-                                     'tolfun': tol,
-                                     'seed': 1234},
-                            callback=cfun.update,
-                            restarts=5)
-        return xopt.reshape(-1, self.num_dim)