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

sgptools/utils/tsp.py

@@ -12,6 +12,8 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 
+from typing import List, Optional, Tuple
+
 from ortools.constraint_solver import routing_enums_pb2
 from ortools.constraint_solver import pywrapcp
 from sklearn.metrics import pairwise_distances
@@ -19,38 +21,44 @@ from shapely.geometry import LineString
 import numpy as np
 
 
-def run_tsp(nodes, 
-            num_vehicles=1, 
-            max_dist=25, 
-            depth=1, 
-            resample=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
-    
+def run_tsp(
+    nodes: np.ndarray,
+    num_vehicles: int = 1,
+    max_dist: float = 25.0,
+    depth: int = 1,
+    resample: Optional[int] = None,
+    start_nodes: Optional[np.ndarray] = None,
+    end_nodes: Optional[np.ndarray] = None,
+    time_limit: int = 10,
+) -> Tuple[Optional[np.ndarray], Optional[List[float]]]:
+    """Method to run TSP/VRP with arbitrary start and end nodes,
+    and without any distance constraint.
+
     Args:
-        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_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
+        nodes (np.ndarray): (# nodes, ndim); Nodes to visit.
+        num_vehicles (int): Number of robots/vehicles.
+        max_dist (float): Maximum distance allowed for each path when handling multi-robot case.
+        depth (int): Internal parameter used to track re-try recursion depth.
+        resample (Optional[int]): Each solution path will be resampled to have
+                                   `resample` number of points.
+        start_nodes (Optional[np.ndarray]): (# num_vehicles, ndim); Optional array of start nodes from which
+                                             to start each vehicle's solution path.
+        end_nodes (Optional[np.ndarray]): (# num_vehicles, ndim); Optional array of end nodes at which
+                                           to end each vehicle's solution path.
+        time_limit (int): TSP runtime time limit in seconds.
 
     Returns:
-        paths (ndarray): Solution paths
-        distances (list): List of path lengths
+        Tuple[Optional[np.ndarray], Optional[List[float]]]:
+            - paths (np.ndarray): Solution paths if found, otherwise None.
+            - distances (List[float]): List of path lengths if paths are found, otherwise None.
     """
     if depth > 5:
         print('Warning: Max depth reached')
         return None, None
-           
+
+    # Backup original nodes
+    original_nodes = np.copy(nodes)
+
     # 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]), \
@@ -63,27 +71,27 @@ def run_tsp(nodes,
 
     # Add dummy 0 location to get arbitrary start and end node sols
     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 #shift to account for dummy node
+        distance_mat = np.zeros((len(nodes) + 1, len(nodes) + 1))
+        distance_mat[1:, 1:] = pairwise_distances(nodes, nodes) * 1e4
+        trim_paths = True  #shift to account for dummy node
     else:
-        distance_mat = pairwise_distances(nodes, nodes)*1e4
+        distance_mat = pairwise_distances(nodes, nodes) * 1e4
         trim_paths = False
     distance_mat = distance_mat.astype(int)
-    max_dist = int(max_dist*1e4)
+    max_dist = int(max_dist * 1e4)
 
     # 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)
+        start_idx = np.arange(num_vehicles) + int(trim_paths)
         num_start_nodes = len(start_nodes)
 
     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)
+        end_idx = np.arange(num_vehicles) + num_start_nodes + int(trim_paths)
 
     # used by ortools
     def distance_callback(from_index, to_index):
@@ -92,8 +100,7 @@ def run_tsp(nodes,
         return distance_mat[from_node][to_node]
 
     # num_locations, num vehicles, start, end
-    manager = pywrapcp.RoutingIndexManager(len(distance_mat), 
-                                           num_vehicles, 
+    manager = pywrapcp.RoutingIndexManager(len(distance_mat), num_vehicles,
                                            start_idx.tolist(),
                                            end_idx.tolist())
     routing = pywrapcp.RoutingModel(manager)
@@ -115,46 +122,141 @@ def run_tsp(nodes,
 
     search_parameters = pywrapcp.DefaultRoutingSearchParameters()
     search_parameters.first_solution_strategy = (
-        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC
-    )
+        routing_enums_pb2.FirstSolutionStrategy.PATH_CHEAPEST_ARC)
     search_parameters.local_search_metaheuristic = (
-        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH
-    )
+        routing_enums_pb2.LocalSearchMetaheuristic.GUIDED_LOCAL_SEARCH)
     search_parameters.time_limit.seconds = time_limit
     solution = routing.SolveWithParameters(search_parameters)
-       
-    paths = None
+
+    paths: Optional[List[np.ndarray]] = None
+    distances: Optional[List[float]] = None
+
     if solution is not None:
-        paths, distances = get_routes(manager, routing, 
-                                      solution, num_vehicles, 
-                                      start_idx, end_idx, trim_paths)
-        for path in paths:
+        paths_indices, distances_raw = _get_routes(manager, routing, solution,
+                                                   num_vehicles, start_idx,
+                                                   end_idx, trim_paths)
+
+        # Check for empty paths and retry with increased max_dist if necessary
+        for path in paths_indices:
             if len(path) < 2:
-                print('TSP Warning: Empty path detected')
-                return run_tsp(nodes, num_vehicles, int(np.mean(distances)*(1.5/depth)), depth+1)
-    else:
-        print('TSP Warning: No solution found')
-        return run_tsp(nodes, num_vehicles, int(max_dist*1.5), depth+1)
+                print(
+                    "TSP Warning: Empty path detected, retrying with increased max_dist."
+                )
+                # Recalculate max_dist based on the current average distance
+                mean_dist = np.mean(
+                    distances_raw) / 1e4 if distances_raw else max_dist
+                return run_tsp(
+                    original_nodes,
+                    num_vehicles,
+                    mean_dist * (1.5 / depth),
+                    depth + 1,
+                    resample,
+                    start_nodes,
+                    end_nodes,
+                    time_limit,
+                )
+        paths = [nodes[path] for path in paths_indices]
+        distances = [d / 1e4 for d in distances_raw]
 
-    # Map paths from node indices to node locations
-    paths = [nodes[path] for path in paths]
+    else:
+        print(
+            "TSP Warning: No solution found, retrying with increased max_dist."
+        )
+        return run_tsp(
+            original_nodes,
+            num_vehicles,
+            max_dist * 1.5,
+            depth + 1,
+            resample,
+            start_nodes,
+            end_nodes,
+            time_limit,
+        )
 
     # Resample each solution path to have resample number of points
-    if resample is not None:
+    if resample is not None and paths is not None:
         paths = np.array([resample_path(path, resample) for path in paths])
 
-    # Convert distances back to floats in the original scale of the nodes
-    distances = np.array(distances)/1e4
     return paths, distances
-    
-'''
-Method to extract route from or-tools solution
-'''
-def get_routes(manager, routing, solution, num_vehicles, start_idx, end_idx, trim_paths):
-    paths = []
-    distances = []
+
+
+def _get_routes(
+    manager: pywrapcp.RoutingIndexManager,
+    routing: pywrapcp.RoutingModel,
+    solution: pywrapcp.Assignment,
+    num_vehicles: int,
+    start_idx: np.ndarray,
+    end_idx: np.ndarray,
+    trim_paths: bool,
+) -> Tuple[Optional[List[np.ndarray]], Optional[List[float]]]:
+    """
+    Solves the Traveling Salesperson Problem (TSP) or Vehicle Routing Problem (VRP)
+    using Google OR-Tools. This method supports multiple vehicles/robots, optional
+    start and end nodes for each vehicle, and an optional maximum distance constraint
+    per path. It also includes a retry mechanism with increased maximum distance
+    if no solution is found.
+
+    Args:
+        nodes (np.ndarray): (# nodes, ndim); A NumPy array of coordinates for all nodes (locations)
+                            that need to be visited. `ndim` is the dimensionality (e.g., 2 for 2D, 3 for 3D).
+        num_vehicles (int): The number of vehicles (robots) available to visit the nodes. Defaults to 1.
+        max_dist (float): The maximum allowed travel distance for each vehicle's path.
+                          This constraint is particularly relevant for multi-vehicle scenarios. Defaults to 25.0.
+        depth (int): Internal parameter used to track the recursion depth for retries when
+                     no solution is found. Users should typically not modify this. Defaults to 1.
+        resample (Optional[int]): If provided, each solution path will be resampled to have
+                                  exactly `resample` number of points (waypoints). This is useful
+                                  for standardizing path representations. Defaults to None.
+        start_nodes (Optional[np.ndarray]): (# num_vehicles, ndim); Optional NumPy array specifying
+                                            the starting coordinates for each vehicle. If None,
+                                            OR-Tools will find arbitrary start points. Defaults to None.
+        end_nodes (Optional[np.ndarray]): (# num_vehicles, ndim); Optional NumPy array specifying
+                                          the ending coordinates for each vehicle. If None,
+                                          OR-Tools will find arbitrary end points. Defaults to None.
+        time_limit (int): The maximum time (in seconds) that OR-Tools will spend searching for a solution.
+                          Defaults to 10.
+
+    Returns:
+        Tuple[Optional[List[np.ndarray]], Optional[List[float]]]:
+        - If a solution is found:
+            Tuple[List[np.ndarray], List[float]]: A tuple containing:
+                - paths (List[np.ndarray]): A list of NumPy arrays, where each array
+                                            represents a vehicle's path (sequence of visited nodes).
+                                            Shape of each array: (num_waypoints, ndim).
+                - distances (List[float]): A list of floats, where each float is the
+                                           total length of the corresponding vehicle's path.
+        - If no solution is found after retries:
+            Tuple[None, None]: Returns `(None, None)`.
+
+    Usage:
+        ```python
+        import numpy as np
+        from sgptools.utils.tsp import run_tsp
+
+        # Example 1: Single TSP, find best path through 5 points
+        nodes_single = np.array([[0,0], [1,1], [0,2], [2,2], [1,0]], dtype=np.float64)
+        paths_single, dists_single = run_tsp(nodes_single, num_vehicles=1, time_limit=5)
+
+        # Example 2: Multi-robot VRP with start/end nodes and resampling
+        nodes_multi = np.array([[1,1], [2,2], [3,3], [4,4], [5,5], [6,6]], dtype=np.float64)
+        start_points = np.array([[0,0], [7,7]], dtype=np.float64)
+        end_points = np.array([[0,7], [7,0]], dtype=np.float64)
+
+        paths_multi, dists_multi = run_tsp(
+            nodes_multi,
+            num_vehicles=2,
+            max_dist=10.0, # Max distance for each robot
+            resample=10,   # Resample each path to 10 points
+            start_nodes=start_points,
+            end_nodes=end_points,
+            time_limit=15
+        )
+        ```
+    """
+    paths: List[np.ndarray] = []
+    distances: List[int] = []
     for vehicle_id in range(num_vehicles):
-        path = []
+        path: List[int] = []
         route_distance = 0
         index = routing.Start(vehicle_id)
         while not routing.IsEnd(index):
@@ -162,39 +264,77 @@ def get_routes(manager, routing, solution, num_vehicles, start_idx, end_idx, tri
             previous_index = index
             index = solution.Value(routing.NextVar(index))
             route_distance += routing.GetArcCostForVehicle(
-                previous_index, index, vehicle_id
-            )
+                previous_index, index, vehicle_id)
         path.append(manager.IndexToNode(index))
         distances.append(route_distance)
-        # remove dummy start/end point
+
+        # Remove dummy start/end points if they were added
         if trim_paths:
-            path = np.array(path)-1
-            if start_idx[vehicle_id] == 0:
-                path = path[1:]
-            if end_idx[vehicle_id] == 0:
-                path = path[:-1]
-        paths.append(path)
+            path_array = np.array(path)
+            # Adjust indices if a dummy node was added at the beginning
+            if (start_idx[vehicle_id] == 0 and path_array[0] == 0
+                    and path_array.shape[0] > 1):
+                path_array = path_array[1:]
+            # Adjust indices if a dummy node was added at the end
+            if (end_idx[vehicle_id] == 0 and path_array[-1] == 0
+                    and path_array.shape[0] > 0):
+                path_array = path_array[:-1]
+
+            # Shift all indices down by 1 if a dummy node was prepended to the overall distance matrix
+            if np.any(start_idx == 0) or np.any(end_idx == 0):
+                path_array = path_array - 1
+                path_array = path_array[
+                    path_array
+                    >= 0]  # Ensure no negative indices from the shift
+
+            paths.append(path_array)
+        else:
+            paths.append(np.array(path))
     return paths, distances
 
-def resample_path(waypoints, num_inducing=10):
-    """Function to map path with arbitrary number of waypoints to 
-    inducing points path with fixed number of waypoints
+
+def resample_path(waypoints: np.ndarray, num_inducing: int = 10) -> np.ndarray:
+    """Resamples a given path (sequence of waypoints) to have a fixed number of
+    `num_inducing` points. This is useful for standardizing path representations
+    or for converting a path with an arbitrary number of waypoints into a
+    fixed-size representation for models. The resampling maintains the path's
+    shape and geometric integrity.
 
     Args:
-        waypoints (ndarray): (num_waypoints, ndim); waypoints of path from vrp solver
-        num_inducing (int): Number of inducing points (waypoints) in the returned path
-        
+        waypoints (np.ndarray): (num_waypoints, ndim); A NumPy array representing the
+                                waypoints of a path. `num_waypoints` is the original
+                                number of points, `ndim` is the dimensionality.
+        num_inducing (int): The desired number of points in the resampled path. Defaults to 10.
+
     Returns:
-        points (ndarray): (num_inducing, ndim); Resampled path
+        np.ndarray: (num_inducing, ndim); The resampled path with `num_inducing` points.
+
+    Raises:
+        Exception: If the input `ndim` is not 2 or 3 (as `shapely.geometry.LineString`
+                   primarily supports 2D/3D geometries).
+
+    Usage:
+        ```python
+        import numpy as np
+        from sgptools.utils.tsp import resample_path
+
+        # Example 2D path
+        original_path_2d = np.array([[0,0], [1,5], [3,0], [5,5]], dtype=np.float64)
+        resampled_path_2d = resample_path(original_path_2d, num_inducing=5)
+
+        # Example 3D path
+        original_path_3d = np.array([[0,0,0], [1,1,1], [2,0,2]], dtype=np.float64)
+        resampled_path_3d = resample_path(original_path_3d, num_inducing=7)
+        ```
     """
     ndim = np.shape(waypoints)[-1]
-    if not (ndim==2 or ndim==3):
+    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]
-    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
+    if ndim == 2:
+        resampled_points = np.array([[p.x, p.y] for p in points])
+    elif ndim == 3:
+        resampled_points = np.array([[p.x, p.y, p.z] for p in points])
+    return resampled_points

sgptools-2.0.0.dist-info/METADATA

@@ -0,0 +1,216 @@
+Metadata-Version: 2.4
+Name: sgptools
+Version: 2.0.0
+Summary: A Python library for efficient sensor placement and informative path planning
+Home-page: https://www.SGP-Tools.com
+Author: Kalvik
+Author-email: itskalvik@gmail.com
+License: Apache-2.0
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Requires-Python: >=3.6
+Description-Content-Type: text/markdown
+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
+Requires-Dist: geopandas
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license
+Dynamic: license-file
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+<p align="center">
+  <img src="docs/assets/SGP-Tools.png#gh-light-mode-only" alt="SGP-Tools Logo" width="600"/>
+  <img src="docs/assets/logo_dark.png#gh-dark-mode-only" alt="SGP-Tools Logo" width="600"/>
+</p>
+
+<p align="center">
+  <em>A Python library for efficient sensor placement and informative path planning</em>
+</p>
+
+<p align="center">
+  <a href="https://pypi.org/project/sgptools/"><img alt="PyPI" src="https://img.shields.io/pypi/v/sgptools.svg"></a>
+  <a href="https://github.com/itskalvik/sgptools/blob/main/LICENSE"><img alt="License" src="https://img.shields.io/pypi/l/sgptools.svg"></a>
+</p>
+
+<p align="center">
+  <img src="docs/assets/point_sensing.gif" width="49%">
+  <img src="docs/assets/non-point_sensing.gif" width="49%">
+  <img src="docs/assets/AIPP-4R.gif" width="49%">
+  <img src="docs/assets/AIPP-non-point_sensing.gif" width="49%">
+</p>
+
+## What is SGP-Tools?
+
+**SGP-Tools** is a powerful and flexible Python library designed for solving **Sensor Placement** and **Informative Path Planning** problems, enabling efficient and scalable solutions for environment monitoring, e.g., monitoring air/water quality, soil moisture, or temperature.
+
+### Sensor Placement
+
+**Sensor Placement** is the problem of finding ideal locations to deploy a set of static sensors to best monitor a spatial phenomenon. The goal is to select a finite number of locations from a continuous space or a discrete set of candidates to maximize the information gathered about an entire area of interest. This is crucial when deploying a limited number of sensors to cover a large field.
+
+### Informative Path Planning (IPP)
+
+**Informative Path Planning** extends this concept to mobile sensors. Instead of finding static locations, IPP aims to compute an informative path for one or more robots to travel along. The path is designed to maximize information gain about the environment, often while adhering to constraints such as a limited travel distance. This is essential for applications like aerial surveying or robotic exploration.
+
+### IPP vs. Lawnmower Paths
+
+A common approach to surveying an area is to use a "lawnmower" path, a simple back-and-forth pattern designed for complete coverage. The following table summarizes the key differences between IPP and Lawnmower Paths:
+
+| Factor | Lawnmower Path | Informative Path Planning (IPP) |
+| :--- | :--- | :--- |
+| **Primary Goal** | Complete and uniform coverage of a predefined area. | Targeted data collection in areas of high information or uncertainty. |
+| **Performance** | Slow data collection but provides a high accuracy reconstruction of the envionment. | Fast data collection but provides an approximate reconstruction of the envionment. |
+| **Prior Knowledge** | Not required; often used when no prior information is available. | Beneficial, but not required for adaptiev IPP; uses prior information to guide the sampling strategy. |
+| **Adaptability** | Non-adaptive; the path is fixed before the mission starts. | Highly adaptive; the path is updated in real-time based on sensor data. |
+| **Efficiency** | Can be inefficient if the phenomenon of interest is sparse. | Highly efficient for sparse or spatially variable phenomena. |
+| **Computational Cost** | Low; simple to plan and execute. | Medium; requires onboard processing to analyze data and update the path. |
+| **Best For** | Baseline mapping, homogenous environments, initial surveys. | Dynamic phenomena, resource-constrained missions. |
+
+## Why SGP-Tools?
+
+-   **State-of-the-Art Algorithms**: Includes a variety of optimization methods including greedy algorithms, Bayesian optimization, CMA-ES, and SGP-based optimization.
+-   **Advanced Modeling Capabilities**: Go beyond simple point sensing with tools for informative path planning for multi-robot systems and complex sensor field-of-view (FoV) models.
+-   **Non-Stationary Kernels**: Capture complex, real-world phenomena with specialized non-stationary kernels like the Neural Spectral Kernel and the Attentive Kernel.
+-   **Flexible and Extensible**: Built on GPflow and TensorFlow, the library is designed to be modular and easy to extend with your own custom methods, kernels, and objectives.
+
+## Installation
+The library is available as a ```pip``` package. To install the package, run the following command:
+
+```
+python3 -m pip install sgptools
+```
+
+Installation from source:
+
+```
+git clone https://github.com/itskalvik/sgp-tools.git
+cd sgp-tools/
+python3 -m pip install -r requirements.txt
+python3 -m pip install -e .
+```
+
+Note: The requirements.txt file contains packages and their latest versions that were last verified to be working without any issues.
+
+## Quick Start
+
+Here's an example of how to use SGP-Tools to get an informative path using the `ContinuousSGP` method:
+
+```python
+from sgptools.utils.data import Dataset # Class for loading and managing datasets
+from sgptools.utils.misc import get_inducing_pts # Utility for selecting inducing points
+from sgptools.utils.tsp import run_tsp # TSP/VRP solver for initial path planning
+from sgptools.utils.gpflow import get_model_params # For training initial GP/SGP hyperparameters
+from sgptools.methods import get_method # Gets the class for continuous SGP optimization
+from sgptools.core.transformations import IPPTransform # Transforms for IPP
+
+# 1. Load or generate a dataset
+# This will create a synthetic dataset for demonstration
+dataset = Dataset(num_train=500, num_test=10000, 
+                  shape=(100, 100))
+X_train, y_train = dataset.get_train()
+X_test, y_test = dataset.get_test()
+
+# 2. Learn the GP hyperparameters from the training data
+print("Learning GP hyperparameters...")
+_, noise_variance, kernel = get_model_params(
+    X_train, y_train, max_steps=1000, verbose=True
+)
+
+# 3. Setup the IPP model
+num_placements = 15
+
+# Initialize inducing points and get initial path
+Xu_init = get_inducing_pts(X_train, num_placements)
+Xu_init, _ = run_tsp(Xu_init, time_limit=10)
+
+# Setup IPP transform with a sampling rate for continuous sensing
+transform_continuous_sensing = IPPTransform(sampling_rate=4)
+
+# Initialize the ContinuousSGP model
+method = get_method('ContinuousSGP')
+csgp_optimizer = method(
+    num_placements, 
+    X_train, 
+    kernel,
+    noise_variance, 
+    transform_continuous_sensing,
+    X_init=Xu_init[0]
+)
+
+# 4. Run the optimization
+print("Optimizing sensor placements...")
+solution_path = csgp_optimizer.optimize(max_steps=200)
+
+print(f"Solution Path: {solution_path}")
+```
+
+<p align="center">
+  <img src="docs/assets/quick_start.png" width="600">
+</p>
+
+For more detailed instructions, please refer to our [tutorials](http://sgp-tools.com/tutorials/index.html)
+
+## SGP-based IPP
+[![Video Summary](https://res.cloudinary.com/marcomontalbano/image/upload/v1713536416/video_to_markdown/images/youtube--G-RKFa1vNHM-c05b58ac6eb4c4700831b2b3070cd403.jpg)](https://www.youtube.com/embed/G-RKFa1vNHM?si=PLmrmkCwXRj7mc4A "Video Summary")
+
+## Datasets
+High-resolution topography and bathymetry data can be downloaded from [NOAA Digital Coast](https://coast.noaa.gov/digitalcoast/)
+
+## About
+Please consider citing the following papers if you use SGP-Tools in your academic work 😄
+
+```
+@misc{JakkalaA23SP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Efficient Sensor Placement from Regression with Sparse Gaussian Processes in Continuous and Discrete Spaces},
+NOTE= {Preprint},
+YEAR={2023},
+URL={https://www.itskalvik.com/research/publication/sgp-sp/},
+}
+
+@inproceedings{JakkalaA24IPP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Multi-Robot Informative Path Planning from Regression with Sparse Gaussian Processes},
+booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
+YEAR={2024},
+PUBLISHER = {{IEEE}},
+URL={https://www.itskalvik.com/research/publication/sgp-ipp/}
+}
+
+@inproceedings{JakkalaA25AIPP,
+AUTHOR={Kalvik Jakkala and Srinivas Akella},
+TITLE={Fully Differentiable Adaptive Informative Path Planning},
+booktitle={IEEE International Conference on Robotics and Automation, {ICRA}},
+YEAR={2025},
+PUBLISHER = {{IEEE}},
+URL={https://www.itskalvik.com/research/publication/sgp-aipp/}
+}
+``` 
+
+## Acknowledgements
+This work was funded in part by the UNC Charlotte Office of Research and Economic Development and by NSF under Award Number IIP-1919233.

sgptools-2.0.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+sgptools/__init__.py,sha256=G2en4FsMUDwwaPFYm6zJX8rMAqMiWGRv3F5izvugFJA,442
+sgptools/methods.py,sha256=KB7hCs_EqoC-EpSB60ywCWdSGXThR-i_JRpI6WBoN20,46274
+sgptools/objectives.py,sha256=8rhKz-s7rwLRN-nHptGUTItmYhOzc0hNkNsSx2NVQGg,10655
+sgptools/core/__init__.py,sha256=OA3EJxpq93HD1_8dlbusW9WoP0BgCrXhJbA7c794Vu0,28
+sgptools/core/augmented_gpr.py,sha256=xURuUSLrWltAMiM7cMTMV_AqUBh3cxESunuO_eUY7sc,3428
+sgptools/core/augmented_sgpr.py,sha256=ZtCsYB1hEq0PW0kAm5-N-EEPOgPRltL2MihSHmHPdYc,7230
+sgptools/core/osgpr.py,sha256=CnpBg5RQjylFqhUL0tcrSXlRcmek6ajtZ9VmTxuv7ao,18912
+sgptools/core/transformations.py,sha256=GxHkCUhO4639TtaSquNAYFJT-RymO_I3nzfWKv77ibY,33686
+sgptools/kernels/__init__.py,sha256=G-o4JY9Hg2i9YBwp6B95nbLfqKxdZ1SkyhsplrSdBds,31
+sgptools/kernels/attentive_kernel.py,sha256=6Ua2GymZSAurQPszrMQaCnbnfIz8tBX5raCWhPrYR64,11796
+sgptools/kernels/neural_kernel.py,sha256=jo9NqyzRcpMrRNyHTmLUvLD2KWbEkDiiEVPb6Z5FmkI,15506
+sgptools/kernels/neural_network.py,sha256=bVmS0o3eAags4SBE_7NXqC2KIK9F7kM2pDFESvpihH0,6872
+sgptools/utils/__init__.py,sha256=Dr5d9vCoeNGGtkebjQ6pSTghOrjm_zycmPkfRdcCHWo,29
+sgptools/utils/data.py,sha256=8KU4befi5SkmsRJ5W7LGZDhAchFGr2jnfz82PBvfZxQ,22864
+sgptools/utils/gpflow.py,sha256=FPy8_ST-IJr-sdcjZPB3iu-Dae_SkCSofbULxRc2O-o,19970
+sgptools/utils/metrics.py,sha256=M8Otd9Iiv6522OaAuhYRF7x2WeSvNdtjxtyhUneqAMU,18290
+sgptools/utils/misc.py,sha256=ZkPz3kHuy_1zcnnA74mJ1GjveWHF6eTZK2yX2JWOPI0,8686
+sgptools/utils/tsp.py,sha256=wIyg91KdJh_zsQ7_nOCgV2BIYKoxEE1tCVYFORU3Yrg,15257
+sgptools-2.0.0.dist-info/licenses/LICENSE.txt,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+sgptools-2.0.0.dist-info/METADATA,sha256=ggG8j2395qCiNB0g2q8SQpNkHujLOiWUA1xoZcQA1O0,9713
+sgptools-2.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+sgptools-2.0.0.dist-info/top_level.txt,sha256=2NWH6uQLAOuLB9fG7o1pqf6Jvpe1_hEcuqfSqtUw3gw,9
+sgptools-2.0.0.dist-info/RECORD,,

{sgptools-1.2.0.dist-info → sgptools-2.0.0.dist-info}/WHEEL

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

sgptools/models/__init__.py

@@ -1,10 +0,0 @@
-# sgptools/models/__init__.py
-
-"""Sensor placement and informative path planning methods in this package:
-
-- `bo`: Provides a Bayesian optimization based approach that maximizes mutual-information to get sensor placements
-- `cma_es`: Provides a genetic algorithm (CMA-ES) based approach that maximizes mutual-information to get sensor placements
-- `continuous_sgp`: Provides an SGP-based sensor placement approach that is optimized using gradient descent
-- `greedy_mi`: Provides a greedy algorithm based approach that maximizes mutual-information to get sensor placements
-- `greedy_sgp`: Provides an SGP-based sensor placement approach that is optimized using a greedy algorithm
-"""