sgptools 1.0.5__py3-none-any.whl → 1.1.0__py3-none-any.whl

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/models/cma_es.py

@@ -57,48 +57,24 @@ class CMA_ES:
         """
         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
+            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, 
-                                      expand_sensor_model=False).numpy()
+            X = self.transform.expand(X)
+            constraints_loss = self.transform.constraints(X)
 
         try:
-            mi = -get_mi(X, self.noise_variance, self.kernel, self.X_train)
+            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
@@ -106,16 +82,20 @@ class CMA_ES:
     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
+                 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
         """
@@ -127,63 +107,15 @@ class CMA_ES:
 
         xopt, _ = cma.fmin2(self.objective, X_init, sigma0, 
                             options={'maxfevals': max_steps,
-                                     'verb_disp': 0,
+                                     'verb_disp': verbose,
                                      'tolfun': tol,
-                                     'seed': 1234},
+                                     '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).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)
+                                         expand_sensor_model=False)
+            if not isinstance(xopt, np.ndarray):
+                xopt = xopt.numpy()
+        return xopt.reshape(-1, self.num_dim)

sgptools/models/core/transformations.py

@@ -15,17 +15,9 @@
 """Provides transforms to model complex sensor field of views and handle informative path planning
 """
 
-try:
-    from tensorflow_graphics.math.interpolation import bspline
-except:
-  pass
-
 import tensorflow as tf
 import numpy as np
 
-from scipy.optimize import linear_sum_assignment
-from sklearn.metrics import pairwise_distances
-
 
 class Transform:
     """Base class for transformations of the inducing points, including expansion and aggregation transforms.
@@ -98,84 +90,6 @@ class Transform:
         """
         return 0.
 
-    def distance(self, Xu):
-        """Computes the distance incured by sequentially visiting the inducing points
-
-        Args:
-            Xu (ndarray): Inducing points from which to compute the path length
-
-        Returns:
-            dist (float): path length
-        """
-        dist = tf.math.reduce_sum(tf.norm(Xu[1:]-Xu[:-1], axis=1))
-        return dist
-    
-
-class SquareTransform(Transform):
-    """Non-point Transform to model a square FoV. Only works for single robot cases. 
-    ToDo: update expand function to handle multi-robot case.
-
-    Args:
-        length (float): Length of the square FoV
-        num_side (int): Number of points along each side of the FoV
-    """
-    def __init__(self, length, num_side, **kwargs):
-        super().__init__(**kwargs)
-        self.length = length
-        self.num_side = num_side
-        self.length_factor=length/(self.num_side)
-        self.num_length = int(length/self.length_factor)
-
-        if self.aggregation_size == 0:
-            self.aggregation_size = None
-        elif self.aggregation_size is None:
-            self.aggregation_size = num_side**2
-
-    def expand(self, Xu):
-        """Applies the expansion transformation to the inducing points
-
-        Args:
-            Xu (ndarray): (1, m, 3); Inducing points in the position and orientation space.
-                            `m` is the number of inducing points,
-                            `3` is the dimension of the space (x, y, angle in radians)
-                        
-        Returns:
-            Xu (ndarray): (mp, 2); Inducing points in input space.
-                        `p` is the number of points each inducing point is mapped 
-                         to in order to form the FoV.
-        """
-        x, y, theta = tf.split(Xu, num_or_size_splits=3, axis=2)
-        x = tf.squeeze(x)
-        y = tf.squeeze(y)
-        theta = tf.squeeze(theta)
-
-        points = []
-        for i in range(-int(np.floor((self.num_side)/2)), int(np.ceil((self.num_side)/2))):
-            points.append(tf.linspace([(x + (i * self.length_factor) * tf.cos(theta)) - self.length/2 * tf.cos(theta+np.pi/2), 
-                                       (y + (i * self.length_factor) * tf.sin(theta)) - self.length/2 * tf.sin(theta+np.pi/2)], 
-                                      [(x + (i * self.length_factor) * tf.cos(theta)) + self.length/2 * tf.cos(theta+np.pi/2), 
-                                       (y + (i * self.length_factor) * tf.sin(theta)) + self.length/2 * tf.sin(theta+np.pi/2)], 
-                                      self.num_side, axis=1))
-        xy = tf.concat(points, axis=1)
-        xy = tf.transpose(xy, [2, 1, 0])
-        xy = tf.reshape(xy, [-1, 2])
-        xy = self._reshape(xy, tf.shape(Xu)[1])
-        return xy
-    
-    def _reshape(self, X, num_inducing):
-        """Reorder the inducing points to be in the correct order for aggregation with square FoV.
-
-        Args:
-            X (ndarray): (mp, 2); Inducing points in input space. `p` is the number of points each 
-                        inducing point is mapped to in order to form the FoV.
-                            
-        Returns:
-            Xu (ndarray): (mp, 2); Reorder inducing points
-        """
-        X = tf.reshape(X, (num_inducing, -1, self.num_side, self.num_side, 2))
-        X = tf.transpose(X, (0, 2, 1, 3, 4))
-        X = tf.reshape(X, (-1, 2))
-        return X
 
 class IPPTransform(Transform):
     """Transform to model IPP problems
@@ -184,6 +98,7 @@ class IPPTransform(Transform):
         * For point sensing, set `sampling_rate = 2`
         * For continuous sensing, set `sampling_rate > 2` (account for the information along the path)
         * For continuous sensing with aggregation, set `sampling_rate > 2` and `aggregate_fov = True` (faster but solution quality is a bit diminished)
+        * If using a non-point FoV model with continuous sampling, only the FoV inducing points are aggregated
         * For multi-robot case, set `num_robots > 1`
         * For onlineIPP use `update_fixed` to freeze the visited waypoints
 
@@ -192,7 +107,7 @@ class IPPTransform(Transform):
         distance_budget (float): Distance budget for the path
         num_robots (int): Number of robots
         Xu_fixed (ndarray): (num_robots, num_visited, num_dim); Visited waypoints that don't need to be optimized
-        num_dim (int): Dimension of the data collection environment
+        num_dim (int): Number of dimensions of the inducing points
         sensor_model (Transform): Transform object to expand each inducing point to `p` points 
                                   approximating each sensor's FoV
         aggregate_fov (bool): Used only when sampling_rate > 2, i.e., when using a continuous sensing model. 
@@ -220,8 +135,11 @@ class IPPTransform(Transform):
 
         # Set aggregation size to sampling rate if aggregate_fov is True
         # and sampling rate is enabled (greater than 2)
-        if aggregate_fov and sampling_rate > 2:
-            self.aggregation_size = sampling_rate
+        if aggregate_fov:
+            if self.sensor_model is not None:
+                self.sensor_model.enable_aggregation()
+            elif sampling_rate > 2:
+                self.aggregation_size = sampling_rate
     
         # Initilize variable to store visited waypoints for onlineIPP
         if Xu_fixed is not None:
@@ -278,7 +196,10 @@ class IPPTransform(Transform):
             Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
 
         if self.sensor_model is not None:
-            Xu = self.sensor_model.expand(Xu)
+            Xu_ = []
+            for i in range(self.num_robots):
+                Xu_.append(self.sensor_model.expand(Xu[i]))
+            Xu = tf.concat(Xu_, axis=0)
             return Xu
 
         Xu = tf.reshape(Xu, (-1, self.num_dim))
@@ -315,6 +236,7 @@ class IPPTransform(Transform):
         if self.distance_budget is None:
             return 0.
         else:
+            # Only do fixed points expansion transform
             Xu = self.expand(Xu, expand_sensor_model=False)
             dist = self.distance(Xu)-self.distance_budget
             dist = tf.reduce_sum(tf.nn.relu(dist))
@@ -323,39 +245,146 @@ class IPPTransform(Transform):
 
     def distance(self, Xu):
         """Computes the distance incured by sequentially visiting the inducing points
-        ToDo: Change distance from 2d to nd. Currently limited to 2d 
-            to ensure the rotation angle is not included when using
-            a square FoV sensor.
+        Args:
+            Xu (ndarray): (m, num_dim); Inducing points from which to compute the path lengths
+                          `m` is the number of inducing points
+                          `num_dim` dimension of the data collection environment
+        Returns:
+            dist (float or tensor of floats): path length(s)
+        """
+        Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
+        if self.sensor_model is not None:
+            dists = []
+            for i in range(self.num_robots):
+                dists.append(self.sensor_model.distance(Xu[i]))
+            dists = tf.concat(dists, axis=0)
+            return dists
+        else:
+            # Assumes 2D waypoints by default
+            dist = tf.norm(Xu[:, 1:, :2] - Xu[:, :-1, :2], axis=-1)
+            dist = tf.reduce_sum(dist, axis=1)
+            return dist
+
+
+class SquareTransform(Transform):
+    """Non-point Transform to model a square FoV. Only works for single robot cases. 
+
+    Args:
+        length (float): Length of the square FoV
+        num_side (int): Number of points along each side of the FoV
+        aggregate_fov (bool): If `True`, covariances corresponding to interpolated inducing points used to 
+                              approximate the sensor FoV are aggregated to reduce the matrix inversion cost
+    """
+    def __init__(self, length, num_side, aggregate_fov=False, **kwargs):
+        super().__init__(**kwargs)
+        self.length = length
+        self.num_side = num_side
+        self.length_factor=length/(self.num_side)
+        self.num_length = int(length/self.length_factor)
+
+        if aggregate_fov:
+            self.enable_aggregation()
+
+    def enable_aggregation(self, size=None):
+        """Enable FoV covariance aggregation, which reduces the covariance matrix inversion cost by reducing the 
+        covariance matrix size.
+
+        Args:
+            size (int): If None, all the interpolated inducing points within the FoV are aggregated. Alternatively, 
+                        the number of inducing points to aggregate can be explicitly defined using this variable.
+        """
+        if size is None:
+            self.aggregation_size = self.num_side**2
+        else:
+            self.aggregation_size = size
+
+    def expand(self, Xu):
+        """Applies the expansion transformation to the inducing points
+
+        Args:
+            Xu (ndarray): (m, 3); Inducing points in the position and orientation space.
+                          `m` is the number of inducing points,
+                          `3` is the dimension of the space (x, y, angle in radians)
+                        
+        Returns:
+            Xu (ndarray): (mp, 2); Inducing points in input space.
+                        `p` is the number of points each inducing point is mapped 
+                         to in order to form the FoV.
+        """
+        x, y, theta = tf.split(Xu, num_or_size_splits=3, axis=1)
+        x     = tf.reshape(x, [-1,])
+        y     = tf.reshape(y, [-1,])
+        theta = tf.reshape(theta, [-1,])
+
+        points = []
+        for i in range(-int(np.floor((self.num_side)/2)), int(np.ceil((self.num_side)/2))):
+            points.append(tf.linspace([(x + (i * self.length_factor) * tf.cos(theta)) - self.length/2 * tf.cos(theta+np.pi/2), 
+                                       (y + (i * self.length_factor) * tf.sin(theta)) - self.length/2 * tf.sin(theta+np.pi/2)], 
+                                      [(x + (i * self.length_factor) * tf.cos(theta)) + self.length/2 * tf.cos(theta+np.pi/2), 
+                                       (y + (i * self.length_factor) * tf.sin(theta)) + self.length/2 * tf.sin(theta+np.pi/2)], 
+                                      self.num_side, axis=1))
+        xy = tf.concat(points, axis=1)
+        xy = tf.transpose(xy, [2, 1, 0])
+        xy = self._reshape(xy)
+        return xy
+    
+    def _reshape(self, X):
+        """Reorder the inducing points to be in the correct order for aggregation with square FoV.
 
         Args:
-            Xu (ndarray): Inducing points from which to compute the path lengths
+            X (ndarray): (mp, 2); Inducing points in input space. `p` is the number of points each 
+                        inducing point is mapped to in order to form the FoV.
+                            
+        Returns:
+            Xu (ndarray): (mp, 2); Reorder inducing points
+        """
+        X = tf.reshape(X, (-1, self.num_side, self.num_side, 2))
+        X = tf.transpose(X, (1, 0, 2, 3))
+        X = tf.reshape(X, (-1, 2))
+        return X
+    
+    def distance(self, Xu):
+        """Computes the distance incured by sequentially visiting the inducing points
+        Args:
+            Xu (ndarray): (m, 3); Inducing points from which to compute the path lengths.
+                          `m` is the number of inducing points.
 
         Returns:
             dist (float): path lengths
         """
-        Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
-        dist = tf.norm(Xu[:, 1:, :2] - Xu[:, :-1, :2], axis=-1)
-        dist = tf.reduce_sum(dist, axis=1)
+        Xu = tf.reshape(Xu, (-1, 3))[:, :2]
+        dist = tf.norm(Xu[1:] - Xu[:-1], axis=-1)
+        dist = tf.reduce_sum(dist, axis=0)
         return dist
-    
+
 
 class SquareHeightTransform(Transform):
-    """Non-point Transform to model a height-dependent square FoV. Only works for single robot cases. 
-    ToDo: Convert from single to multi-robot setup and make it compatible with IPPTransform
+    """Non-point Transform to model a height-dependent square FoV
 
     Args:
-        num_points (int): Number of points along each side of the FoV
-        distance_budget (float): Distance budget for the path
+        num_side (int): Number of points along each side of the FoV
+        aggregate_fov (bool): If `True`, covariances corresponding to interpolated inducing points used to 
+                              approximate the sensor FoV are aggregated to reduce the matrix inversion cost
     """
-    def __init__(self, num_points, distance_budget=None, **kwargs):
+    def __init__(self, num_side, aggregate_fov=False, **kwargs):
         super().__init__(**kwargs)
-        self.num_points = num_points
-        self.distance_budget = distance_budget
-    
-        if self.aggregation_size == 0:
-            self.aggregation_size = None
-        elif self.aggregation_size is None:
-            self.aggregation_size = num_points**2
+        self.num_side = num_side
+
+        if aggregate_fov:
+            self.enable_aggregation()
+
+    def enable_aggregation(self, size=None):
+        """Enable FoV covariance aggregation, which reduces the covariance matrix inversion cost by reducing the 
+        covariance matrix size.
+
+        Args:
+            size (int): If None, all the interpolated inducing points within the FoV are aggregated. Alternatively, 
+                        the number of inducing points to aggregate can be explicitly defined using this variable.
+        """
+        if size is None:
+            self.aggregation_size = self.num_side**2
+        else:
+            self.aggregation_size = size
 
     def expand(self, Xu):     
         """
@@ -372,17 +401,17 @@ class SquareHeightTransform(Transform):
                         to in order to form the FoV.
         """
         x, y, h = tf.split(Xu, num_or_size_splits=3, axis=1)
-        x = tf.squeeze(x)
-        y = tf.squeeze(y)
-        h = tf.squeeze(h)
+        x = tf.reshape(x, [-1,])
+        y = tf.reshape(y, [-1,])
+        h = tf.reshape(h, [-1,])
 
-        delta = h / (self.num_points - 1)
+        delta = h / (self.num_side - 1)
 
         pts = []
-        for i in range(self.num_points):
+        for i in range(self.num_side):
             pts.append(tf.linspace([x - h/2, y - (h/2) + (delta * i)], 
                                    [x + h/2, y - (h/2) + (delta * i)], 
-                                   self.num_points, 
+                                   self.num_side, 
                                    axis=1))
         xy = tf.concat(pts, axis=1)
         xy = tf.transpose(xy, [2, 1, 0])
@@ -400,7 +429,22 @@ class SquareHeightTransform(Transform):
         Returns:
             Xu (ndarray): (mp, 2); Reorder inducing points
         """
-        X = tf.reshape(X, (num_inducing, -1, self.num_points, self.num_points, 2))
+        X = tf.reshape(X, (num_inducing, -1, self.num_side, self.num_side, 2))
         X = tf.transpose(X, (0, 2, 1, 3, 4))
         X = tf.reshape(X, (-1, 2))
         return X
+    
+    def distance(self, Xu):
+        """Computes the distance incured by sequentially visiting the inducing points
+        Args:
+            Xu (ndarray): (m, 3); Inducing points from which to compute the path lengths.
+                          `m` is the number of inducing points.
+
+        Returns:
+            dist (float): path lengths
+        """
+        Xu = tf.reshape(Xu, (-1, 3))
+        dist = tf.norm(Xu[1:] - Xu[:-1], axis=-1)
+        dist = tf.reduce_sum(dist, axis=0)
+        return dist
+    

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/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/utils/data.py

@@ -91,8 +91,8 @@ def prep_tif_dataset(dataset_path):
         dataset_path (str): Path to the dataset file, used only when dataset_type is 'tif'.
 
     Returns:
-       X: (n, d); Dataset input features
-       y: (n, 1); Dataset labels
+       X (ndarray): (n, d); Dataset input features
+       y (ndarray): (n, 1); Dataset labels
     '''
     data = PIL.Image.open(dataset_path)
     data = np.array(data)
@@ -116,22 +116,31 @@ def prep_tif_dataset(dataset_path):
 
 ####################################################
 
-def prep_synthetic_dataset():
+def prep_synthetic_dataset(shape=(50, 50), 
+                           min_height=0.0, 
+                           max_height=30.0, 
+                           roughness=0.5,
+                           **kwargs):
     '''Generates a 50x50 grid of synthetic elevation data using the diamond square algorithm.
     
     Refer to the following repo for more details:
         - [https://github.com/buckinha/DiamondSquare](https://github.com/buckinha/DiamondSquare)
     
     Args:
+        shape (tuple): (x, y); Grid size along the x and y axis
+        min_height (float): Minimum allowed height in the sampled data
+        max_height (float): Maximum allowed height in the sampled data
+        roughness (float): Roughness of the sampled data
 
     Returns:
-       X: (n, d); Dataset input features
-       y: (n, 1); Dataset labels
+       X (ndarray): (n, d); Dataset input features
+       y (ndarray): (n, 1); Dataset labels
     '''
-    data = diamond_square(shape=(50,50), 
-                          min_height=0, 
-                          max_height=30, 
-                          roughness=0.5)
+    data = diamond_square(shape=shape,
+                          min_height=min_height, 
+                          max_height=max_height, 
+                          roughness=roughness,
+                          **kwargs)
 
     # create x and y coordinates from the extent
     x_coords = np.arange(0, data.shape[0])/10
@@ -145,17 +154,16 @@ def prep_synthetic_dataset():
 
 ####################################################
 
-def get_dataset(dataset_type, dataset_path=None,
+def get_dataset(dataset_path=None,
                 num_train=1000,
                 num_test=2500, 
-                num_candidates=150):
+                num_candidates=150,
+                **kwargs):
     """Method to generate/load datasets and preprocess them for SP/IPP. The method uses kmeans to 
     generate train and test sets.
     
     Args:
-        dataset_type (str): 'tif' or 'synthetic'. 'tif' will load and proprocess data from a GeoTIFF file. 
-                        'synthetic' will use the diamond square algorithm to generate synthetic elevation data.
-        dataset_path (str): Path to the dataset file, used only when dataset_type is 'tif'.
+        dataset_path (str): Path to a tif dataset file. If None, the method will generate synthetic data.
         num_train (int): Number of training samples to generate.
         num_test (int): Number of testing samples to generate.
         num_candidates (int): Number of candidate locations to generate.
@@ -170,10 +178,10 @@ def get_dataset(dataset_type, dataset_path=None,
        y (ndarray): (n, 1); Full dataset labels
     """
     # Load the data
-    if dataset_type == 'tif':
+    if dataset_path is not None:
         X, y = prep_tif_dataset(dataset_path=dataset_path)
-    elif dataset_type == 'synthetic':
-        X, y = prep_synthetic_dataset()
+    else:
+        X, y = prep_synthetic_dataset(**kwargs)
 
     X_train = get_inducing_pts(X, num_train)
     X_train, y_train = cont2disc(X_train, X, y)

sgptools/utils/gpflow.py

@@ -18,6 +18,7 @@ from gpflow.utilities.traversal import print_summary
 import tensorflow as tf
 import tensorflow_probability as tfp
 
+import numpy as np
 import matplotlib.pyplot as plt
 
 
@@ -87,6 +88,43 @@ def get_model_params(X_train, y_train,
     
     return loss, gpr_gt.likelihood.variance, kernel
 
+
+class TraceInducingPts(gpflow.monitor.MonitorTask):
+    '''
+    GPflow monitoring task, used to trace the inducing points
+    states at every step during optimization. 
+
+    Args:
+        model (gpflow.models.sgpr): GPflow GP/SGP model
+    '''
+    def __init__(self, model):
+        super().__init__()
+        self.trace = []
+        self.model = model
+
+    def run(self, **kwargs):
+        '''
+        Method used to extract the inducing points and 
+        apply IPP fixed points transform if available
+        '''
+        Xu = self.model.inducing_variable.Z
+        Xu_exp = self.model.transform.expand(Xu, 
+                            expand_sensor_model=False).numpy()
+        self.trace.append(Xu_exp)
+
+    def get_trace(self):
+        '''
+        Returns the inducing points collected at each optimization step
+
+        Returns:
+            trace (ndarray): (n, m, d); Array with the inducing points.
+                            `n` is the number of optimization steps;
+                            `m` is the number of inducing points;
+                            `d` is the dimension of the inducing points.
+        '''
+        return np.array(self.trace)
+
+
 def optimize_model(model, 
                    max_steps=2000, 
                    kernel_grad=True, 
@@ -102,21 +140,22 @@ def optimize_model(model,
     Trains a GP/SGP model
 
     Args:
-        model (gpflow.models): GPflow GP/SGP model to train
-        max_steps (int): Maximum number of training steps
-        kernel_grad (bool): If False, the kernel parameters will not be optimized
-        lr (float): Optimization learning rate
-        optimizer (str): Optimizer to use for training (`scipy` or `tf`)
+        model (gpflow.models): GPflow GP/SGP model to train.
+        max_steps (int): Maximum number of training steps.
+        kernel_grad (bool): If `False`, the kernel parameters will not be optimized. 
+                            Ignored when `trainable_variables` are passed.
+        lr (float): Optimization learning rate.
+        optimizer (str): Optimizer to use for training (`scipy` or `tf`).
         method (str): Optimization method refer to [scipy minimize](https://docs.scipy.org/doc/scipy/reference/generated/scipy.optimize.minimize.html#scipy.optimize.minimize) 
                       and [tf optimizers](https://www.tensorflow.org/api_docs/python/tf/keras/optimizers) for full list
-        verbose (bool): If true, the training progress will be printed
+        verbose (bool): If `True`, the training progress will be printed when using Scipy.
         trace_fn (str): Function to trace metrics during training. 
-                        If `None`, the loss values are traced;
-                        if `traceXu`, it the inducing points states at each optimization step are traced
-        convergence_criterion (bool): It True, enables early stopping when the loss plateaus
-        trainable_variables (list): List of model variables to train 
-                                    (can be used to limit training to a subset of variables)
-        tol (float): Convergence tolerance to decide when to stop optimization
+                        If `None`, the loss values are returned;
+                        If `traceXu`, it the inducing points states at each optimization step are returned (increases computation time).
+        convergence_criterion (bool): If `True` and using a tensorflow optimizer, it 
+                                      enables early stopping when the loss plateaus.
+        trainable_variables (list): List of model variables to train.
+        tol (float): Convergence tolerance to decide when to stop optimization.
     """
     # Train all variables if trainable_variables are not provided
     # If kernel_gradient is False, disable the kernel parameter gradient updates
@@ -128,13 +167,24 @@ def optimize_model(model,
     if optimizer == 'scipy':
         if method is None:
             method = 'L-BFGS-B'
+
+        if trace_fn == 'traceXu':
+            execute_task = TraceInducingPts(model)
+            task_group = gpflow.monitor.MonitorTaskGroup(execute_task, 
+                                                         period=1)
+            trace_fn = gpflow.monitor.Monitor(task_group)
+
         opt = gpflow.optimizers.Scipy()
         losses = opt.minimize(model.training_loss,
                               trainable_variables,
                               method=method,
                               options=dict(disp=verbose, maxiter=max_steps),
-                              tol=tol)
-        losses = losses.fun
+                              tol=tol,
+                              step_callback=trace_fn)
+        if trace_fn is None:
+            losses = losses.fun
+        else:
+            losses = trace_fn.task_groups[0].tasks[0].get_trace()
     else:
         if trace_fn is None:
             trace_fn = lambda x: x.loss

sgptools/utils/metrics.py

@@ -131,12 +131,12 @@ def get_rmse(y_pred, y_test):
     """
     return np.sqrt(np.mean(np.square(y_pred - y_test)))
 
-def get_reconstruction(Xu, X_test, noise_variance, kernel):
+def get_reconstruction(sensor_data, X_test, noise_variance, kernel):
     """Computes the GP-based data field estimates with the solution placements as the training set
 
     Args:
-        Xu (tuple): (ndarray (m, d); ndarray (m, 1)); Sensing locations' input 
-                    and corresponding ground truth labels
+        sensor_data (ndarray tuple): ((m, d), (m, 1)); Sensing locations' input 
+                             and corresponding ground truth labels
         X_test (ndarray): (n, d); Testing data input locations
         noise_variance (float): data variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
@@ -145,7 +145,7 @@ def get_reconstruction(Xu, X_test, noise_variance, kernel):
         y_pred (ndarray): (n, 1); Predicted data field estimates
         y_var (ndarray): (n, 1); Prediction variance at each location in the data field
     """
-    Xu_X, Xu_y = Xu
+    Xu_X, Xu_y = sensor_data
 
     # Get the GP predictions
     gpr = gpflow.models.GPR((Xu_X, Xu_y),

sgptools/utils/misc.py

@@ -51,7 +51,10 @@ def cont2disc(Xu, candidates, candidate_labels=None):
     """
     # Sanity check to ensure that there are sensing locations and candidates to match
     if len(candidates)==0 or len(Xu)==0:
-        return []
+        if candidate_labels is not None:
+            return [], []
+        else:
+            return []
     
     dists = pairwise_distances(candidates, Y=Xu, metric='euclidean')
     row_ind, _ = linear_sum_assignment(dists)
@@ -83,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')
 
@@ -133,4 +137,4 @@ def project_waypoints(waypoints, candidates):
     """
     waypoints_disc = cont2disc(waypoints, candidates)
     waypoints_valid = _reoder_path(waypoints, waypoints_disc)
-    return waypoints_valid
+    return waypoints_valid

{sgptools-1.0.5.dist-info → sgptools-1.1.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: sgptools
-Version: 1.0.5
+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.1.0.dist-info/RECORD

@@ -0,0 +1,25 @@
+sgptools/__init__.py,sha256=J4jZOdSzuUtaabg4TtYxxWfQwZkA0E_bVK3aaBPgPAc,449
+sgptools/kernels/__init__.py,sha256=zRf4y-wJwjXKt1uOnmI5MbzCA6pRlyA7C-eagLfb3d0,190
+sgptools/kernels/neural_kernel.py,sha256=9XEjcwwi1Gwj4D5cAZwq5QdWqMaI-Vu2DKgYO58DmPg,6709
+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
+sgptools/models/continuous_sgp.py,sha256=USf9fG1Pl-rQfcD_ffP6mB4mrh0F9RMUA7Lfhw9rc48,2940
+sgptools/models/greedy_mi.py,sha256=06CY6tm9C3iBYEG_DOuQKDmWIww9Ah0rkeJUXsCR2YU,5018
+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=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw,11798
+sgptools/models/core/transformations.py,sha256=avluSP7g4EWjijlpFQYobO_CHKA0-V7PemC6SdVwrG8,18976
+sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
+sgptools/utils/data.py,sha256=oTXq4oRuzJdXpZC6frUfja8jhwy_ZdDDi7L1BYZcdQs,7309
+sgptools/utils/gpflow.py,sha256=LnFYufnMW4ch7qsKnru53QUxEtIzJqE822qj6w8ssRg,8576
+sgptools/utils/metrics.py,sha256=tu8H129n8GuxV5fQIKLcfzPUxd7sp8zEF9qZBOZjNKo,5834
+sgptools/utils/misc.py,sha256=LdAFJS7-xubWpRnrgdLOorCa9vB_8vRrvL5cahxHYNA,5442
+sgptools/utils/tsp.py,sha256=RJAQ4_uE7CUtR1ei3nSnGy-1kNhw82E9P_HyaCkc4iI,7007
+sgptools-1.1.0.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.1.0.dist-info/METADATA,sha256=4_pfsYY9aY2D8vw_gsb0EGoE2ErABQog-slYq1ThEQo,944
+sgptools-1.1.0.dist-info/WHEEL,sha256=GV9aMThwP_4oNCtvEC2ec3qUYutgWeAzklro_0m4WJQ,91
+sgptools-1.1.0.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.1.0.dist-info/RECORD,,

{sgptools-1.0.5.dist-info → sgptools-1.1.0.dist-info}/WHEEL

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

sgptools-1.0.5.dist-info/RECORD

@@ -1,25 +0,0 @@
-sgptools/__init__.py,sha256=J4jZOdSzuUtaabg4TtYxxWfQwZkA0E_bVK3aaBPgPAc,449
-sgptools/kernels/__init__.py,sha256=zRf4y-wJwjXKt1uOnmI5MbzCA6pRlyA7C-eagLfb3d0,190
-sgptools/kernels/neural_kernel.py,sha256=9XEjcwwi1Gwj4D5cAZwq5QdWqMaI-Vu2DKgYO58DmPg,6709
-sgptools/models/__init__.py,sha256=X2lIg9kf1-2MHUswk-VW2dHHcbSLxf6_IuV7lc_kvDc,682
-sgptools/models/bo.py,sha256=RkcbD0t2d1gkZf7SMtMyymlYne9sFEaA4pjmgQhlTWY,3640
-sgptools/models/cma_es.py,sha256=URLndW_lb9zQj6XrxO6tnm9U6xld8jgsrqsg-Oo5vyw,8006
-sgptools/models/continuous_sgp.py,sha256=USf9fG1Pl-rQfcD_ffP6mB4mrh0F9RMUA7Lfhw9rc48,2940
-sgptools/models/greedy_mi.py,sha256=LJVXKHC58iJs1CyfAioAjCeK2o5hiViTchFxuiKj73o,4870
-sgptools/models/greedy_sgp.py,sha256=jgQexdEZ_z88iD6sM_D0NhJvBodQ9zindh9L7117q_8,4462
-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=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw,11798
-sgptools/models/core/transformations.py,sha256=NTj3yZjTQXTHBr24XFI_W5dh2-TVginisEiT6LPeMeg,16742
-sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
-sgptools/utils/data.py,sha256=5HX4YwxZX4Q1J6UekB9GARMVhjsF806kTh2eRCrU79I,6978
-sgptools/utils/gpflow.py,sha256=bnrtKl9tvKVh1Wz969KQJQf8UtApa7i0SkOj-KMOWNc,6816
-sgptools/utils/metrics.py,sha256=0tyMPoZgA-dRNs-Ye69paMNFpWgLuLNE1t8ywOnRmaE,5806
-sgptools/utils/misc.py,sha256=W8lx6n1eJeeiq6cyRGzhZMCnWItoiQzODHQkqVAQi4U,5322
-sgptools/utils/tsp.py,sha256=RJAQ4_uE7CUtR1ei3nSnGy-1kNhw82E9P_HyaCkc4iI,7007
-sgptools-1.0.5.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.0.5.dist-info/METADATA,sha256=GqxkIaxPKoQjZhyU2505xFvNs5xqBu40Ncah6BWFDm4,944
-sgptools-1.0.5.dist-info/WHEEL,sha256=Mdi9PDNwEZptOjTlUcAth7XJDFtKrHYaQMPulZeBCiQ,91
-sgptools-1.0.5.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.0.5.dist-info/RECORD,,