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

sgptools/__init__.py

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

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,10 @@ def get_model_params(X_train, y_train,
                      variance=1.0, 
                      noise_variance=0.1,
                      kernel=None,
+                     return_gp=False,
                      **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 +68,47 @@ 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
 
     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, 500)
+        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 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/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.2.dist-info → sgptools-1.1.4.dist-info}/METADATA

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

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

@@ -1,4 +1,4 @@
-sgptools/__init__.py,sha256=v20FWREF4GkLOyADat_DukZaWOptzI1Yt0RxT4JSY3o,449
+sgptools/__init__.py,sha256=99q8oLBb0hxIdFFxf9AWGmgcNMrJePEkcCRtn9K-iDI,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
@@ -14,12 +14,12 @@ sgptools/models/core/osgpr.py,sha256=gqliUdXdnt3fea206LP0rqGIggmIdKh8WP2DtFWzdBw
 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/gpflow.py,sha256=3Zw7iFg1pdrzAVih3dmt4y4NtJF4EMSioNVDR2DZ_sg,9575
 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.2.dist-info/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-sgptools-1.1.2.dist-info/METADATA,sha256=Ig-Y6qyVRqARqO4FODhkSOHUsjrrNI6Eaw96uVTNDmg,944
-sgptools-1.1.2.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
-sgptools-1.1.2.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
-sgptools-1.1.2.dist-info/RECORD,,
+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,,