def main(): # Load G = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() # Define GP model. data_std = 0.1 sigma0 = 1.0 m0 = 2139.1 lambda0 = 200.0 ground_truth = torch.from_numpy( np.load(os.path.join(results_folder, "ground_truth.npy"))) synth_data = torch.from_numpy( np.load(os.path.join(results_folder, "synth_data.npy"))) # Now train GP model on it. myGP = InverseGaussianProcess(m0, sigma0, lambda0, volcano_coords, kernel) myGP.train(np.linspace(1.0, 2000, 20), G, synth_data, data_std, out_path=os.path.join(results_folder, "./train_res_matern52.pck"), n_epochs=2000, lr=0.5, n_chunks=80, n_flush=1)
def main(): # Load static data. G = torch.from_numpy( np.load(os.path.join(data_folder, "F_corrected_final.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load( os.path.join(data_folder, "niklas_data_coords_corrected_final.npy"))).float() data_values = torch.from_numpy( np.load( os.path.join(data_folder, "niklas_data_obs_corrected_final.npy"))).float() data_std = 0.1 sigma0_matern32 = 284.66 m0_matern32 = 2139.1 lambda0_matern32 = 651.58 constant_updatable_gp = UpdatableGP(kernel, lambda0_matern32, sigma0_matern32, m0_matern32, volcano_coords, n_chunks=200) residuals = constant_updatable_gp.leave_1_out_residuals( G, data_values, data_std) np.save(residuals.numpy(), os.path.join(results_folder, "./loocv_niklas.pck"))
def main(): grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = grid.cells data_coords_surface = np.load( os.path.join(data_folder, "surface_data_coords.npy")) data_coords_niklas = np.load( os.path.join(data_folder, "niklas_data_coords.npy")) coast_coords = get_coast_coordinates(grid) threshold_small = 2600.0 threshold_big = 2500.0 for i in range(1, 6): ground_truth = torch.from_numpy( np.load( os.path.join(ground_truths_folder, "prior_sample_{}.npy".format(i)))) out_file_path = "excu_profile_small_{}".format(i) plot_excu_profile_with_data_revised(volcano_coords, data_coords_niklas, coast_coords, ground_truth, threshold_small, out_file_path) out_file_path = "excu_profile_big_{}".format(i) plot_excu_profile_with_data_revised(volcano_coords, data_coords_niklas, coast_coords, ground_truth, threshold_big, out_file_path)
def main(): grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = grid.cells data_coords_surface = np.load( os.path.join(data_folder, "surface_data_coords.npy")) data_coords_niklas = np.load( os.path.join(data_folder, "niklas_data_coords.npy")) surface_coords = np.load( os.path.join(data_folder, "surface_data_coords.npy")) coast_coords = get_coast_coordinates(grid) threshold = 2500.0 def process_sample(sample_nr): ground_truth = torch.from_numpy( np.load( os.path.join(ground_truths_folder, "prior_sample_{}.npy".format(sample_nr)))) visited_inds = np.load( os.path.join( os.path.join(base_results_folder, "sample_{}/".format(sample_nr)), "visited_inds.npy")) visited_coords = surface_coords[visited_inds, :] out_file_path = "excu_big_with_visited_inds_sample_{}".format( sample_nr) plot_excu_profile_with_visited_inds(volcano_coords, data_coords_niklas, visited_coords, coast_coords, ground_truth, threshold, out_file_path) for sample_nr in range(1, 6): process_sample(sample_nr)
def main(): # Load grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = grid.cells data_coords = np.load(os.path.join(data_folder,"surface_data_coords.npy")) ground_truth = np.load("./ground_truth.npy") data_values = np.load(os.path.join(data_folder, "post_data_sample.npy")) surface_coords = grid.surface # Interpolate surface on regular grid. X_surface_mesh, Y_surface_mesh, Z_surface_mesh = point_cloud_to_2D_regular_grid( surface_coords, n_grid=300) density_structured_grid = underground_point_cloud_to_structured_grid( volcano_coords, ground_truth, surface_coords, n_grid=50, fill_offset=1, fill_value=-1e6) # Threshold to only plot one region. vals[vals > 500] = 0 vals[vals < 0] = 0 mlab.surf(X_surface_mesh, Y_surface_mesh, Z_surface_mesh, opacity=0.35) d = mlab.pipeline.add_dataset(density_structured_grid) iso = mlab.pipeline.iso_surface(d) mlab.show()
def main(): grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = grid.cells data_coords_surface = np.load( os.path.join(data_folder, "surface_data_coords.npy")) data_coords_niklas = np.load( os.path.join(data_folder, "niklas_data_coords.npy")) # Center the coordinates. X1 = data_coords_niklas[:, 0] Y1 = data_coords_niklas[:, 1] Z1 = data_coords_niklas[:, 2] # Center the separations and scale to meters. X1_centred = 111 * 1e3 * (1e-5 * (X1 - np.min(X1))) Y1_centred = 111 * 1e3 * (1e-5 * (Y1 - np.min(Y1))) volcano_X = 111 * 1e3 * ( 1e-5 * (volcano_coords[:, 0] - np.min(volcano_coords[:, 0]))) volcano_Y = 111 * 1e3 * ( 1e-5 * (volcano_coords[:, 1] - np.min(volcano_coords[:, 1]))) volcano_Z = volcano_coords[:, 2] # Same, but centred compared to volano. X1_centred_b = 111 * 1e3 * (1e-5 * (X1 - np.min(volcano_coords[:, 0]))) Y1_centred_b = 111 * 1e3 * (1e-5 * (Y1 - np.min(volcano_coords[:, 1]))) # Prepare figure layout. plt.rc('xtick', labelsize=5) plt.rc('ytick', labelsize=5) fig = plt.figure() widths = [1, 1] heights = [1, 1, 1, 1] gs = fig.add_gridspec(ncols=2, nrows=4, width_ratios=widths, height_ratios=heights) f_ax1 = fig.add_subplot(gs[:, 0]) f_ax2 = fig.add_subplot(gs[1:2, 1]) f_ax3 = fig.add_subplot(gs[2:3, 1]) f_ax1.scatter(X1_centred, Y1_centred, c=Z1, cmap=cmap, linewidth=0.2, s=1) f_ax1.set_aspect('equal') f_ax1.tick_params(axis='both', which='major', pad=0.1) f_ax2.scatter(X1_centred, Z1, c=Z1, cmap=cmap, linewidth=0.2, s=1) f_ax2.set_aspect(1.5) f_ax2.tick_params(axis='both', which='major', pad=0.1) f_ax3.scatter(Y1_centred, Z1, c=Z1, cmap=cmap, linewidth=0.2, s=1) f_ax3.set_aspect(1.5) f_ax3.tick_params(axis='both', which='major', pad=0.1) plt.savefig("niklas_data_overview", bbox_inches="tight", pad_inches=0.1, dpi=400)
def main(): os.makedirs(output_path, exist_ok=True) # Load F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() ground_truth = torch.from_numpy( np.load(os.path.join(data_folder, "post_sample.npy"))) data_values = torch.from_numpy( np.load(os.path.join(data_folder, "post_data_sample.npy"))) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # PATHS ON THE VOLCANO. from volcapy.data_preparation.paths import paths as paths_niklas # Convert to indices in the full dataset. paths = [] for path in paths_niklas: paths.append(niklas_data_inds[path].long()) # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Load results. visited_inds = np.load("visited_inds.npy") observed_data = np.load("observed_data.npy") # Plot situation. plt.scatter(data_coords[:, 0], data_coords[:, 1], c="k", alpha=0.1) plt.scatter(volcano_coords[excursion_inds, 0], volcano_coords[excursion_inds, 1], c="r", alpha=0.07) # plt.scatter(niklas_coords[:, 0], niklas_coords[:, 1], # c=niklas_coords[:, 2]) plt.scatter(data_coords[visited_inds, 0], data_coords[visited_inds, 1], c="g") plt.title("Visited locations on the Stromboli and excursion set.") plt.show() """
def main(): os.makedirs(output_path, exist_ok=True) # Load F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() ground_truth = torch.from_numpy( np.load(os.path.join(data_folder, "post_sample.npy"))) data_values = torch.from_numpy( np.load(os.path.join(data_folder, "post_data_sample.npy"))) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Params data_std = 0.1 # lambda0 = 338.0 lambda0 = 338.46 sigma0 = 359.49 m0 = -114.40 # Define GP model. data_feed = lambda x: data_values[x] updatable_gp = UpdatableGP(cl, lambda0, sigma0, m0, volcano_coords, n_chunks=80) for i, current_ind in enumerate(niklas_data_inds): y = data_feed(current_ind) G = F[current_ind, :].reshape(1, -1) updatable_gp.update(G, y, data_std) # Extract variance and coverage function. coverage = updatable_gp.coverage(THRESHOLD_low, None) # Save. np.save(os.path.join(output_path, "coverage_{}.npy".format(i)), coverage)
def main(): os.makedirs(output_path, exist_ok=True) # Load F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() ground_truth = torch.from_numpy( np.load(os.path.join(data_folder, "post_sample.npy"))) data_values = torch.from_numpy( np.load(os.path.join(data_folder, "post_data_sample.npy"))) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Params data_std = 0.1 # lambda0 = 338.0 lambda0 = 338.46 sigma0 = 359.49 m0 = -114.40 # Define GP model. data_feed = lambda x: data_values[x] updatable_gp = UpdatableGP(cl, lambda0, sigma0, m0, volcano_coords, n_chunks=80) # Asimilate myopic data collection plan. visited_inds = np.load(os.path.join(results_folder, "visited_inds.npy")) observed_data = np.load(os.path.join(results_folder, "visited_inds.npy")) n_chunks = 80 for i, inds in enumerate(np.array_split(visited_inds, n_chunks)): print("Processing chunk {} / {}".format(i, n_chunks)) y = data_feed(inds) G_current = F[inds, :] updatable_gp.update(G_current, y, data_std)
def main(sample_nr): ground_truth_path = os.path.join( data_folder, "prior_samples_v2/prior_sample_{}.npy".format(sample_nr)) ground_truth = np.load(ground_truth_path) grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() irregular_array_to_point_cloud(volcano_coords.numpy(), ground_truth, "ground_truth_{}.vtk".format(sample_nr), fill_nan_val=-20000.0)
def main(): # Load G = torch.from_numpy( np.load(os.path.join(data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy( grid.cells).float().detach() # Optimal hyperparameters. data_std = 0.1 sigma0 = 2.968352 lambda0 = 207.8275 ground_truth = torch.from_numpy(np.load(os.path.join(results_folder, "ground_truth.npy"))) synth_data = torch.from_numpy( np.load(os.path.join(results_folder, "synth_data.npy"))) # Build trends: constant cylindrical. x0 = volcano_coords[:, 0].mean() # Volcano center. y0 = volcano_coords[:, 1].mean() z0 = volcano_coords[:, 2].mean() coeff_F = torch.hstack([ torch.ones(volcano_coords.shape[0], 1), cylindrical( volcano_coords, x0, y0).reshape(-1, 1) ]).float() # Now fit GP model updatable_gp = UniversalUpdatableGP(kernel, lambda0, torch.tensor([sigma0]), volcano_coords, coeff_F, coeff_cov="uniform", coeff_mean="uniform", n_chunks=200) # Compute cross-validation matrix. K_tilde = updatable_gp.compute_cv_matrix(G, synth_data, data_std=0.2) np.save(os.path.join(results_folder, "K_tilde.npy"), K_tilde.cpu().numpy()) # Compute posterior mean. updatable_gp.update_uniform(G, synth_data, data_std) np.save(os.path.join(results_folder, "post_mean_universal.npy"), updatable_gp.post_mean.cpu().numpy()) np.save(os.path.join(results_folder, "coeff_post_mean.npy"), updatable_gp.coeff_post_mean.cpu().numpy()) variance = updatable_gp.covariance.extract_variance() np.save(os.path.join(results_folder, "variance_universal.npy"), variance.cpu().numpy()) """
def main(): # Load data_folder = "/home/cedric/PHD/Dev/VolcapySIAM/data/InversionDatas/stromboli_40357_cells" F = torch.from_numpy( np.load(os.path.join(data_folder, "F_niklas.npy"))).float().detach() F = torch.from_numpy( np.load(os.path.join(data_folder, "F_niklas_corr.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy( grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder,"niklas_data_coords.npy"))).float() data_values = torch.from_numpy( np.load(os.path.join(data_folder,"niklas_data_obs.npy"))).float() print("Size of inversion grid: {} cells.".format(volcano_coords.shape[0])) print("Number of datapoints: {}.".format(data_coords.shape[0])) size = data_coords.shape[0]*volcano_coords.shape[0]*4 / 1e9 cov_size = (volcano_coords.shape[0])**2 * 4 / 1e9 print("Size of Covariance matrix: {} GB.".format(cov_size)) print("Size of Pushforward matrix: {} GB.".format(size)) # HYPERPARAMETERS data_std = 0.1 sigma0 = 221.6 m0 = 2133.8 lambda0 = 462.0 # Run inversion in one go to compare. import volcapy.covariance.exponential as kernel start = timer() myGP = InverseGaussianProcess(m0, sigma0, lambda0, volcano_coords, kernel, logger=logger) cov_pushfwd = cl.compute_cov_pushforward( lambda0, F, volcano_coords, n_chunks=20, n_flush=50) m_post_m, m_post_d = myGP.condition_model(F, data_values, data_std, concentrate=False, is_precomp_pushfwd=False) end = timer() print("Non-sequential inversion run in {} s.".format(end - start)) # Train. myGP.train_fixed_lambda(200.0, F, data_values, data_std)
def main(): # Load data_folder = "/home/cedric/PHD/Dev/VolcapySIAM/data/InversionDatas/stromboli_23823_cells" F = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_coords.npy"))).float() data_values = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_obs.npy"))).float() print("Size of inversion grid: {} cells.".format(volcano_coords.shape[0])) print("Number of datapoints: {}.".format(data_coords.shape[0])) size = data_coords.shape[0] * volcano_coords.shape[0] * 4 / 1e9 cov_size = (volcano_coords.shape[0])**2 * 4 / 1e9 print("Size of Covariance matrix: {} GB.".format(cov_size)) print("Size of Pushforward matrix: {} GB.".format(size)) # HYPERPARAMETERS data_std = 0.1 sigma0 = 100.6 m0 = 1000.0 lambda0 = 300.0 start = timer() myGP = InverseGaussianProcess(m0, sigma0, lambda0, volcano_coords, kernel, logger=logger) m_post_m, m_post_d = myGP.condition_model(F, data_values, data_std, concentrate=False, is_precomp_pushfwd=False) end = timer() print("Non-sequential inversion run in {} s.".format(end - start)) # Train. myGP.train(np.linspace(20, 1400, 14), F, data_values, data_std, out_path="./train_res.pck", n_chunks=2, n_flush=50)
def main(): # Load G = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder,"surface_data_coords.npy"))).float() ground_truth = torch.from_numpy(np.load(ground_truth_path)) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Load results. visited_inds_IVR = np.load(os.path.join( results_folder_IVR, "visited_inds.npy")) visited_inds_wIVR = np.load(os.path.join( results_folder_wIVR, "visited_inds.npy")) # Observation operators. # G_stacked_IVR = G[visited_inds_IVR, :] G_stacked_wIVR = G[visited_inds_wIVR, :] # Reload the GPs. # gpIVR = UpdatableGP.load(os.path.join(results_folder_IVR, "gp_state.pkl")) # gpwIVR = UpdatableGP.load(os.path.join(results_folder_wIVR, "gp_state.pkl")) gpINFILL = UpdatableGP.load(os.path.join(results_folder_INFILL, "gp_state.pkl")) # Produce posterior realization. for reskrig_sample_nr in range(300, 400): prior_realization = torch.from_numpy(np.load( os.path.join(reskrig_samples_folder, "prior_sample_{}.npy".format(reskrig_sample_nr)))) myReal = UpdatableRealization.bootstrap(prior_realization, G_stacked_wIVR, data_std=0.1, gp_module=gpINFILL) np.save( os.path.join(results_folder_wIVR, "Cond_Reals_Infill/conditional_real_{}.npy".format(reskrig_sample_nr)), myReal._realization.detach().cpu().numpy())
def main(): # Load G = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = np.load(os.path.join(data_folder, "niklas_data_coords.npy")) data_std = 0.1 ground_truth = torch.from_numpy( np.load(os.path.join(results_folder, "ground_truth.npy"))) synth_data = torch.from_numpy( np.load(os.path.join(results_folder, "synth_data.npy"))) # Build trends: constant cylindrical. x0 = volcano_coords[:, 0].mean() # Volcano center. y0 = volcano_coords[:, 1].mean() z0 = volcano_coords[:, 2].mean() coeff_F = torch.hstack([ torch.ones(volcano_coords.shape[0], 1), cylindrical(volcano_coords, x0, y0).reshape(-1, 1) ]).float() # Define GP model with arbitrary parameters (we will train them anyway). lambda0, sigma0 = 10, 2 updatable_gp = UniversalUpdatableGP(kernel, lambda0, sigma0, volcano_coords, coeff_F, coeff_cov="uniform", coeff_mean="uniform", n_chunks=200) # Train cross-validation. lambda0s = np.linspace(0.2, 1000, 50) sigma0s = np.linspace(0.1, 100, 50) # Compute folds via kMeans. k = 10 # number of clusters. folds = kMeans_folds(k, data_coords) updatable_gp.train_cv_criterion( lambda0s, sigma0s, G, synth_data, data_std, criterion="k fold", folds=folds, out_path=os.path.join(results_folder, "./{}_fold_kMeans_residuals.pck".format(k)))
def main(): # Load G = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() # Define GP model. data_std = 0.1 sigma0 = 1.0 m0 = 2139.1 lambda0 = 200.0 # Build trends: constant cylindrical. x0 = volcano_coords[:, 0].mean() # Volcano center. y0 = volcano_coords[:, 1].mean() z0 = volcano_coords[:, 2].mean() coeff_mean = torch.tensor([m0, 0.01]).reshape(-1, 1).float() coeff_cov = torch.tensor([[200.0, 0], [0, 0.05]]).float() coeff_F = torch.hstack([ torch.ones(volcano_coords.shape[0], 1), cylindrical(volcano_coords, x0, y0).reshape(-1, 1) ]).float() # Model with trend. updatable_gp = UniversalUpdatableGP(kernel, lambda0, torch.tensor([sigma0]), volcano_coords, coeff_F, coeff_cov, coeff_mean, n_chunks=200) ground_truth = torch.from_numpy( np.load(os.path.join(results_folder, "ground_truth.npy"))) synth_data = torch.from_numpy( np.load(os.path.join(results_folder, "synth_data.npy"))) lambda0s = np.linspace(1.0, 3000, 30) kappa_s = np.linspace(1e-5, 1, 30) updatable_gp.train(lambda0s, kappa_s, G, synth_data, out_path=os.path.join(results_folder, "./train_res_universal.pck"))
def main(): # Create output directory. output_folder = os.path.join(base_folder, "./train_res.pck") # Load static data. F = torch.from_numpy( np.load(os.path.join(data_folder, "F_corrected_final.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load( os.path.join(data_folder, "niklas_data_coords_corrected_final.npy"))).float() data_values = torch.from_numpy( np.load( os.path.join(data_folder, "niklas_data_obs_corrected_final.npy"))).float() print("Size of inversion grid: {} cells.".format(volcano_coords.shape[0])) print("Number of datapoints: {}.".format(data_coords.shape[0])) size = data_coords.shape[0] * volcano_coords.shape[0] * 4 / 1e9 cov_size = (volcano_coords.shape[0])**2 * 4 / 1e9 print("Size of Covariance matrix: {} GB.".format(cov_size)) print("Size of Pushforward matrix: {} GB.".format(size)) # HYPERPARAMETERS to start search from. data_std = 0.1 sigma0 = 340.0 m0 = 561.0 lambda0 = 50.0 myGP = InverseGaussianProcess(m0, sigma0, lambda0, volcano_coords, kernel) # Train. myGP.train(np.linspace(50.0, 1450, 30), F, data_values, data_std, out_path="./train_res.pck", n_epochs=3000, lr=0.5, n_chunks=80, n_flush=1)
def main(): # Load G = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = np.load(os.path.join(data_folder, "niklas_data_coords.npy")) k = 10 kmeans = KMeans(init="random", n_clusters=k, n_init=10, max_iter=300, random_state=42) kmeans.fit(data_coords) # Plot clusters. import matplotlib.pyplot as plt plt.scatter(x=data_coords[:, 0], y=data_coords[:, 1], c=kmeans.labels_) plt.show()
def main(): # Load static data. F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() # Load generated data. ground_truth = torch.from_numpy(np.load(ground_truth_path)) # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 # Choose a starting points on the coast. start_ind = 4478 # ------------------------------------- # Define GP model. # ------------------------------------- data_std = 0.1 lambda0 = 338.46 sigma0 = 359.49 m0 = -114.40 # Prepare data. data_values = F @ ground_truth data_feed = lambda x: data_values[x] updatable_gp = UpdatableGP(cl, lambda0, sigma0, m0, volcano_coords, n_chunks=200) updatable_gp.update(F[1].reshape(1, -1), data_values[1], 0.1)
def sample_posterior_strategy(strategy_folder, sample_nr, prior_sample_folder, static_data_folder, n_samples): # Load static data. # Load static data. F = torch.from_numpy( np.load(os.path.join(static_data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(static_data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() # Create GP (trained Matern 32). data_std = 0.1 sigma0_matern32 = 284.66 m0_matern32 = 2139.1 lambda0_matern32 = 651.58 myGP = InverseGaussianProcess(m0_matern32, sigma0_matern32, lambda0_matern32, volcano_coords, kernel, n_chunks=200, n_flush=50) current_folder = os.path.join(strategy_folder, "sample_{}/".format(sample_nr)) post_sample_folder = os.path.join(current_folder, "post_samples/") os.makedirs(post_sample_folder, exist_ok=True) # Load observed data. visited_inds = np.load(os.path.join(current_folder, "visited_inds.npy")).flatten() observed_data = torch.from_numpy( np.load(os.path.join(current_folder, "observed_data.npy")).flatten().reshape(-1, 1)) G = F[visited_inds, :] sample_posterior(myGP, n_samples, prior_sample_folder, G, observed_data, data_std, post_sample_folder)
def main(): # Load volcano geometry. data_folder = "/home/cedric/PHD/Dev/VolcapySIAM/reporting/variance_extraction_benchmark/stromboli_51023_cells" grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = grid.cells # Activate auto-wrapping of numpy arrays as rpy2 objects. numpy2ri.activate() # Import the R RandomFields library. rflib = importr("RandomFields") # Create the model and sample. model = rflib.RMexp(var=3, scale=5) simu = rflib.RFsimulate(model, volcano_coords) # Back to numpy. sample = np.asarray(simu.slots['data']).astype(np.float32) irregular_array_to_point_cloud(volcano_coords, sample, "sample.vtk", fill_nan_val=-20000.0)
def discretize_in_n(n): """ Discretize the geometry at a given lengthscale, here specifiec by the number of cells along each direction of the horizontal plane. """ nx = n ny = n # Regrid. x, step_x = np.linspace(x_min, x_max, nx, endpoint=True, retstep=True) y, step_y = np.linspace(y_min, y_max, ny, endpoint=True, retstep=True) print("Step x {}".format(step_x)) print("Step y {}".format(step_y)) # Set the same resolution for z. z_step = float(np.mean([step_x, step_y])) print("Step z {}".format(z_step)) # Find z by getting closest cell in fine grid. tree_x = KDTree(dsm_x) tree_y = KDTree(dsm_y) _, inds_x = tree_x.query(x[:, None]) _, inds_y = tree_y.query(y[:, None]) # Remesh the z-s. a, b = np.meshgrid(inds_x, inds_y) z = dsm_z[a, b] print("Minimal altitude {}".format(np.min(z))) my_grid = Grid.build_grid(x, y, z, z_low=-1600, z_step=z_step) print("Grid with {} cells.".format(my_grid.shape[0])) print(my_grid.res_x) print(my_grid.res_y) print(my_grid.res_z) # Return mean resolution and total number of cells. return my_grid.shape[0], np.mean(np.array([step_x, step_y, z_step]))
def sample_prior(input_path, output_path, n_realizations): os.makedirs(output_path, exist_ok=True) # Load grid = Grid.load(os.path.join(input_path, "grid.pickle")) volcano_coords = torch.from_numpy( grid.cells).float().detach() # HYPERPARAMETERS. data_std = 0.1 sigma0_exp = 308.89 # WARNING: Old values. m0_exp = 535.39 lambda0_exp = 1925.0 sigma0_matern32 = 284.66 m0_matern32 = 2139.1 lambda0_matern32 = 651.58 sigma0_matern52 = 258.40 m0_matern52 = 2120.93 lambda0_matern52 = 441.05 myGP = InverseGaussianProcess(m0_matern32, sigma0_matern32, lambda0_matern32, volcano_coords, kernel, n_chunks=70, n_flush=50) for i in range(500, 500 + n_realizations): start = timer() prior_sample = myGP.sample_prior() end = timer() print("Prior sampling run in {}s.".format(end - start)) np.save(os.path.join(output_path, "prior_sample_{}.npy".format(i)), prior_sample.detach().cpu().numpy())
def main(): # Load F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder,"surface_data_coords.npy"))).float() ground_truth = torch.from_numpy(np.load(ground_truth_path)) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Load results. visited_inds_IVR = np.load(os.path.join( results_folder_IVR, "visited_inds.npy")) visited_inds_wIVR = np.load(os.path.join( results_folder_wIVR, "visited_inds.npy")) def compute_mismatch(coverage): # ------------------------------------------------- # ------------------------------------------------- # Find the Vorob'ev threshold. vorobev_volume = np.sum(coverage) def f(x): return (np.abs(np.sum(coverage > x) - vorobev_volume)) from scipy.optimize import minimize vorobev_threshold = minimize(f, 0.5, method='nelder-mead', options={'xatol': 1e-3, 'disp': True}).x print("Vorob'ev threshold: {}.".format(vorobev_threshold)) # Plot estimated excursion set using coverage function. est_excursion_inds = coverage > vorobev_threshold print("Vorobe'v volume: {}.".format(vorobev_volume)) print("Current estimate volume: {}.".format(np.sum(est_excursion_inds))) # Compute mismatch. mismatch = np.zeros(volcano_coords.shape[0]) mismatch[est_excursion_inds] = 1 tmp = np.zeros(volcano_coords.shape[0]) tmp[excursion_inds] = 2 mismatch = mismatch + tmp excu_size = excursion_inds.shape[0] + 1 p_false_pos = 100 * np.sum(mismatch == 1) / excu_size p_false_neg = 100 * np.sum(mismatch == 2) / excu_size p_correct = 100 * np.sum(mismatch == 3) / excu_size return (p_false_pos, p_false_neg, p_correct) mismatches_IVR = [] mismatches_wIVR = [] mismatches_static = [] # Number of static datapoints. n_static = 542 for i in range(1, n_static): coverage_static = np.load( os.path.join( static_results_folder, "coverage_{}.npy".format(i))) mismatches_static.append(compute_mismatch(coverage_static)) for i in range(1, visited_inds_IVR.shape[0]): coverage_IVR = np.load( os.path.join( results_folder_IVR, "coverage_{}.npy".format(i))) mismatches_IVR.append(compute_mismatch(coverage_IVR)) for i in range(1, visited_inds_wIVR.shape[0]): coverage_wIVR = np.load( os.path.join( results_folder_wIVR, "coverage_{}.npy".format(i))) mismatches_wIVR.append(compute_mismatch(coverage_wIVR)) mismatches_IVR = np.array(mismatches_IVR) mismatches_wIVR = np.array(mismatches_wIVR) mismatches_static = np.array(mismatches_static) plt.plot(list(range(1, visited_inds_IVR.shape[0])), mismatches_IVR[:,0], label="false positives, IVR strategy", color="blue", linestyle="dashed") plt.plot(list(range(1, visited_inds_IVR.shape[0])), mismatches_IVR[:,1], label="false negatives, IVR strategy", color="red", linestyle="dashed") plt.plot(list(range(1, visited_inds_IVR.shape[0])), mismatches_IVR[:,2], label="correct prediction, IVR strategy", color="green", linestyle="dashed") plt.plot(list(range(1, visited_inds_wIVR.shape[0])), mismatches_wIVR[:,0], label="false positives, weighted IVR strategy", color="cornflowerblue", linestyle="solid") plt.plot(list(range(1, visited_inds_wIVR.shape[0])), mismatches_wIVR[:,1], label="false negatives, weighted IVR strategy", color="lightcoral", linestyle="solid") plt.plot(list(range(1, visited_inds_wIVR.shape[0])), mismatches_wIVR[:,2], label="correct prediction, weighted IVR strategy", color="lightgreen", linestyle="solid") # Add the surface fill coverage. coverage_fill = np.load(os.path.join( infill_folder, "coverage_surface_fill.npy")) mismatch_fill = compute_mismatch(coverage_fill) # Size of the limiting horizontal line corresponding to the infill # strategy. n = 600 plt.plot(list(range(1, n)), np.repeat(mismatch_fill[0], n-1), label="false positives, surface fill", color="cornflowerblue", linestyle="dotted") plt.plot(list(range(1, n)), np.repeat(mismatch_fill[1], n-1), label="false negatives, surface fill", color="lightcoral", linestyle="dotted") plt.plot(list(range(1, n)), np.repeat(mismatch_fill[2], n-1), label="correct prediction, surface fill", color="lightgreen", linestyle="dotted") plt.xlim([1, 500]) plt.legend() plt.xlabel("Number of observations") plt.ylabel("Size in percent of true excursion size") plt.savefig("mismatch_evolution_bigstep", bbox_inches="tight", pad_inches=0.1, dpi=600) plt.show()
def main(sample_nr): post_sample_path = os.path.join( ground_truth_folder, "post_samples/post_sample_{}.npy".format(sample_nr)) post_data_sample_path = os.path.join( ground_truth_folder, "post_data_samples/post_data_sample_{}.npy".format(sample_nr)) output_path = os.path.join(output_folder, "INFILL_results/sample_{}".format(sample_nr)) os.makedirs(output_path, exist_ok=True) save_gp_state_path = os.path.join(output_path, "gp_state.pkl") # Load F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() ground_truth = torch.from_numpy(np.load(post_sample_path)) data_values = torch.from_numpy(np.load(post_data_sample_path)) # Dictionary between the original Niklas data and our discretization. niklas_data_inds = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_inds_insurf.npy"))).long() niklas_coords = data_coords[niklas_data_inds].numpy() # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 700.0 excursion_inds = (ground_truth >= THRESHOLD_low).nonzero()[:, 0] # Coast data. coast_data_inds_infull = niklas_data_inds[coast_data_inds] # Choose a starting points on the coast. start_ind = coast_data_inds_infull[0] # Params data_std = 0.1 # lambda0 = 338.0 lambda0 = 338.46 sigma0 = 359.49 m0 = -114.40 # Define GP model. data_feed = lambda x: data_values[x] updatable_gp = UpdatableGP(cl, lambda0, sigma0, m0, volcano_coords, n_chunks=80) from volcapy.strategy.infill import InfillStrategy strategy = InfillStrategy( updatable_gp, data_coords, F, data_feed, lower=THRESHOLD_low, upper=None, ) start = timer() visited_inds, observed_data, ivrs = strategy.run( start_ind, n_steps=2000, data_std=0.1, output_folder=output_path, save_coverage=True, max_step=310.0, save_gp_state_path=save_gp_state_path) end = timer() print("Run in {} mins.".format((end - start) / 60)) np.save(os.path.join(output_path, "visited_inds.npy"), visited_inds) np.save(os.path.join(output_path, "observed_data.npy"), observed_data) np.save(os.path.join(output_path, "ivrs.npy"), ivrs)
def main(sample_nr): # Create output directory. output_folder = os.path.join(base_folder, "wIVR_final_big/sample_{}".format(sample_nr)) os.makedirs(output_folder, exist_ok=True) # Load static data. F = torch.from_numpy( np.load(os.path.join(data_folder, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "surface_data_coords.npy"))).float() # Load generated data. ground_truth_path = os.path.join(ground_truth_folder, "prior_sample_{}.npy".format(sample_nr)) ground_truth = torch.from_numpy(np.load(ground_truth_path)) # Load prior realizations. N_REALIZATIONS = 100 prior_realizations = [] for i in range(100, 100 + N_REALIZATIONS): realization_path = os.path.join(ground_truth_folder, "prior_sample_{}.npy".format(i)) prior_realizations.append(torch.from_numpy(np.load(realization_path))) # -------------------------------- # DEFINITION OF THE EXCURSION SET. # -------------------------------- THRESHOLD_low = 2500.0 # Choose a starting points on the coast. start_ind = 4478 # ------------------------------------- # Define GP model. # ------------------------------------- data_std = 0.1 sigma0_matern32 = 284.66 m0_matern32 = 2139.1 lambda0_matern32 = 651.58 # Prepare data. data_values = F @ ground_truth data_feed = lambda x: data_values[x] updatable_gp = UpdatableGP(cl, lambda0_matern32, sigma0_matern32, m0_matern32, volcano_coords, n_chunks=200) # ------------------------------------- strategy = ConservativeStrategy(updatable_gp, data_coords, F, data_feed, lower=THRESHOLD_low, upper=None, prior_realizations=prior_realizations) # Run strategy. visited_inds, observed_data = strategy.run(start_ind, n_steps=4000, data_std=0.1, max_step=151.0, min_step=60.0, output_folder=output_folder)
def prepare_stromboli(input_path, output_path, z_step): dsm_x = np.load(os.path.join(input_path, "dsm_stromboli_x.npy")) dsm_y = np.load(os.path.join(input_path, "dsm_stromboli_y.npy")) dsm_z = np.load(os.path.join(input_path, "dsm_stromboli_z.npy")) my_grid = Grid.build_grid(dsm_x, dsm_y, dsm_z, z_low=-800, z_step=z_step) my_grid.save(os.path.join(output_path, "grid.pickle")) print("Grid with {} cells.".format(my_grid.shape[0])) # Name the output directory with the number of cells. dir_name = "stromboli_{}_cells".format(my_grid.shape[0]) output_path = os.path.join(output_path, dir_name) os.makedirs(output_path, exist_ok=True) # Determines which cells lie deep inside the volcano (i.e. away from the # surface). # This is useful when using IVR to select new datapoints, since we are mostly # interested at variance reduction deep below the surface. DEPTH_THRESHOLD = 150.0 # Only keep cells at least that far from the surface. surface_tree = KDTree(my_grid.surface) # Loop over cells and only keep the ones that are far away from the surface. deep_cells_inds = [] for i, cell in enumerate(my_grid.cells): print("Processing cell {}/{}".format(i, my_grid.cells.shape[0])) d, _ = surface_tree.query(cell) if d > DEPTH_THRESHOLD: deep_cells_inds.append(i) print("There are {} surface cells.".format(my_grid.surface.shape[0])) print("Kept {}/{} cells".format(len(deep_cells_inds), my_grid.cells.shape[0])) np.save(os.path.join(output_path, "deep_cells_inds.npy"), np.array(deep_cells_inds, dtype=np.int32)) # Put measurement stations on the whole surface, at 1 meter from the ground. # First only keep cells that are outside the water. data_coords = np.array([x for x in my_grid.surface if x[2] > 0.0]) print(("There are {} surface cells above sea level. " + "Placing potential observation " + "sites on each of those..").format(data_coords.shape[0])) data_coords[:, 2] = data_coords[:, 2] + 1.0 # Also load locations of Niklas data points. from volcapy.loading import load_niklas niklas_data = load_niklas(ORIGINAL_NIKLAS_DATA_PATH) niklas_data_coords = np.array(niklas_data["data_coords"])[1:] niklas_data_values = np.array(niklas_data["d"]) # Find the indices of the closest data points to Niklas data. # This may be used to mitigate the difference between the two in case there # are a lot of difference in altitude because of the discretization. tree_surf_data = KDTree(data_coords) _, inds_niklas_in_surface = tree_surf_data.query(niklas_data_coords) niklas_data_coords_insurf = data_coords[inds_niklas_in_surface] np.save(os.path.join(output_path, "niklas_data_inds_insurf.npy"), inds_niklas_in_surface) # Save location of data points before computing forward. # Save the surface of the volcano and the datapoints. in vtk. from volcapy.plotting.vtkutils import irregular_array_to_point_cloud, array_to_vector_cloud irregular_array_to_point_cloud(my_grid.surface, np.ones(my_grid.surface.shape[0]), os.path.join(output_path, "surface.vtk"), fill_nan_val=-20000.0) orientation_data = np.zeros((data_coords.shape[0], 3)) orientation_data[:, 2] = -1.0 array_to_vector_cloud(data_coords, orientation_data, os.path.join(output_path, "data_points.vtk")) orientation_data = np.zeros((niklas_data_coords.shape[0], 3)) orientation_data[:, 2] = -1.0 orientation_data_vals = np.zeros((niklas_data_coords.shape[0], 3)) orientation_data_vals[:, 2] = niklas_data_values array_to_vector_cloud(niklas_data_coords, orientation_data, os.path.join(output_path, "niklas_data_coords.vtk")) array_to_vector_cloud( niklas_data_coords_insurf, orientation_data, os.path.join(output_path, "niklas_data_coords_insurf.vtk")) array_to_vector_cloud(niklas_data_coords, orientation_data_vals, os.path.join(output_path, "niklas_data_vals.vtk")) # ---------------------------------------------------------------------- # Also compute forward for Niklas data. # TODO: WARNING!!! There is one too many data site. Here remove the first, but # maybe its the last who should be removed. ref_coords = np.array(niklas_data["data_coords"][0])[None, :] # TODO: Verify this. According to Niklas, we should subtract the response on # the reference station. Assuming this is the first data site, then, from every # line, we should subract the first line. F_ref_station = compute_forward(my_grid.cells, my_grid.cells_roof, my_grid.res_x, my_grid.res_y, my_grid.res_z, ref_coords, n_procs=4) F_niklas = compute_forward(my_grid.cells, my_grid.cells_roof, my_grid.res_x, my_grid.res_y, my_grid.res_z, niklas_data_coords, n_procs=4) # Subtract the first station. F_niklas_corr = F_niklas - np.repeat( F_ref_station, F_niklas.shape[0], axis=0) np.save(os.path.join(output_path, "F_niklas.npy"), F_niklas) np.save(os.path.join(output_path, "F_niklas_corr.npy"), F_niklas_corr[1:]) np.save(os.path.join(output_path, "niklas_data_coords.npy"), niklas_data_coords[1:, :]) np.save(os.path.join(output_path, "niklas_data_obs.npy"), niklas_data['d'][1:]) # Compute forward on whole surface. F_full_surface = compute_forward(my_grid.cells, my_grid.cells_roof, my_grid.res_x, my_grid.res_y, my_grid.res_z, data_coords, n_procs=4) # Save everything, but cut first observation. np.save(os.path.join(output_path, "surface_data_coords.npy"), data_coords) np.save(os.path.join(output_path, "F_full_surface.npy"), F_full_surface)
def prepare_groundtruth(data_path, prior_sample_path, post_sample_path, post_data_sample_path): """ Given a realization from the prior, compute the corresponding conditional realization by updating. Parameters ---------- data_path: string Path to the static data defining the situation (grid, forward, ...). prior_sample_path: string Path ta a realization from the prior. post_sample_path: float Where to save the computed posterior realization. post_data_sample_path: string Where to save the computed posterior realization of the data. """ # Load F = torch.from_numpy(np.load(os.path.join( data_path, "F_niklas.npy"))).float().detach() F_full = torch.from_numpy( np.load(os.path.join(data_path, "F_full_surface.npy"))).float().detach() grid = Grid.load(os.path.join(data_path, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_path, "niklas_data_coords.npy"))).float() data_coords_full = torch.from_numpy( np.load(os.path.join(data_path, "surface_data_coords.npy"))).float() data_values = torch.from_numpy( np.load(os.path.join(data_path, "niklas_data_obs.npy"))).float() print("Size of inversion grid: {} cells.".format(volcano_coords.shape[0])) print("Number of datapoints: {}.".format(data_coords.shape[0])) size = data_coords.shape[0] * volcano_coords.shape[0] * 4 / 1e9 cov_size = (volcano_coords.shape[0])**2 * 4 / 1e9 print("Size of Covariance matrix: {} GB.".format(cov_size)) print("Size of Pushforward matrix: {} GB.".format(size)) prior_sample = torch.from_numpy(np.load(prior_sample_path)).float() # HYPERPARAMETERS, small volcano. data_std = 0.1 sigma0 = 359.49 m0 = -114.40 lambda0 = 338.46 myGP = InverseGaussianProcess(m0, sigma0, lambda0, volcano_coords, kernel, logger=logger) start = timer() post_sample = myGP.update_sample(prior_sample, F, data_values, data_std) end = timer() print("Sample updating run in {}s.".format(end - start)) np.save(post_sample_path, post_sample.detach().cpu().numpy()) post_data_sample = F_full @ post_sample np.save(post_data_sample_path, post_data_sample.detach().cpu().numpy())
def main(): # Load data_folder = "/home/cedric/PHD/Dev/VolcapySIAM/reporting/input_data" F = torch.from_numpy(np.load(os.path.join( data_folder, "F_niklas.npy"))).float().detach() grid = Grid.load(os.path.join(data_folder, "grid.pickle")) volcano_coords = torch.from_numpy(grid.cells).float().detach() data_coords = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_coords.npy"))).float() data_values = torch.from_numpy( np.load(os.path.join(data_folder, "niklas_data_obs.npy"))).float() # Subdivide for variance reduction computation. part_ind = 60 F_rest = F[part_ind:, :] F = F[:part_ind, :] data_coords_part = data_coords[part_ind:, :] data_coords = data_coords[:part_ind, :] data_values = data_values[:part_ind] print("Size of inversion grid: {} cells.".format(volcano_coords.shape[0])) print("Number of datapoints: {}.".format(data_coords.shape[0])) size = data_coords.shape[0] * volcano_coords.shape[0] * 8 / 1e9 print("Size of Pushforward matrix: {} GB.".format(size)) # Params data_std = 0.1 lambda0 = 200.0 sigma0 = 200.0 m0 = 1300 start = timer() # Now ready to go to updatable covariance. from volcapy.update.updatable_covariance import UpdatableCovariance updatable_cov = UpdatableCovariance(cl, lambda0, sigma0, volcano_coords) from volcapy.update.updatable_covariance import UpdatableMean updatable_mean = UpdatableMean(m0 * torch.ones(volcano_coords.shape[0]), updatable_cov) n_chunks = 5 # Loop over measurement chunks. for i, (F_i, data_part) in enumerate( zip(torch.chunk(F, chunks=n_chunks, dim=0), torch.chunk(data_values, chunks=n_chunks, dim=0))): print("Processing data chunk nr {}.".format(i)) updatable_cov.update(F_i, data_std) updatable_mean.update(data_part, F_i) m = updatable_mean.m.cpu().numpy() np.save("m_post_{}_stromboli.npy".format(i), m) irregular_array_to_point_cloud(volcano_coords.numpy(), m, "m_post_{}_stromboli.vtk".format(i), fill_nan_val=-20000.0) end = timer() print("Sequential inversion run in {} s.".format(end - start)) # Save the variance. variances = updatable_cov.extract_variance() irregular_array_to_point_cloud(volcano_coords.numpy(), variances.detach().cpu().numpy(), "variances_stromboli.vtk", fill_nan_val=-20000.0) # Save the coordinates of the observation points for later plotting. # The point data will be used for glyph orientation when plotting. orientation_data = np.zeros((data_coords.shape[0], 3)) orientation_data[:, 2] = -1.0 # Add an offset for easier visualization. data_coords[:, 2] = data_coords[:, 2] + 50.0 array_to_vector_cloud(data_coords.numpy(), orientation_data, "data_points_in_IVR.vtk") IVRs = [] # Now compute the variance reduction associated to the other points. for i, F_i in enumerate(F_rest): IVR = updatable_cov.compute_IVR(F_i.reshape(1, -1), data_std) print(IVR) IVRs.append(IVR) # Save periodically. if i % 15 == 0: print("Saving at {}.".format(i)) np.save("IVRs.npy", np.array(IVRs)) np.save("IVRs.npy", np.array(IVRs)) data_coords_part[:, 2] = data_coords_part[:, 2] + 50.0 np.save("data_coords_IVR.npy", data_coords_part) # Add an offset for easier visualization. _array_to_point_cloud(data_coords_part.numpy(), np.array(IVRs), "IVRs.vtk") """
# General torch settings and devices. torch.set_num_threads(8) gpu = torch.device('cuda:0') cpu = torch.device('cpu') # ------------------------------------------------------ # Load Niklas Data # ------------------------------------------------------ # Dimension of the response. # F = np.load("/home/cedric/PHD/Dev/VolcapySIAM/reporting/F_niklas.npy") F = np.load("/home/cedric/PHD/Dev/VolcapySIAM/reporting/F.npy") F = torch.as_tensor(F).float() d_obs = np.load( "/home/cedric/PHD/Dev/VolcapySIAM/reporting/niklas_data_obs.npy") grid = Grid.load("/home/cedric/PHD/Dev/VolcapySIAM/reporting/grid.pickle") cells_coords = grid.cells # Careful: we have to make a column vector here. data_std = 0.1 d_obs = torch.as_tensor(d_obs)[:, None] n_data = d_obs.shape[0] data_cov = torch.eye(n_data) cells_coords = torch.as_tensor(cells_coords).detach() # HYPERPARAMETERS sigma0_init = 221.6 m0 = 2133.8 lambda0 = 462.0 # ------------------------------------------------------