def __init__(self, map_data, main_sensor='None', k_name="RBF", acq="gaussian_sei", acq_mod="masked"): # self.agents = agents self.map_data = map_data self.acquisition = acq # 'gaussian_sei' 'gaussian_ei' 'maxvalue_entropy_search''gaussian_pi' self.acq_mod = acq_mod # 'masked' 'split_path' 'truncated', 'normal' self.k_name = k_name # "RBF" Matern" "RQ" if k_name == "RBF_N": self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RBF(100), alpha=1e-7) elif k_name == "RBF": self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RBF(100.0), alpha=1e-7) # self.gp = gpr.GaussianProcessRegressor(kernel=kernels.Matern(100, nu=3.5), alpha=1e-7) elif k_name == "RQ": self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RBF(100), alpha=1e-7) # self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RationalQuadratic(100, 0.1), alpha=1e-7) self.data = [np.array([[], []]), np.array([])] self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.main_sensor = main_sensor self.splitted_goals = []
def __init__(self, agents, map_data, main_sensor='None', acq="RU"): self.agents = agents self.map_data = map_data self.acquisition = 'gaussian_sei' self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RBF(100), alpha=1e-7) # self.gp = gpr.GaussianProcessRegressor(kernel=kernels.Matern(150, nu=3.5), alpha=1e-7) # self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RationalQuadratic(150, 0.1), alpha=1e-7) # self.gp = gpr.GaussianProcessRegressor(normalize_y=True, kernel=20 * kernels.RBF(150), alpha=1e-7) self.data = [np.array([[], []]), np.array([])] self.acq_method = acq self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.main_sensor = main_sensor _x, _y = self.obtain_shapely_polygon().exterior.coords.xy self.fpx, self.fpy = self.obtain_points(_x, _y) # dists = [] # for i in range(len(self.fpx) - 1): # dists.append(np.linalg.norm( # np.subtract(np.array([self.fpx[i], self.fpy[i]]), np.array([self.fpx[i + 1], self.fpy[i + 1]])))) # import matplotlib.pyplot as plt # plt.Figure() # plt.hist(dists) # print(np.mean(dists)) # print(np.std(dists)) plt.plot(self.fpx, self.fpy, '-*')
def __init__(self, map_data, sensors: set, k_names=None, d=1.0, no_drones=2, acq=0): if k_names is None: k_names = ["RBF"] * len(sensors) self.map_data = map_data self.k_names = k_names # "RBF" Matern" "RQ" self.sensors = sensors self.gps = dict() self.train_inputs = [np.array([[], []])] self.train_targets = dict() self.proportion = d self.nans = None self.mus = dict() self.stds = dict() self.has_calculated = dict() for sensor, kernel in zip(sensors, k_names): if kernel == "RBF": # "RBF" Matern" "RQ" self.gps[sensor] = gprnew.GaussianProcessRegressor( kernel=kernels.RBF(100), alpha=1e-7) self.train_targets[sensor] = np.array([]) self.mus[sensor] = np.array([]) self.stds[sensor] = np.array([]) self.has_calculated[sensor] = False self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.acq_method = acq % 4 _x, _y = self.obtain_shapely_polygon().exterior.coords.xy self.fpx_, self.fpy_ = self.obtain_points(_x, _y) no_wps = len(self.fpx_) self.fpx_ = list(self.fpx_) self.fpy_ = list(self.fpy_) self.fpx = [ self.fpx_[int(i * (no_wps / no_drones)):int(i * (no_wps / no_drones) + no_wps / no_drones)] for i in range(no_drones) ] self.fpy = [ self.fpy_[int(i * (no_wps / no_drones)):int(i * (no_wps / no_drones) + no_wps / no_drones)] for i in range(no_drones) ] self.current_goals = [[] for _ in range(no_drones)] for i in range(no_drones): self.current_goals[i] = np.array( [self.fpx[i].pop(0), self.fpy[i].pop(0)])
def __init__(self, agents, map_data, main_sensor='None'): self.agents = agents self.map_data = map_data self.acquisition = 'gaussian_lcb' self.gp = gpr.GaussianProcessRegressor(normalize_y=True, kernel=1000 * kernels.RBF(2)) self.data = [np.array([[], []]), np.array([])] # self.vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape(2, -1).T self.vector_pos = np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T self.main_sensor = main_sensor
def __init__(self, map_data, sensors: set, k_names=None, acq="gaussian_ei", acq_mod="masked", acq_fusion="decoupled", d=1.0): if k_names is None: k_names = ["RBF"] * len(sensors) self.map_data = map_data self.acquisition = acq # 'gaussian_sei' 'gaussian_ei' 'maxvalue_entropy_search''gaussian_pi' self.acq_mod = acq_mod # 'masked' 'split_path' 'truncated', 'normal' self.k_names = k_names # "RBF" Matern" "RQ" self.sensors = sensors self.gps = dict() self.train_inputs = [np.array([[], []])] self.train_targets = dict() self.proportion = d self.mus = dict() self.stds = dict() self.has_calculated = dict() for sensor, kernel in zip(sensors, k_names): if kernel == "RBF": # "RBF" Matern" "RQ" helper = gpr.GaussianProcessRegressor(kernel=kernels.RBF(100), alpha=1e-7) self.gps[sensor] = convert(helper, 'torch') self.gps[sensor].to('cuda') self.train_targets[sensor] = np.array([]) self.mus[sensor] = np.array([]) self.stds[sensor] = np.array([]) self.has_calculated[sensor] = False self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.acq_fusion = acq_fusion # simple_max: maximum value found # max_sum: sum of acq on max for each maximum self.splitted_goals = [] self.nans = None
def __init__(self, map_data, sensors: set, k_names=None, acq="gaussian_ei", acq_mod="masked", acq_fusion="decoupled", d=0.375): if k_names is None: k_names = ["RBF"] * len(sensors) self.map_data = map_data self.acquisition = acq # 'gaussian_sei' 'gaussian_ei' 'maxvalue_entropy_search''gaussian_pi' self.acq_mod = acq_mod # 'masked' 'split_path' 'truncated', 'normal', self.k_names = k_names # "RBF" Matern" "RQ" self.sensors = sensors self.gps = dict() self.train_inputs = [np.array([[], []])] self.train_targets = dict() self.proportion = d self.mus = dict() self.stds = dict() self.has_calculated = dict() for sensor, kernel in zip(sensors, k_names): if kernel == "RBF": # "RBF" Matern" "RQ" self.gps[sensor] = gpr.GaussianProcessRegressor( kernel=kernels.RBF(100), alpha=1e-7) # self.gps[sensor] = gprnew.GaussianProcessRegressor(kernel=kernels.RBF(100), alpha=1e-7, noise=0.01) self.train_targets[sensor] = np.array([]) self.mus[sensor] = np.array([]) self.stds[sensor] = np.array([]) self.has_calculated[sensor] = False self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.problem = MyProblem(gps=self.gps, train_targets=self.train_targets, map_data=map_data) self.algorithm = NSGA2(pop_size=50) self.splitted_goals = [] self.nans = None
def __init__(self, map_data, sensors: set, k_names=None, d=1.0): if k_names is None: k_names = ["RBF"] * len(sensors) self.map_data = map_data self.k_names = k_names # "RBF" Matern" "RQ" self.sensors = sensors self.gps = dict() self.train_inputs = [np.array([[], []])] self.train_targets = dict() self.proportion = d self.mus = dict() self.stds = dict() self.has_calculated = dict() for sensor, kernel in zip(sensors, k_names): if kernel == "RBF": # "RBF" Matern" "RQ" self.gps[sensor] = gprnew.GaussianProcessRegressor( kernel=kernels.RBF(100), alpha=1e-7) self.train_targets[sensor] = np.array([]) self.mus[sensor] = np.array([]) self.stds[sensor] = np.array([]) self.has_calculated[sensor] = False self.all_vector_pos = np.mgrid[0:self.map_data.shape[1]:1, 0:self.map_data.shape[0]:1].reshape( 2, -1).T self.vector_pos = np.fliplr( np.asarray(np.where(self.map_data == 0)).reshape(2, -1).T) self.splitted_goals = [] self.nans = None self.fpx, self.fpy = self.obtain_points() self.fpx = list(self.fpx) self.fpy = list(self.fpy) self.current_goal = np.array([self.fpx.pop(0), self.fpy.pop(0)])
def __init__(self, scenario_map, initial_position=None, battery_budget=100, resolution=1, seed=0): self.id = "Continuous BO Ypacarai" # Map of the environment # self.scenario_map = scenario_map # Environment boundaries self.map_size = self.scenario_map.shape self.map_lims = np.array(self.map_size) - 1 # Action space and sizes # self.action_space = gym.spaces.Box(low=np.array([0, 0]), high=np.array([1, 1])) self.action_size = 2 # Internal state of the Markov Decision Process # self.state = None self.next_state = None self.reward = None self.done = False # Create the ground truth object # self.gt = GroundTruth(1 - self.scenario_map, 1, max_number_of_peaks=5) # Initial position, referred as a [X,Y] vector # self.initial_position = initial_position self.step_count = 0 # Penalization for a collision in the reward funcion # self.collision_penalization = 10 # Seed for deterministic replication # self.seed = seed np.random.seed(self.seed) # Battery budget self.battery = battery_budget # Battery cost -> Cost of the battery per 1m movement # This is calculated approximately using the long size of the map ~ 15km in the Ypacarai case self.battery_cost = 100 / np.max(self.map_size) / resolution # Gaussian Process parameters # GP with RBF kernel of 10% long-size of the map lengthscale (in pixels) self.gp = gpr.GaussianProcessRegressor(kernel=kernels.RBF( 0.1 * np.min(self.map_size)), alpha=1e-7) # Matrix de (num_muestra, features): num_muestra: numero de posiciones en la que se tomaron muestras # features: cada una de las dimenciones, i.e., features son y, x self.train_inputs = None # Solution vector: y = f(x) self.train_targets = None # Matrix de (num_pos, features): num_pos: numero de posiciones en la que puede encontrarse el ASV # features: cada una de las dimenciones, i.e., features son y, x # [[2 17] # [2 18] # ... # [y x] # ... # [54 31] # [54 32]] self.possible_locations = np.asarray( np.where(self.scenario_map == 1)).reshape(2, -1).T # Generate vector of possible gt (speeds up the reward MSE process) self.target_locations = None # Vector!! de dimension 1 fila x (mxn) columnas representando el mapa de incertidumbre anterior self.current_std = None # Vector!! de dimension 1 fila x (mxn) columnas representando el mapa de media anterior self.current_mu = None # Current MSE for reward self.previous_mse = None self._max_step_distance = np.min(self.map_size) # Initial position # # The initial position HAS PIXEL UNITS: # The action spaces translates to PIXEL UNITS TO FORM THE STATE self.position = None self.place_agent() self.reset()