sgptools 1.1.4__py3-none-any.whl → 1.1.7__py3-none-any.whl

sgptools/__init__.py

@@ -12,7 +12,7 @@ The library includes python code for the following:
 
 """
 
-__version__ = "1.1.4"
+__version__ = "1.1.7"
 __author__ = 'Kalvik'
 
 from .models.core import *

sgptools/models/core/osgpr.py

@@ -57,28 +57,39 @@ class OSGPR_VFE(GPModel, InternalDataTrainingLossMixin):
         self.Kaa_old = tf.Variable(Kaa_old, shape=tf.TensorShape(None), trainable=False)
         self.Z_old = tf.Variable(Z_old, shape=tf.TensorShape(None), trainable=False)
 
-    def update(self, data):
+    def init_Z(self):
+        M = self.inducing_variable.Z.shape[0]
+        M_old = int(0.7 * M)
+        M_new = M - M_old
+        old_Z = self.Z_old.numpy()[np.random.permutation(M)[0:M_old], :]
+        new_Z = self.X.numpy()[np.random.permutation(self.X.shape[0])[0:M_new], :]
+        Z = np.vstack((old_Z, new_Z))
+        return Z
+
+    def update(self, data, inducing_variable=None):
         """Configure the OSGPR to adapt to a new batch of data. 
         Note: The OSGPR needs to be trained using gradient-based approaches after update.
 
         Args:
-            data (tuple): (X, y) ndarrays with new batch of inputs (n, d) and labels (n, 1)
+            data (tuple): (X, y) ndarrays with new batch of inputs (n, d) and labels (n, ndim)
         """
         self.X, self.Y = self.data = gpflow.models.util.data_input_to_tensor(data)
         self.num_data = self.X.shape[0]
 
-        self.Z_old = tf.Variable(self.inducing_variable.Z.numpy(), 
-                                 shape=tf.TensorShape(None), 
-                                 trainable=False)
+        # Update the inducing points        
+        self.Z_old.assign(self.inducing_variable.Z.numpy())
+        if inducing_variable is None:
+            inducing_variable = self.init_Z()
+        self.inducing_variable.Z.assign(inducing_variable)
 
         # Get posterior mean and covariance for the old inducing points
         mu_old, Su_old = self.predict_f(self.Z_old, full_cov=True)
-        self.mu_old = tf.Variable(mu_old, shape=tf.TensorShape(None), trainable=False)
-        self.Su_old = tf.Variable(Su_old, shape=tf.TensorShape(None), trainable=False)
-        
+        self.mu_old.assign(mu_old.numpy())
+        self.Su_old.assign(Su_old.numpy())
+
         # Get the prior covariance matrix for the old inducing points
         Kaa_old = self.kernel(self.Z_old)
-        self.Kaa_old = tf.Variable(Kaa_old, shape=tf.TensorShape(None), trainable=False)
+        self.Kaa_old.assign(Kaa_old.numpy())
 
     def _common_terms(self):
         Mb = self.inducing_variable.num_inducing
@@ -228,7 +239,8 @@ def init_osgpr(X_train,
                lengthscales=1.0, 
                variance=1.0,
                noise_variance=0.001,
-               kernel=None):
+               kernel=None,
+               ndim=1):
     """Initialize a VFE OSGPR model with an RBF kernel with 
     unit variance and lengthcales, and 0.001 noise variance.
     Used in the Online Continuous SGP approach. 
@@ -243,6 +255,7 @@ def init_osgpr(X_train,
         variance (float): Kernel variance
         noise_variance (float): Data noise variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
+        ndim (int): Number of output dimensions
 
     Returns:
         online_param (OSGPR_VFE): Initialized online sparse Gaussian process model
@@ -252,7 +265,7 @@ def init_osgpr(X_train,
         kernel = gpflow.kernels.SquaredExponential(lengthscales=lengthscales, 
                                                    variance=variance)
         
-    y_train = np.zeros((len(X_train), 1), dtype=X_train.dtype)
+    y_train = np.zeros((len(X_train), ndim), dtype=X_train.dtype)
     Z_init = get_inducing_pts(X_train, num_inducing)
     init_param = gpflow.models.SGPR((X_train, y_train),
                                     kernel, 
@@ -261,8 +274,8 @@ def init_osgpr(X_train,
     
     # Initialize the OSGPR model using the parameters from the SGPR model
     # The X_train and y_train here will be overwritten in the online phase 
-    X_train = np.array([[0, 0], [0, 0]])
-    y_train = np.array([0, 0]).reshape(-1, 1)
+    X_train = np.zeros([2, X_train.shape[-1]], dtype=X_train.dtype)
+    y_train =  np.zeros([2, ndim], dtype=X_train.dtype)
     Zopt = init_param.inducing_variable.Z.numpy()
     mu, Su = init_param.predict_f(Zopt, full_cov=True)
     Kaa = init_param.kernel(Zopt)

sgptools/utils/data.py

@@ -120,6 +120,7 @@ def prep_synthetic_dataset(shape=(50, 50),
                            min_height=0.0, 
                            max_height=30.0, 
                            roughness=0.5,
+                           random_seed=None,
                            **kwargs):
     '''Generates a 50x50 grid of synthetic elevation data using the diamond square algorithm.
     
@@ -131,6 +132,7 @@ def prep_synthetic_dataset(shape=(50, 50),
         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
+        random_seed (int): Random seed for reproducibility
 
     Returns:
        X (ndarray): (n, d); Dataset input features
@@ -140,6 +142,7 @@ def prep_synthetic_dataset(shape=(50, 50),
                           min_height=min_height, 
                           max_height=max_height, 
                           roughness=roughness,
+                          random_seed=random_seed,
                           **kwargs)
 
     # create x and y coordinates from the extent

sgptools/utils/gpflow.py

@@ -53,6 +53,8 @@ def get_model_params(X_train, y_train,
                      noise_variance=0.1,
                      kernel=None,
                      return_gp=False,
+                     train_inducing_pts=False,
+                     num_inducing_pts=500,
                      **kwargs):
     """Train a GP on the given training set. 
     Trains a sparse GP if the training set is larger than 1000 samples.
@@ -69,6 +71,10 @@ def get_model_params(X_train, y_train,
         noise_variance (float): Data noise variance
         kernel (gpflow.kernels.Kernel): gpflow kernel function
         return_gp (bool): If True, returns the trained GP model
+        train_inducing_pts (bool): If True, trains the inducing points when
+                                   using a sparse GP model
+        num_inducing_pts (int): Number of inducing points to use when training
+                                a sparse GP model
 
     Returns:
         loss (list): Loss values obtained during training
@@ -88,12 +94,15 @@ def get_model_params(X_train, y_train,
                                 noise_variance=noise_variance)
         trainable_variables=gpr.trainable_variables
     else:
-        inducing_pts = get_inducing_pts(X_train, 500)
+        inducing_pts = get_inducing_pts(X_train, num_inducing_pts)
         gpr = gpflow.models.SGPR(data=(X_train, y_train), 
                                  kernel=kernel,
                                  inducing_variable=inducing_pts,
                                  noise_variance=noise_variance)
-        trainable_variables=gpr.trainable_variables[1:]
+        if train_inducing_pts:
+            trainable_variables=gpr.trainable_variables
+        else:
+            trainable_variables=gpr.trainable_variables[1:]
 
     if max_steps > 0:
         loss = optimize_model(gpr, max_steps=max_steps, lr=lr, 

sgptools/utils/misc.py

@@ -3,6 +3,8 @@ from .metrics import get_distance
 from scipy.optimize import linear_sum_assignment
 from sklearn.metrics import pairwise_distances
 from scipy.cluster.vq import kmeans2
+from shapely import geometry
+import geopandas as gpd
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -138,3 +140,23 @@ def project_waypoints(waypoints, candidates):
     waypoints_disc = cont2disc(waypoints, candidates)
     waypoints_valid = _reoder_path(waypoints, waypoints_disc)
     return waypoints_valid
+
+def ploygon2candidats(vertices, 
+                      num_samples=5000, 
+                      random_seed=2024):
+    """Sample unlabeled candidates within a polygon
+
+    Args:
+        vertices (ndarray): (v, 2) of vertices that define the polygon
+        num_samples (int): Number of samples to generate
+        random_seed (int): Random seed for reproducibility
+
+    Returns:
+       candidates (ndarray): (n, 2); Candidate sensor placement locations
+    """
+    poly = geometry.Polygon(vertices)
+    sampler = gpd.GeoSeries([poly])
+    candidates = sampler.sample_points(size=num_samples,
+                                       rng=random_seed)
+    candidates = candidates.get_coordinates().to_numpy()
+    return candidates

{sgptools-1.1.4.dist-info → sgptools-1.1.7.dist-info}/METADATA

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

{sgptools-1.1.4.dist-info → sgptools-1.1.7.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sgptools/__init__.py,sha256=99q8oLBb0hxIdFFxf9AWGmgcNMrJePEkcCRtn9K-iDI,449
+sgptools/__init__.py,sha256=dgJa5rLAj4qD6De6iK-MHAvh7CS7qJkPKrdj5zIXdgY,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
@@ -10,16 +10,16 @@ sgptools/models/greedy_sgp.py,sha256=giddMbU3ohePTdLTcH4fDx-bS9upq1T_K8KUW_Ag6HI
 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/osgpr.py,sha256=fyIRtNGWZeRRuojQJQAxDhMCUTKlmh5mXK3iddrPC8A,12199
 sgptools/models/core/transformations.py,sha256=X7WEKo_lFAYB5HKnFvxFsxfz6CB-jzPfVWcx1sWe2lI,18313
 sgptools/utils/__init__.py,sha256=jgWqzSDgUbqOTFo8mkqZaTlyz44l3v2XYPJfcHYHjqM,376
-sgptools/utils/data.py,sha256=oTXq4oRuzJdXpZC6frUfja8jhwy_ZdDDi7L1BYZcdQs,7309
-sgptools/utils/gpflow.py,sha256=3Zw7iFg1pdrzAVih3dmt4y4NtJF4EMSioNVDR2DZ_sg,9575
+sgptools/utils/data.py,sha256=ojDq6KzBXbAl5CdpA6A6me0sg5Sah9ZTl2TpFCqgR4c,7464
+sgptools/utils/gpflow.py,sha256=46-_Tl-suxvuX3Y9KI_uiixfyCWQ2T-7BUn-7hesdVM,10047
 sgptools/utils/metrics.py,sha256=tu8H129n8GuxV5fQIKLcfzPUxd7sp8zEF9qZBOZjNKo,5834
-sgptools/utils/misc.py,sha256=LdAFJS7-xubWpRnrgdLOorCa9vB_8vRrvL5cahxHYNA,5442
+sgptools/utils/misc.py,sha256=11nsDEU3imnrvH7ywGMiwtNBcBnJfHX3KaGxFS3eq6w,6223
 sgptools/utils/tsp.py,sha256=b1Lx1Pj-sv7siX-f0S6d25C3RtvszCl3IP4QbvBckqY,8151
-sgptools-1.1.4.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.1.4.dist-info/METADATA,sha256=o43iAz3oaqmk1E7uqGVyw4ya-YRgRwJJN-O3Y2wL_lQ,944
-sgptools-1.1.4.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sgptools-1.1.4.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.1.4.dist-info/RECORD,,
+sgptools-1.1.7.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.1.7.dist-info/METADATA,sha256=SE-g1VWus5SyoA0PUmEpgHcQ-UX1EUpVXHPSMW1yACU,944
+sgptools-1.1.7.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sgptools-1.1.7.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.1.7.dist-info/RECORD,,