def insert_measurements(date, version, con): #Insert measurements in DB with con: measurements_cur = con.cursor() measurements_gen = measurements.get_measurements(date, version) for measurement in measurements_gen: measurements_cur.execute( "INSERT INTO measurements VALUES(%s, %s, %s, %s, %s, %s)", measurement)
def set_measurements(self, seed=None): # random trajectory and anchors self.traj.set_coeffs(seed=seed) if seed is not None: np.random.seed(seed) self.anchors = create_anchors(self.traj.dim, self.n_anchors) # get measurements self.basis, self.D_topright = get_measurements(self.traj, self.anchors, seed=seed, n_samples=20)
def setUp(self): self.t1 = Trajectory(dim=2, n_complexity=2, model='polynomial', coeffs=np.array([[0., 0.], [0., 1.]])) self.t2 = Trajectory(dim=2, n_complexity=2, model='polynomial', coeffs=np.array([[-3., 3.], [1., 0.]])) times1 = np.linspace(0, 1, 10) times2 = np.linspace(1, 2, 20) np.random.seed(1) self.anchors = 4 * np.random.rand(2, 5) b1, D1 = get_measurements(self.t1, self.anchors, seed=1, times=times1) b2, D2 = get_measurements(self.t2, self.anchors, seed=1, times=times2) self.F = np.hstack((b1, b2)) self.D = np.vstack((D1, D2)) self.times = np.r_[times1, times2]
def test_f_multidim(self): from trajectory import Trajectory from measurements import get_measurements, create_anchors anchors = create_anchors(dim=2, n_anchors=5) trajectory = Trajectory(n_complexity=4, dim=2) basis, D_topright = get_measurements(trajectory, anchors, n_samples=10) eps = 1e-10 self.assertTrue(np.all(abs(f_multidim(anchors, basis, D_topright, trajectory.coeffs)) < eps)) self.assertTrue(abs(f_onedim(anchors, basis, D_topright, trajectory.coeffs)) < eps) coeffs_hat = np.squeeze(compute_exact(D_topright, anchors, basis)) np.testing.assert_allclose(coeffs_hat, trajectory.coeffs)
def setUp(self): np.random.seed(2) n_complexity = 5 self.traj = Trajectory(model='bandlimited') self.traj.set_n_complexity(n_complexity) self.traj.set_coeffs(1) self.anchors = np.random.rand(self.traj.dim, 10) * 10 # between 0 and 10. self.times = self.traj.get_times(n_samples=200) self.basis, self.D_gt = get_measurements(self.traj, self.anchors[:2, :], times=self.times) points_gt = self.traj.get_sampling_points(self.times) self.indices = range(len(self.times))[::self.traj.dim + 1] self.points_sub = points_gt[:, self.indices]
def run_simulation(parameters, outfolder=None, solver=None, verbose=False): """ Run simulation. :param parameters: Can be either the name of the folder where parameters.json is stored, or a new dict of parameters. """ if type(parameters) == str: fname = parameters + 'parameters.json' parameters = read_params(fname) print('read parameters from file {}.'.format(fname)) elif type(parameters) == dict: parameters = parameters # if we are trying new parameters and saving in a directory that already exists, # we need to make sure that the saved parameters are actually the same. if outfolder is not None: try: parameters_old = read_params(outfolder + 'parameters.json') parameters['time'] = parameters_old['time'] assert parameters == parameters_old, 'found conflicting parameters file: {}'.format(outfolder + 'parameters.json') except FileNotFoundError: print('no conflicting parameters file found.') except AssertionError as error: raise (error) else: raise TypeError('parameters needs to be folder name or dictionary.') if 'noise_to_square' not in parameters: parameters['noise_to_square'] = False if 'measure_distances' not in parameters: parameters['measure_distances'] = False if 'sampling_strategy' not in parameters: parameters['sampling_strategy'] = 'uniform' complexities = parameters['complexities'] anchors = parameters['anchors'] positions = parameters['positions'] n_its = parameters['n_its'] noise_sigmas = parameters['noise_sigmas'] success_thresholds = parameters['success_thresholds'] assert len(success_thresholds) == len(noise_sigmas) if parameters['sampling_strategy'] == 'single_time': max_measurements = max(positions) else: max_measurements = max(positions) * max(anchors) successes = np.full((len(complexities), len(anchors), len(positions), len(noise_sigmas), max_measurements), np.nan) errors = np.full(successes.shape, np.nan) relative_errors = np.full(successes.shape, np.nan) absolute_errors = np.full(successes.shape, np.nan) num_not_solved = np.full(successes.shape, np.nan) num_not_accurate = np.full(successes.shape, np.nan) squared_distances = [] for c_idx, n_complexity in enumerate(complexities): print('n_complexity', n_complexity) for a_idx, n_anchors in enumerate(anchors): print('n_anchors', n_anchors) for p_idx, n_positions in enumerate(positions): print('n_positions', n_positions) if parameters['sampling_strategy'] == 'single_time': n_measurements = n_positions else: n_measurements = n_positions * n_anchors for m_idx, n_missing in enumerate(range(n_measurements)): if verbose: print('measurements idx', m_idx) for noise_idx, noise_sigma in enumerate(noise_sigmas): indexes = np.s_[c_idx, a_idx, p_idx, noise_idx, m_idx] if verbose: print("noise", noise_sigma) # set all values to 0 since we have visited them. if np.isnan(successes[indexes]): successes[indexes] = 0.0 if np.isnan(num_not_solved[indexes]): num_not_solved[indexes] = 0.0 if np.isnan(num_not_accurate[indexes]): num_not_accurate[indexes] = 0.0 for _ in range(n_its): trajectory = Trajectory(n_complexity, dim=DIM) anchors_coord = create_anchors(DIM, n_anchors) trajectory.set_coeffs(seed=None) basis, D_topright = get_measurements(trajectory, anchors_coord, n_samples=n_positions) distances = np.sqrt(D_topright) D_topright = add_noise(D_topright, noise_sigma, parameters["noise_to_square"]) mask = create_mask(n_positions, n_anchors, strategy=parameters['sampling_strategy'], n_missing=n_missing) if parameters['measure_distances']: squared_distances.extend(D_topright.flatten().tolist()) D_topright = np.multiply(D_topright, mask) try: assert p.full_rank_condition( np.sort(np.sum(mask, axis=0))[::-1], DIM + 1, n_complexity), "insufficient rank" if (solver is None) or (solver == "semidef_relaxation_noiseless"): X = semidef_relaxation_noiseless(D_topright, anchors_coord, basis, chosen_solver=cvxpy.CVXOPT) P_hat = X[:DIM, DIM:] elif solver == 'trajectory_recovery': P_hat = trajectory_recovery(D_topright, anchors_coord, basis) elif solver == 'weighted_trajectory_recovery': P_hat = trajectory_recovery(D_topright, anchors_coord, basis, weighted=True) else: raise ValueError(solver) # calculate reconstruction error with respect to distances trajectory_estimated = Trajectory(coeffs=P_hat) _, D_estimated = get_measurements(trajectory_estimated, anchors_coord, n_samples=n_positions) estimated_distances = np.sqrt(D_estimated) robust_add(errors, indexes, np.linalg.norm(P_hat - trajectory.coeffs)) robust_add(relative_errors, indexes, np.linalg.norm((distances - estimated_distances) / (distances + 1e-10))) robust_add(absolute_errors, indexes, np.linalg.norm(distances - estimated_distances)) assert not np.linalg.norm(P_hat - trajectory.coeffs) > success_thresholds[noise_idx] robust_increment(successes, indexes) except cvxpy.SolverError: logging.info("could not solve n_positions={}, n_missing={}".format( n_positions, n_missing)) robust_increment(num_not_solved, indexes) except ZeroDivisionError: logging.info("could not solve n_positions={}, n_missing={}".format( n_positions, n_missing)) robust_increment(num_not_solved, indexes) except np.linalg.LinAlgError: robust_increment(num_not_solved, indexes) except AssertionError as e: if str(e) == "insufficient rank": robust_increment(num_not_solved, indexes) else: logging.info("result not accurate n_positions={}, n_missing={}".format( n_positions, n_missing)) robust_increment(num_not_accurate, indexes) errors[indexes] = errors[indexes] / (n_its - num_not_solved[indexes]) relative_errors[indexes] = relative_errors[indexes] / (n_its - num_not_solved[indexes]) results = { 'successes': successes, 'num-not-solved': num_not_solved, 'num-not-accurate': num_not_accurate, 'errors': errors, 'relative-errors': relative_errors, 'absolute-errors': absolute_errors, 'distances': squared_distances } if outfolder is not None: print('Done with simulation. Saving results...') parameters['time'] = time.time() if not os.path.exists(outfolder): os.makedirs(outfolder) save_params(outfolder + 'parameters.json', **parameters) save_results(outfolder + 'result_{}_{}', results) else: return results