sgptools 1.1.3__py3-none-any.whl → 1.1.6__py3-none-any.whl

sgptools/__init__.py

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

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

@@ -21,6 +21,8 @@ import tensorflow_probability as tfp
 import numpy as np
 import matplotlib.pyplot as plt
 
+from .misc import get_inducing_pts
+
 
 def plot_loss(losses, save_file=None):
     """Helper function to plot the training loss
@@ -50,8 +52,12 @@ def get_model_params(X_train, y_train,
                      variance=1.0, 
                      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
+    """Train a GP on the given training set. 
+    Trains a sparse GP if the training set is larger than 1000 samples.
 
     Args:
         X_train (ndarray): (n, d); Training set inputs
@@ -64,29 +70,54 @@ def get_model_params(X_train, y_train,
         variance (float): Kernel variance
         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
         variance (float): Optimized data noise variance
         kernel (gpflow.kernels.Kernel): Optimized gpflow kernel function
+        gp (gpflow.models.GPR): Optimized gpflow GP model. 
+                                Returned only if ```return_gp=True```.
+                                
     """
     if kernel is None:
         kernel = gpflow.kernels.SquaredExponential(lengthscales=lengthscales, 
                                                    variance=variance)
 
-    gpr_gt = gpflow.models.GPR(data=(X_train, y_train), 
-                               kernel=kernel,
-                               noise_variance=noise_variance)
+    if len(X_train) <= 1500:
+        gpr = gpflow.models.GPR(data=(X_train, y_train), 
+                                kernel=kernel,
+                                noise_variance=noise_variance)
+        trainable_variables=gpr.trainable_variables
+    else:
+        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)
+        if train_inducing_pts:
+            trainable_variables=gpr.trainable_variables
+        else:
+            trainable_variables=gpr.trainable_variables[1:]
 
     if max_steps > 0:
-        loss = optimize_model(gpr_gt, max_steps=max_steps, lr=lr, **kwargs)
+        loss = optimize_model(gpr, max_steps=max_steps, lr=lr, 
+                              trainable_variables=trainable_variables,
+                              **kwargs)
     else:
         loss = 0
 
     if print_params:
-        print_summary(gpr_gt)
+        print_summary(gpr)
     
-    return loss, gpr_gt.likelihood.variance, kernel
+    if return_gp:
+        return loss, gpr.likelihood.variance, kernel, gpr
+    else:
+        return loss, gpr.likelihood.variance, kernel
 
 
 class TraceInducingPts(gpflow.monitor.MonitorTask):

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

@@ -24,21 +24,23 @@ def run_tsp(nodes,
             max_dist=25, 
             depth=1, 
             resample=None, 
-            start_idx=None,
-            end_idx=None,
+            start_nodes=None,
+            end_nodes=None,
             time_limit=10):
     """Method to run TSP/VRP with arbitrary start and end nodes, 
     and without any distance constraint
     
     Args:
-        nodes (ndarray): (# nodes, n_dim); Nodes to visit 
+        nodes (ndarray): (# nodes, ndim); Nodes to visit 
         num_vehicles (int): Number of robots/vehicles
         max_dist (float): Maximum distance allowed for each path when handling mutli-robot case
         depth (int): Internal parameter used to track re-try recursion depth
         resample (int): Each solution path will be resampled to have
                         `resample` number of points
-        start_idx (list): Optionl list of start node indices from which to start the solution path 
-        end_idx (list): Optionl list of end node indices from which to start the solution path 
+        start_nodes (ndarray): (# num_vehicles, ndim); Optionl array of start nodes from which 
+                                to start each vehicle's solution path
+        end_nodes (ndarray): (# num_vehicles, ndim); Optionl array of end nodes at which 
+                                to end each vehicle's solution path
         time_limit (int): TSP runtime time limit in seconds
 
     Returns:
@@ -48,28 +50,42 @@ def run_tsp(nodes,
     if depth > 5:
         print('Warning: Max depth reached')
         return None, None
-        
+           
+    # Add the start and end nodes to the node list
+    if end_nodes is not None:
+        assert end_nodes.shape == (num_vehicles, nodes.shape[-1]), \
+            "Incorrect end_nodes shape, should be (num_vehicles, ndim)!"
+        nodes = np.concatenate([end_nodes, nodes])
+    if start_nodes is not None:
+        assert start_nodes.shape == (num_vehicles, nodes.shape[-1]), \
+            "Incorrect start_nodes shape, should be (num_vehicles, ndim)!"
+        nodes = np.concatenate([start_nodes, nodes])
+
     # Add dummy 0 location to get arbitrary start and end node sols
-    if start_idx is None or end_idx is None:
+    if start_nodes is None or end_nodes is None:
         distance_mat = np.zeros((len(nodes)+1, len(nodes)+1))
         distance_mat[1:, 1:] = pairwise_distances(nodes, nodes)*1e4
-        trim_paths = True
+        trim_paths = True #shift to account for dummy node
     else:
         distance_mat = pairwise_distances(nodes, nodes)*1e4
         trim_paths = False
     distance_mat = distance_mat.astype(int)
     max_dist = int(max_dist*1e4)
 
-    if start_idx is None:
-        start_idx = [0]*num_vehicles
-    elif trim_paths:
-        start_idx = [i+1 for i in start_idx]
+    # Get start and end node indices for ortools
+    if start_nodes is None:
+        start_idx = np.zeros(num_vehicles, dtype=int)
+        num_start_nodes = 0
+    else:
+        start_idx = np.arange(num_vehicles)+int(trim_paths)
+        num_start_nodes = len(start_nodes)
 
-    if end_idx is None:
-        end_idx = [0]*num_vehicles
-    elif trim_paths:
-        end_idx = [i+1 for i in end_idx]
+    if end_nodes is None:
+        end_idx = np.zeros(num_vehicles, dtype=int)
+    else:
+        end_idx = np.arange(num_vehicles)+num_start_nodes+int(trim_paths)
 
+    # used by ortools
     def distance_callback(from_index, to_index):
         from_node = manager.IndexToNode(from_index)
         to_node = manager.IndexToNode(to_index)
@@ -78,8 +94,8 @@ def run_tsp(nodes,
     # num_locations, num vehicles, start, end
     manager = pywrapcp.RoutingIndexManager(len(distance_mat), 
                                            num_vehicles, 
-                                           start_idx,
-                                           end_idx)
+                                           start_idx.tolist(),
+                                           end_idx.tolist())
     routing = pywrapcp.RoutingModel(manager)
     transit_callback_index = routing.RegisterTransitCallback(distance_callback)
     routing.SetArcCostEvaluatorOfAllVehicles(transit_callback_index)
@@ -165,14 +181,20 @@ def resample_path(waypoints, num_inducing=10):
     inducing points path with fixed number of waypoints
 
     Args:
-        waypoints (ndarray): (num_waypoints, n_dim); waypoints of path from vrp solver
+        waypoints (ndarray): (num_waypoints, ndim); waypoints of path from vrp solver
         num_inducing (int): Number of inducing points (waypoints) in the returned path
         
     Returns:
-        points (ndarray): (num_inducing, n_dim); Resampled path
+        points (ndarray): (num_inducing, ndim); Resampled path
     """
+    ndim = np.shape(waypoints)[-1]
+    if not (ndim==2 or ndim==3):
+        raise Exception(f"ndim={ndim} is not supported for path resampling!")
     line = LineString(waypoints)
     distances = np.linspace(0, line.length, num_inducing)
     points = [line.interpolate(distance) for distance in distances]
-    points = np.array([[p.x, p.y] for p in points])
+    if ndim==2:
+        points = np.array([[p.x, p.y] for p in points])
+    elif ndim==3:
+        points = np.array([[p.x, p.y, p.z] for p in points])
     return points

{sgptools-1.1.3.dist-info → sgptools-1.1.6.dist-info}/METADATA

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

{sgptools-1.1.3.dist-info → sgptools-1.1.6.dist-info}/RECORD

@@ -1,4 +1,4 @@
-sgptools/__init__.py,sha256=1nTYxJDM2wZiWHZRqjmWbREndmielrwcbbYLzCMmunc,449
+sgptools/__init__.py,sha256=ETsbfpEnORTg0xjJyWQSUNI7cSLKYCAr6QRluBeGzRs,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
@@ -13,13 +13,13 @@ sgptools/models/core/augmented_sgpr.py,sha256=qMP9J4AnOUx9AEZfaPhoyb3RP_2AOhOUCU
 sgptools/models/core/osgpr.py,sha256=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw,11798
 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=LnFYufnMW4ch7qsKnru53QUxEtIzJqE822qj6w8ssRg,8576
+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/tsp.py,sha256=RJAQ4_uE7CUtR1ei3nSnGy-1kNhw82E9P_HyaCkc4iI,7007
-sgptools-1.1.3.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.1.3.dist-info/METADATA,sha256=c1XktvlxtIJuD2UHF9NsZmipVI5RJqNoeMlo_E94T_M,944
-sgptools-1.1.3.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sgptools-1.1.3.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.1.3.dist-info/RECORD,,
+sgptools/utils/misc.py,sha256=11nsDEU3imnrvH7ywGMiwtNBcBnJfHX3KaGxFS3eq6w,6223
+sgptools/utils/tsp.py,sha256=b1Lx1Pj-sv7siX-f0S6d25C3RtvszCl3IP4QbvBckqY,8151
+sgptools-1.1.6.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-1.1.6.dist-info/METADATA,sha256=SXtfy54sXEKKFd7uPKkpDA7CCQUbAunhjl9YHE_hTRs,944
+sgptools-1.1.6.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+sgptools-1.1.6.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-1.1.6.dist-info/RECORD,,