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

sgptools/models/core/transformations.py

@@ -1,434 +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.
-
-"""Provides transforms to model complex sensor field of views and handle informative path planning
-"""
-
-import tensorflow as tf
-import numpy as np
-
-
-class Transform:
-    """Base class for transformations of the inducing points, including expansion and aggregation transforms.
-
-    Refer to the following papers for more details:
-        - Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces [Jakkala and Akella, 2023]
-        - Multi-Robot Informative Path Planning from Regression with Sparse Gaussian Processes [Jakkala and Akella, 2024]
-
-    Args:
-        aggregation_size (int): Number of consecutive inducing points to aggregate
-        constraint_weight (float): Weight term that controls the importance of the 
-                                   constraint terms in the SGP's optimization objective 
-    """
-    def __init__(self, 
-                 aggregation_size=None, 
-                 constraint_weight=1.0,
-                 **kwargs):
-        self.aggregation_size = aggregation_size
-        self.constraint_weight = constraint_weight
-
-    def expand(self, Xu):
-        """Applies the expansion transform to the inducing points
-
-        Args:
-            Xu (ndarray): Expansion transformed inducing points
-        """
-        return Xu
-
-    def aggregate(self, k):
-        """Applies the aggregation transform to kernel matrices
-
-        Args:
-            k (tensor): (mp, mp)/(mp, n); Kernel matrix. 
-                        `m` is the number of inducing points,
-                        `p` is the number of points each inducing point is mapped,
-                        `n` is the number of training data points.
-
-        Returns:
-            k (tensor): (m, m)/(m, n); Aggregated kernel matrix
-        """
-        if self.aggregation_size is None:
-            return k
-
-        if k.shape[0] == k.shape[1]:
-            # Handle Kuu which is a square matrix
-            k = tf.expand_dims(tf.expand_dims(k, axis=0), axis=-1)
-            k = tf.nn.avg_pool(k,
-                               ksize=[1, self.aggregation_size, self.aggregation_size, 1],
-                               strides=[1, self.aggregation_size, self.aggregation_size, 1],
-                               padding='VALID')
-            k = tf.squeeze(k, axis=[0, -1])
-        else:
-            # Handle Kuf which is a rectangular matrix
-            k = tf.expand_dims(k, axis=0)
-            k = tf.nn.avg_pool(k,
-                               ksize=[1, self.aggregation_size, 1],
-                               strides=[1, self.aggregation_size, 1],
-                               padding='VALID')
-            k = tf.squeeze(k, axis=[0])
-        return k
-
-    def constraints(self, Xu):
-        """Computes the constraint terms that are added to the SGP's optimization function
-
-        Args:
-            Xu (ndarray): Inducing points from which to compute the constraints
-
-        Returns:
-            c (float): constraint terms (eg., distance constraint)
-        """
-        return 0.
-
-
-class IPPTransform(Transform):
-    """Transform to model IPP problems
-
-    Usage details: 
-        * 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
-
-    Args:
-        sampling_rate (int): Number of points to sample between each pair of inducing points
-        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): 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. 
-                              If `True`, covariances corresponding to interpolated inducing points along each edge
-                              of the path are aggregated to reduce the matrix inversion cost.
-    """
-    def __init__(self, 
-                 sampling_rate=2, 
-                 distance_budget=None, 
-                 num_robots=1,
-                 Xu_fixed=None,
-                 num_dim=2,
-                 sensor_model=None,
-                 aggregate_fov=False,
-                 **kwargs):
-        super().__init__(**kwargs)
-        if sampling_rate < 2:
-            raise ValueError('Sampling rate must be greater than 2.')
-        
-        self.sampling_rate = sampling_rate
-        self.distance_budget = distance_budget
-        self.num_robots = num_robots
-        self.num_dim = num_dim
-        self.sensor_model = sensor_model
-
-        # Set aggregation size to sampling rate if aggregate_fov is True
-        # and sampling rate is enabled (greater than 2)
-        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:
-            self.Xu_fixed = tf.Variable(Xu_fixed, 
-                                        shape=tf.TensorShape(None), 
-                                        trainable=False)
-        else:
-            self.Xu_fixed = None
-
-    def update_Xu_fixed(self, Xu_fixed):
-        """Function to update the visited waypoints
-
-        Args:
-            Xu_fixed (ndarray): numpy array (num_robots, num_visited_waypoints, num_dim)
-        """
-        self.num_fixed = Xu_fixed.shape[1]
-        if self.Xu_fixed is not None:
-            self.Xu_fixed.assign(Xu_fixed)
-        else:
-            self.Xu_fixed = tf.Variable(Xu_fixed, 
-                                        shape=tf.TensorShape(None), 
-                                        trainable=False)
-
-    def expand(self, Xu, expand_sensor_model=True):
-        """Sample points between each pair of inducing points to form the path
-
-        Args:
-            Xu (ndarray): (num_robots x num_inducing, num_dim); Inducing points in the num_dim dimensional space
-            expand_sensor_model (bool): Only add the fixed inducing points without other sensor/path transforms, 
-                                        used for online IPP
-
-        Returns:
-            Xu (ndarray): Expansion transformed inducing points
-        """
-        # If using single-robot offline IPP with point sensing, return inducing points as is.
-        if self.sampling_rate == 2 and self.Xu_fixed is None and self.sensor_model is None:
-            return Xu
-        
-        Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
-        
-        # If using online IPP, add visited waypoints that won't be optimized anymore
-        if self.Xu_fixed is not None:
-            Xu = tf.concat([self.Xu_fixed, Xu[:, self.num_fixed:]], axis=1)
-
-        if not expand_sensor_model:
-            return tf.reshape(Xu, (-1, self.num_dim))
-
-        # Interpolate additional inducing points between waypoints to approximate 
-        # the continuous data sensing model
-        if self.sampling_rate > 2:
-            Xu = tf.linspace(Xu[:, :-1], Xu[:, 1:], self.sampling_rate)
-            Xu = tf.transpose(Xu, perm=[1, 2, 0, 3])
-            Xu = tf.reshape(Xu, (self.num_robots, -1, self.num_dim))
-
-        if self.sensor_model is not None:
-            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))
-        return Xu
-    
-    def aggregate(self, k):
-        """Applies the aggregation transform to kernel matrices. Checks `sensor_model` 
-           and uses the appropriate aggregation transform. 
-
-        Args:
-            k (tensor): (mp, mp)/(mp, n); Kernel matrix. 
-                        `m` is the number of inducing points,
-                        `p` is the number of points each inducing point is mapped,
-                        `n` is the number of training data points.
-
-        Returns:
-            k (tensor): (m, m)/(m, n); Aggregated kernel matrix
-        """
-        if self.sensor_model is not None:
-            return self.sensor_model.aggregate(k)
-        else:
-            return super().aggregate(k)
-        
-    def constraints(self, Xu):
-        """Computes the distance constraint term that is added to the SGP's optimization function.
-        Each robot can be assigned a different distance budget.
-
-        Args:
-            Xu (ndarray): Inducing points from which to compute the distance constraints
-
-        Returns:
-            loss (float): distance constraint term
-        """
-        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))
-            loss = -dist*self.constraint_weight
-            return loss
-
-    def distance(self, Xu):
-        """Computes the distance incured by sequentially visiting the inducing points
-        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 = tf.reshape(xy, (-1, 2))
-        return xy
-    
-    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))[:, :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
-
-    Args:
-        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_side, aggregate_fov=False, **kwargs):
-        super().__init__(**kwargs)
-        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):     
-        """
-        Applies the expansion transform to the inducing points
-
-        Args:
-            Xu (ndarray): (m, 3); Inducing points in the 3D position space.
-                        `m` is the number of inducing points,
-                        `3` is the dimension of the space (x, y, z)
-                        
-        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, h = tf.split(Xu, num_or_size_splits=3, axis=1)
-        x = tf.reshape(x, [-1,])
-        y = tf.reshape(y, [-1,])
-        h = tf.reshape(h, [-1,])
-
-        delta = h / (self.num_side - 1)
-
-        pts = []
-        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_side, 
-                                   axis=1))
-        xy = tf.concat(pts, axis=1)
-        xy = tf.transpose(xy, [2, 1, 0])
-        xy = tf.reshape(xy, [-1, 2])
-        xy = self._reshape(xy, tf.shape(Xu)[0])
-        return xy
-
-    def _reshape(self, X, num_inducing):
-        """Reorder the inducing points to be in the correct order for aggregation with square height 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
-    
-    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

@@ -1,115 +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.
-
-from apricot import CustomSelection
-from gpflow.models.gpr import GPR
-import numpy as np
-
-
-class GreedyMI:
-    """Helper class to compute mutual information using a Gaussian process for a given set of sensor locations.
-    Used by `get_greedy_mi_sol` function to compute the solution sensor placements using the Greedy-MI method.
-
-    Refer to the following papers for more details:
-        - Near-Optimal Sensor Placements in Gaussian Processes: Theory, Efficient Algorithms and Empirical Studies [Krause et al., 2008]
-        - Data-driven learning and planning for environmental sampling [Ma et al., 2018]
-
-    Args:
-        S (ndarray): (n, d); Candidate sensor placement locations
-        V (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, 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)
-    
-        if len(A) == 0:
-            sigma_a = 1.0
-        else:
-            if self.transform is not None:
-                A = self.transform.expand(A)
-            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∪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:
-            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 = 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()
-
-
-def get_greedy_mi_sol(num_sensors, candidates, X_train, noise_variance, kernel, 
-                      transform=None, optimizer='naive'):
-    """Get sensor placement solutions using the GP-based mutual information approach (submodular objective function). 
-    Uses a greedy algorithm to select sensor placements from a given discrete set of candidates locations.
-
-    Refer to the following papers for more details:
-        - Near-Optimal Sensor Placements in Gaussian Processes: Theory, Efficient Algorithms and Empirical Studies [Krause et al., 2008]
-        - Data-driven learning and planning for environmental sampling [Ma et al., 2018]
-
-    Args:
-        num_sensors (int): Number of sensor locations to optimize
-        candidates (ndarray): (n, d); Candidate sensor placement locations
-        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
-        optimizer (str): Name of an optimizer available in the apricot library
-
-    Returns:
-        Xu (ndarray): (m, d); Solution sensor placement locations
-    """
-    mi_model = GreedyMI(candidates, X_train, noise_variance, kernel, transform)
-    model = CustomSelection(num_sensors,
-                            mi_model.mutual_info,
-                            optimizer=optimizer,
-                            verbose=False)
-    sol = model.fit_transform(np.arange(len(candidates)).reshape(-1, 1))
-    return candidates[sol.reshape(-1)]

sgptools/models/greedy_sgp.py

@@ -1,97 +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.
-
-from .core.augmented_sgpr import AugmentedSGPR
-from apricot import CustomSelection
-import numpy as np
-
-
-class GreedySGP:
-    """Helper class to compute SGP's ELBO/optimization bound for a given set of sensor locations.
-    Used by `get_greedy_sgp_sol` function to compute the solution sensor placements using the Greedy-SGP method.
-
-    Refer to the following papers for more details:
-        - Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces [[Jakkala and Akella, 2023](https://www.itskalvik.com/publication/sgp-sp/)]
-
-    Args:
-        num_inducing (int): Number of inducing points
-        S (ndarray): (n, d); Candidate sensor placement locations
-        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
-        transform (Transform): Transform object
-    """
-    def __init__(self, num_inducing, S, V, noise_variance, kernel, 
-                 transform=None):
-        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.num_inducing = num_inducing
-        self.inducing_dim = S.shape[1]
-
-    def bound(self, x):
-        """Computes the SGP's optimization bound using the inducing points `x` 
-
-        Args:
-            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]
-
-        # Copy all given solution placements to the inducing points set
-        Xu[-len(x):] = self.locs[x]
-
-        # 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, 
-                       transform=None):
-    """Get sensor placement solutions using the Greedy-SGP method. Uses a greedy algorithm to 
-    select sensor placements from a given discrete set of candidates locations.
-
-    Refer to the following papers for more details:
-        - Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces [[Jakkala and Akella, 2023](https://www.itskalvik.com/publication/sgp-sp/)]
-
-    Args:
-        num_sensors (int): Number of sensor locations to optimize
-        candidates (ndarray): (n, d); Candidate sensor placement locations
-        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
-
-    Returns:
-        Xu (ndarray): (m, d); Solution sensor placement locations
-    """
-    sgp_model = GreedySGP(num_sensors, candidates, X_train, 
-                          noise_variance, kernel, transform=transform)
-    model = CustomSelection(num_sensors,
-                            sgp_model.bound,
-                            optimizer='naive',
-                            verbose=False)
-    sol = model.fit_transform(np.arange(len(candidates)).reshape(-1, 1))
-    return candidates[sol.reshape(-1)]

sgptools-1.2.0.dist-info/METADATA

@@ -1,39 +0,0 @@
-Metadata-Version: 2.2
-Name: sgptools
-Version: 1.2.0
-Summary: Software Suite for Sensor Placement and Informative Path Planning
-Home-page: https://www.itskalvik.com/sgp-tools
-Author: Kalvik
-Author-email: itskalvik@gmail.com
-License: Apache-2.0
-Requires-Python: >=3.6
-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
-Dynamic: author
-Dynamic: author-email
-Dynamic: description
-Dynamic: home-page
-Dynamic: license
-Dynamic: requires-dist
-Dynamic: requires-python
-Dynamic: summary
-
-Software Suite for Sensor Placement and Informative Path Planning