Add py scripts and tests

Author: Saurav Agarwal

python/scripts/coverage_env/coverage_simple.py

@@ -0,0 +1,58 @@
+#  This file is part of the CoverageControl library
+#
+#  Author: Saurav Agarwal
+#  Contact: [email protected], [email protected]
+#  Repository: https://github.com/KumarRobotics/CoverageControl
+#
+#  Copyright (c) 2024, Saurav Agarwal
+#
+#  The CoverageControl library is free software: you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  The CoverageControl library is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#  Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  CoverageControl library. If not, see <https://www.gnu.org/licenses/>.
+
+import sys
+import coverage_control as cc
+# Algorithms available:
+# ClairvoyantCVT
+# CentralizedCVT
+# DecentralizedCVT
+# NearOptimalCVT
+from coverage_control.algorithms import ClairvoyantCVT as CoverageAlgorithm
+
+params = cc.Parameters()
+
+# CoverageSystem handles the environment and robots
+env = cc.CoverageSystem(params)
+
+init_cost = env.GetObjectiveValue()
+print("Initial Coverage cost: " + str('{:.2e}'.format(init_cost)))
+
+# Runs the coverage control algorithm
+controller = CoverageAlgorithm(params, env)
+
+for i in range(0, params.pEpisodeSteps):
+    # Compute actions to be taken by the robots
+    controller.ComputeActions();
+    # Get actions from the controller
+    actions = controller.GetActions()
+    # Send actions to the environment
+    if env.StepActions(actions):
+        print("Error in step " + str(i))
+        break
+
+    if controller.IsConverged():
+        print("Converged in step " + str(i))
+        break
+
+# print some metrics
+current_cost = env.GetObjectiveValue()
+print("Improvement %: " + str('{:.2f}'.format(100 * (init_cost - current_cost)/init_cost)))

python/scripts/data_generation/data_generation.py

@@ -1,39 +1,91 @@
+#  This file is part of the CoverageControl library
+#
+#  Author: Saurav Agarwal
+#  Contact: [email protected], [email protected]
+#  Repository: https://github.com/KumarRobotics/CoverageControl
+#
+#  Copyright (c) 2024, Saurav Agarwal
+#
+#  The CoverageControl library is free software: you can redistribute it and/or
+#  modify it under the terms of the GNU General Public License as published by
+#  the Free Software Foundation, either version 3 of the License, or (at your
+#  option) any later version.
+#
+#  The CoverageControl library is distributed in the hope that it will be
+#  useful, but WITHOUT ANY WARRANTY; without even the implied warranty of
+#  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General
+#  Public License for more details.
+#
+#  You should have received a copy of the GNU General Public License along with
+#  CoverageControl library. If not, see <https://www.gnu.org/licenses/>.
+
+# @file data_generation.py
+# This file contains the code to generate a dataset for learning
+# Prefer using simple_data_generation.py for generating a dataset
+# 
+
+# DataDir = "~/CoverageControl_ws/src/CoverageControl/" # Absolute path to the root of the repository
+# EnvironmentConfig = "params/coverage_control_params.toml" # Relative to DataDir
+#
+# NumDataset = 1000
+#
+# # Number of steps to take before data is stores
+# # This helps in creating a more diverse dataset
+# EveryNumSteps = 5
+#
+# # The robots stop moving once the algorithm has converged
+# # Having some of these converged steps can help in stabilizing robot actions
+# ConvergedDataRatio = 0.25
+#
+# # Resizing of maps and Sparsification of tensors are triggered every TriggerPostProcessing dataset
+# # This should be set based on RAM resources available on the system
+# TriggerPostProcessing = 100
+#
+# CNNMapSize = 32
+# SaveAsSparseQ = true
+# NormalizeQ = true
+#
+# [DataSetSplit]
+# TrainRatio = 0.7
+# ValRatio =  0.2
+
 import os
 import sys
 import torch
-import datetime
 import math
+import pathlib
+import datetime
 
-import pyCoverageControl as CoverageControl
-from pyCoverageControl import CoverageSystem
-from pyCoverageControl import LloydGlobalOnline as CoverageAlgorithm
-# from pyCoverageControl import OracleGlobalOffline as CoverageAlgorithm
-# from pyCoverageControl import LloydLocalSensorGlobalComm as CoverageAlgorithm
-import CoverageControlTorch as cct
-import CoverageControlTorch.data_loaders.data_loader_utils as dl_utils
-from CoverageControlTorch.utils.coverage_system import ToTensor
-import CoverageControlTorch.utils.coverage_system as CoverageSystemUtils
-
+import coverage_control
+from coverage_control import IOUtils
+from coverage_control import CoverageSystem
+from coverage_control.algorithms import ClairvoyantCVT as CoverageAlgorithm
+from coverage_control.nn import CoverageEnvUtils
 
 class DatasetGenerator():
-    def __init__(self, config_file):
+    def __init__(self, config_file, append_dir=None):
 
-        # Load configs and create directories
-        self.config = dl_utils.LoadToml(config_file)
-        self.data_dir = self.config['DataDir']
-        self.data_folder = self.data_dir + '/data/'
+        self.config = IOUtils.load_toml(config_file)
+        self.data_dir = IOUtils.sanitize_path(self.config['DataDir'])
+        self.dataset_dir = self.data_dir + '/data/'
+        if append_dir is not None:
+            self.dataset_dir += append_dir
 
-        if not os.path.exists(self.data_dir):
-            throw("Data directory does not exist")
+        if not pathlib.Path(self.data_dir).exists():
+            print(f'{self.data_dir} does not exist')
+            exit()
 
-        if not os.path.exists(self.data_folder):
-            os.makedirs(self.data_folder)
+        self.dataset_dir_path = pathlib.Path(self.dataset_dir)
+        if not self.dataset_dir_path.exists():
+            os.makedirs(self.dataset_dir)
 
-        env_config_file = self.data_dir + self.config["EnvironmentConfig"]
-        if not os.path.exists(env_config_file):
-            throw("Environment config file does not exist")
+        env_config_file = IOUtils.sanitize_path(self.config["EnvironmentConfig"])
+        env_config_file = pathlib.Path(env_config_file)
+        if not env_config_file.exists():
+            print(f'{env_config_file} does not exist')
+            exit()
 
-        self.env_params = CoverageControl.Parameters(env_config_file)
+        self.env_params = coverage_control.Parameters(env_config_file.as_posix())
 
         # Initialize variables
         self.dataset_count = 0
@@ -69,12 +121,12 @@ def __init__(self, config_file):
         self.edge_weights = torch.zeros((self.num_dataset, self.num_robots, self.num_robots))
 
         # Write metrics
-        self.metrics_file = self.data_folder + 'metrics.txt'
+        self.metrics_file = self.dataset_dir_path / 'metrics.txt'
         self.metrics = open(self.metrics_file, 'w')
         # Get current time
         start_time = datetime.datetime.now()
         self.metrics.write('Time: ' + str(datetime.datetime.now()) + '\n')
-        self.metrics.write('Data directory: ' + self.data_dir + '\n')
+        self.metrics.write('Dataset directory: ' + self.dataset_dir + '\n')
         self.PrintTensorSizes()
         self.PrintTensorSizes(self.metrics)
         self.metrics.flush()
@@ -113,16 +165,17 @@ def RunDataGeneration(self):
                 converged_data_count += 1
 
     def StepWithSave(self):
-        converged = not self.alg.Step()
+        self.alg.ComputeActions()
+        converged = self.alg.IsConverged()
         actions = self.alg.GetActions()
         count = self.dataset_count
-        self.actions[count] = ToTensor(actions)
-        self.robot_positions[count] = CoverageSystemUtils.GetRobotPositions(self.env)
-        self.coverage_features[count] = CoverageSystemUtils.GetVoronoiFeatures(self.env)
-        self.raw_local_maps[self.trigger_count] = CoverageSystemUtils.GetRawLocalMaps(self.env, self.env_params)
-        self.raw_obstacle_maps[self.trigger_count] = CoverageSystemUtils.GetRawObstacleMaps(self.env, self.env_params)
-        self.comm_maps[count] = CoverageSystemUtils.GetCommunicationMaps(self.env, self.env_params, self.cnn_map_size)
-        self.edge_weights[count] = CoverageSystemUtils.GetWeights(self.env, self.env_params)
+        self.actions[count] = CoverageEnvUtils.to_tensor(actions)
+        self.robot_positions[count] = CoverageEnvUtils.get_robot_positions(self.env)
+        self.coverage_features[count] = CoverageEnvUtils.get_voronoi_features(self.env)
+        self.raw_local_maps[self.trigger_count] = CoverageEnvUtils.get_raw_local_maps(self.env, self.env_params)
+        self.raw_obstacle_maps[self.trigger_count] = CoverageEnvUtils.get_raw_obstacle_maps(self.env, self.env_params)
+        self.comm_maps[count] = CoverageEnvUtils.get_communication_maps(self.env, self.env_params, self.cnn_map_size)
+        self.edge_weights[count] = CoverageEnvUtils.get_weights(self.env, self.env_params)
         self.dataset_count += 1
         if self.dataset_count % 100 == 0:
             print(f'Dataset: {self.dataset_count}/{self.num_dataset}')
@@ -141,12 +194,12 @@ def TriggerPostProcessing(self):
         trigger_end_idx = min(self.num_dataset, self.trigger_start_idx + self.trigger_size)
         raw_local_maps = self.raw_local_maps[0:trigger_end_idx - self.trigger_start_idx]
         raw_local_maps = raw_local_maps.to(self.device)
-        resized_local_maps = CoverageSystemUtils.ResizeMaps(raw_local_maps, self.cnn_map_size)
+        resized_local_maps = CoverageEnvUtils.resize_maps(raw_local_maps, self.cnn_map_size)
         self.local_maps[self.trigger_start_idx:trigger_end_idx] = resized_local_maps.view(-1, self.num_robots, self.cnn_map_size, self.cnn_map_size).cpu().clone()
 
         raw_obstacle_maps = self.raw_obstacle_maps[0:trigger_end_idx - self.trigger_start_idx]
         raw_obstacle_maps = raw_obstacle_maps.to(self.device)
-        resized_obstacle_maps = CoverageSystemUtils.ResizeMaps(raw_obstacle_maps, self.cnn_map_size)
+        resized_obstacle_maps = CoverageEnvUtils.resize_maps(raw_obstacle_maps, self.cnn_map_size)
         self.obstacle_maps[self.trigger_start_idx:trigger_end_idx] = resized_obstacle_maps.view(-1, self.num_robots, self.cnn_map_size, self.cnn_map_size).cpu().clone()
 
         self.trigger_start_idx = trigger_end_idx
@@ -176,23 +229,24 @@ def SaveTensor(self, tensor, name, as_sparse=False):
             validation_tensor = validation_tensor.to_sparse()
             test_tensor = test_tensor.to_sparse()
 
-        torch.save(train_tensor, self.data_folder + '/train/' + name)
-        torch.save(validation_tensor, self.data_folder + '/val/' + name)
-        torch.save(test_tensor, self.data_folder + '/test/' + name)
+        dataset_dir_path = pathlib.Path(self.dataset_dir)
+        torch.save(train_tensor, dataset_dir_path / 'train/' / name)
+        torch.save(validation_tensor, dataset_dir_path / 'val/' / name)
+        torch.save(test_tensor, dataset_dir_path / 'test/' / name)
 
     def SaveDataset(self):
         as_sparse = self.config['SaveAsSparseQ']
-        self.train_size = int(self.num_dataset * self.config['DatasetSplit']['TrainRatio'])
-        self.validation_size = int(self.num_dataset * self.config['DatasetSplit']['ValRatio'])
+        self.train_size = int(self.num_dataset * self.config['DataSetSplit']['TrainRatio'])
+        self.validation_size = int(self.num_dataset * self.config['DataSetSplit']['ValRatio'])
         self.test_size = self.num_dataset - self.train_size - self.validation_size
 
         # Make sure the folder exists
-        if not os.path.exists(self.data_folder + '/train'):
-            os.makedirs(self.data_folder + '/train')
-        if not os.path.exists(self.data_folder + '/val'):
-            os.makedirs(self.data_folder + '/val')
-        if not os.path.exists(self.data_folder + '/test'):
-            os.makedirs(self.data_folder + '/test')
+        if not os.path.exists(self.dataset_dir + '/train'):
+            os.makedirs(self.dataset_dir + '/train')
+        if not os.path.exists(self.dataset_dir + '/val'):
+            os.makedirs(self.dataset_dir + '/val')
+        if not os.path.exists(self.dataset_dir + '/test'):
+            os.makedirs(self.dataset_dir + '/test')
 
         self.SaveTensor(self.robot_positions, 'robot_positions.pt')
         self.SaveTensor(self.local_maps, 'local_maps.pt', as_sparse)
@@ -201,8 +255,8 @@ def SaveDataset(self):
 
         # min_val, range_val = self.NormalizeCommunicationMaps()
         self.SaveTensor(self.comm_maps, 'comm_maps.pt', as_sparse)
-        # torch.save(min_val, self.data_folder + '/comm_maps_min.pt')
-        # torch.save(range_val, self.data_folder + '/comm_maps_range.pt')
+        # torch.save(min_val, self.dataset_dir / 'comm_maps_min.pt')
+        # torch.save(range_val, self.dataset_dir / 'comm_maps_range.pt')
 
         self.SaveTensor(self.actions, 'actions.pt')
         self.SaveTensor(self.coverage_features, 'coverage_features.pt')
@@ -212,16 +266,18 @@ def SaveDataset(self):
             coverage_features, coverage_features_mean, coverage_features_std = self.NormalizeTensor(self.coverage_features)
             self.SaveTensor(normalized_actions, 'normalized_actions.pt')
             self.SaveTensor(coverage_features, 'normalized_coverage_features.pt')
-            torch.save(actions_mean, self.data_folder + '/actions_mean.pt')
-            torch.save(actions_std, self.data_folder + '/actions_std.pt')
-            torch.save(coverage_features_mean, self.data_folder + '/coverage_features_mean.pt')
-            torch.save(coverage_features_std, self.data_folder + '/coverage_features_std.pt')
+            torch.save(actions_mean, self.dataset_dir_path / 'actions_mean.pt')
+            torch.save(actions_std, self.dataset_dir_path / 'actions_std.pt')
+            torch.save(coverage_features_mean, self.dataset_dir_path / 'coverage_features_mean.pt')
+            torch.save(coverage_features_std, self.dataset_dir_path / 'coverage_features_std.pt')
 
 
     def StepWithoutSave(self):
-        converged = not self.alg.Step()
-        error_flag = self.env.StepActions(self.alg.GetActions())
-        return converged or error_flag
+        self.alg.ComputeActions()
+        converged = self.alg.IsConverged()
+        if (self.env.StepActions(self.alg.GetActions())):
+            return True
+        return converged
 
     def GetTensorByteSizeMB(self, tensor):
         return (tensor.element_size() * tensor.nelement()) / (1024 * 1024)
@@ -240,6 +296,8 @@ def PrintTensorSizes(self, file=sys.stdout):
 
 if __name__ == '__main__':
     config_file = sys.argv[1]
+    if len(sys.argv) > 2:
+        append_folder = sys.argv[2]
+    else:
+        append_folder = None
     DatasetGenerator(config_file)
-
-

python/scripts/data_generation/gen.sh

@@ -1,22 +1,7 @@
 #!/bin/bash
 
-for i in {4..9}
+for i in {0..5}
 do
 	echo "$i"
-	python simple_data_generation.py ~/CoverageControl_ws/datasets/1254/data_params.toml $i
-done
-for i in {4..9}
-do
-	echo "$i"
-	python simple_data_generation.py ~/CoverageControl_ws/datasets/1774/data_params.toml $i
-done
-for i in {4..9}
-do
-	echo "$i"
-	python simple_data_generation.py ~/CoverageControl_ws/datasets/1620/data_params.toml $i
-done
-for i in {4..9}
-do
-	echo "$i"
-	python simple_data_generation.py ~/CoverageControl_ws/datasets/1916/data_params.toml $i
+	python simple_data_generation.py ~/CoverageControl_ws/src/CoverageControl/params/data_params.toml $i
 done