import numpy as np import mitsuba as mi mi.set_variant("cuda_ad_rgb") import drjit as dr from PDE2D.Coefficient import * from PDE2D.utils import * from PDE2D.BoundaryShape import * from PDE2D.Solver import * from python2D.optimizations.sketch import * from mitsuba import Float, UInt32, UInt64, Point2f from PDE2D import Split import time def compute_primal(wos : WostVariable, split : Split, spe : int, delete_injection : bool, conf_numbers : list[UInt32], max_split_depth : int, compute_std: bool, verbose : bool = False, kill_step = dr.inf, kill_rate = 0.99): points_el, active_conf, electrode_nums = wos.input.shape.out_boundary.create_electrode_points(spe = spe, delete_injection = delete_injection, conf_numbers = conf_numbers) L, _ = wos.solve(points_el, active_conf, split = split, max_depth_split = max_split_depth, conf_numbers=conf_numbers, all_inside = True, verbose = verbose, tput_kill = kill_rate, max_length=kill_step) el_std = None if compute_std: el_tensor, el_std = create_electrode_result(L, spe, electrode_nums, apply_normalization=True, compute_std = True) el_std = el_std.numpy() else: el_tensor = create_electrode_result(L, spe, electrode_nums, apply_normalization = True, compute_std = False) return L, el_tensor, el_std, electrode_nums def compute_primals(wos : WostVariable, split : Split, spe : int, dirichlet_spe : int, seed : int, delete_injection : bool, max_split_depth : int, compute_std : bool, confs_iter : int = 8, num_electrodes : int = 16, dirichlet_offset : int = 0, kill_step = dr.inf, kill_rate = 0.99, wos_dummy : WostVariable = None, selected_point : int = 0, conf_numbers = []): num_conf = len(conf_numbers) results = np.zeros([num_conf, num_electrodes]) std = np.zeros([num_conf, num_electrodes]) electrode_nums = np.zeros([num_conf, num_electrodes - 2]) num_iter = int(np.ceil(num_conf / confs_iter)) #print(num_iter) initstate, initseq = tea(dr.arange(UInt64, num_iter), UInt64(seed)) pcg = PCG32() pcg.seed(initstate, initseq) seeds = pcg.next_uint32_bounded(10000).numpy() #print(seeds) for i, seed in enumerate(seeds): begin= i * confs_iter end = min(num_conf, (i + 1) * confs_iter) conf_numbers_i = [conf_numbers[j] for j in range(begin, end)] dr.make_opaque(conf_numbers_i) wos.change_seed(seed) # Compute the voltages of the points inside. if (wos.input.shape.num_shapes > 1): origins = wos.input.shape.get_origins() origins = np.delete(origins, selected_point, axis = 0) in_points = Point2f(origins.T) in_points = dr.repeat(in_points, dirichlet_spe) #dr.set_log_level(3) L_d, _ = wos_dummy.solve(in_points, split = split, max_depth_split = max_split_depth, conf_numbers=conf_numbers_i, all_inside = True, max_length=kill_step, tput_kill = kill_rate, verbose = False) #dr.set_log_level(0) dirichlet_vals = (dr.block_sum(L_d, dirichlet_spe) / dirichlet_spe).numpy().T dirichlet_vals = np.insert(dirichlet_vals, selected_point, dirichlet_offset, axis = 0) wos.input.shape.update_in_boundary_dirichlets(dirichlet_vals.tolist()) _, signal, el_std, elnums = compute_primal(wos, split, spe, delete_injection, conf_numbers_i, max_split_depth, compute_std, kill_step = kill_step, kill_rate = kill_rate) results[begin : end] = signal.numpy() electrode_nums[begin : end] = elnums.numpy() if el_std is not None: std[begin : end] = elnums.numpy() return results, std, electrode_nums def optimize_eit(path : str, wos : WostVariable, wos_obj : WostVariable, wos_dummy : WostVariable, split : Split, spe : int, primal_spe : int, dirichlet_spe : int, seed : int, conf_per_iter : int, max_split_depth : int, num_iter : int, learning_rate : float, λ_L1 : float, λ_TV : float, post_process : callable, cond_threshold : float, grad_threshold : float, max_dirichlet : int, dirichlet_radius : float, dirichlet_offset : float, merge_distance : float, normalize_grad :bool = False, plot : bool = True, bbox_plot : list[list[float]] = [[-1.05, -1.05],[1.05, 1.05]], delete_injection : bool = True, compute_std : bool = True, verbose : bool = False, max_range : list[float] = [0.1, 3], fileset : str = None, centered_dirichlet = False, kill_step = dr.inf, kill_rate = 0.99, measure_time = True, vis_confs = []): set_matplotlib(9) selected_point = 0 num_conf = wos.input.shape.out_boundary.num_confs print(num_conf) conf_per_iter = min(num_conf, conf_per_iter) num_electrodes = wos.input.shape.out_boundary.num_electrodes objectives = wos.input.shape.out_boundary.voltages # Compute the primals for getting the first loss values. conf_numbers_all = [dr.opaque(UInt32, i, shape=(1)) for i in range(num_conf)] primals, primals_std, electrode_nums = compute_primals(wos, split, primal_spe, dirichlet_spe, seed, delete_injection, max_split_depth, compute_std, confs_iter = num_electrodes, num_electrodes= num_electrodes, kill_step=kill_step, kill_rate=kill_rate, conf_numbers = conf_numbers_all) losses = MSE_numpy(primals, objectives) plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "begin-scaled", coeff_obj = wos_obj.input.α, max_range = max_range) plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "begin", coeff_obj = wos_obj.input.α) # Create the optimizer opt = Adam(lr= learning_rate, params = wos.opt_params) wos.update(opt) loss_list = [] loss_reg_list = [] # Record the objective optimization parameters record_dict = {} #if max_dirichlet > 0: dirichlet_points = wos.input.shape.get_origins() record_dict[f"dirichletpoints-0"] = np.array(dirichlet_points) record_dict["primals-0"] = np.array(primals.squeeze()) record_dict[f"objectives"] = objectives for key in opt.keys(): record_dict[f"{key}-0"] = opt[key].numpy() if wos_obj is not None: dirichlet_obj = wos_obj.input.shape.get_origins() record_dict["dirichlet-objective"] = np.array(dirichlet_obj) record_dict["objective-tensor"] = wos_obj.input.α.tensor.numpy().squeeze() initstate, initseq = tea(dr.arange(UInt32, conf_per_iter), UInt64(seed)) sampler = PCG32() sampler.seed(initstate, initseq) group_size = int(dr.ceil(num_conf / conf_per_iter)) confs = dr.arange(UInt32, num_conf) print("Optimization Started!") # Begin optimization for i in range(num_iter): # Primal results of some confs are computed at each iteration for visualization purposes. if len(vis_confs) > 0: if measure_time: dr.sync_thread() t0 = time.time() primals_vis, _, _= compute_primals(wos, split, primal_spe, dirichlet_spe, seed + i, delete_injection, max_split_depth, compute_std, confs_iter = num_electrodes, num_electrodes= num_electrodes, kill_step=kill_step, kill_rate=kill_rate, conf_numbers = vis_confs, wos_dummy=wos_dummy, dirichlet_offset = dirichlet_offset, selected_point=selected_point) record_dict[f"vis-{i}"] = np.array(primals_vis) if measure_time: dr.sync_thread() t1 = time.time() t_vis = t1 - t0 print(f"Vis primal time: {t_vis}") record_dict[f"t-vis{i}"] = t_vis seed_iter = sampler.next_uint32()[0] # Select some confs randomly. confs_iter = dr.gather(UInt32, confs, sampler.next_uint32_bounded(group_size) + dr.arange(UInt32, conf_per_iter) * group_size) confs_iter = dr.select(confs_iter >= num_conf, sampler.next_uint32_bounded(num_conf), confs_iter) confs_iter = confs_iter.numpy().squeeze() confs_opaque = [dr.opaque(UInt32, j, shape = (1)) for j in confs_iter.tolist()] obj_res_iter = objectives[confs_iter, :] wos.change_seed(seed_iter) if measure_time: dr.sync_thread() t0 = time.time() # Compute the voltages of the points inside. if (wos.input.shape.num_shapes > 1) and not centered_dirichlet: origins = wos.input.shape.get_origins() origins = np.delete(origins, selected_point, axis = 0) in_points = Point2f(origins.T) in_points = dr.repeat(in_points, dirichlet_spe) L_d, _ = wos_dummy.solve(in_points, split = split, max_depth_split = max_split_depth, conf_numbers=confs_opaque, all_inside = True, verbose = verbose, max_length=kill_step, tput_kill = kill_rate) dirichlet_vals = (dr.block_sum(L_d, dirichlet_spe) / dirichlet_spe).numpy().T dirichlet_vals = np.insert(dirichlet_vals, selected_point, dirichlet_offset, axis = 0) wos.input.shape.update_in_boundary_dirichlets(dirichlet_vals.tolist()) if measure_time: dr.sync_thread() t1 = time.time() t_dirichlet = t1 - t0 print(f"Dirichlet time: {t_dirichlet}") record_dict[f"t-dirichlet{i}"] = t_dirichlet L, signal, signal_std, _ = compute_primal(wos, split, primal_spe, delete_injection, confs_opaque, max_split_depth, compute_std, verbose = verbose, kill_step = kill_step, kill_rate = kill_rate) dr.eval(signal) signal_np = signal.numpy() primals[confs_iter] = signal.numpy() losses[confs_iter] = MSE_numpy(signal_np, obj_res_iter) if compute_std: primals_std[confs_iter] = signal_std obj_opaque = ArrayXf(obj_res_iter.tolist()) dr.make_opaque(obj_opaque) loss_grad = compute_loss_grad(signal, obj_opaque) if normalize_grad: L, signal, _, elnums = compute_primal(wos, split, spe, delete_injection, confs_opaque, max_split_depth, False, kill_step = kill_step, kill_rate = kill_rate) else: L = Float(1) elnums = None dL = compute_dL(L, loss_grad, spe, elnums, apply_normalization=normalize_grad) points_el, active_conf, _ = wos.input.shape.out_boundary.create_electrode_points(spe = spe, delete_injection = delete_injection, conf_numbers = confs_opaque) #print(f"Grad (num_shapes = {wos.input.shape.num_shapes})") #dr.set_log_level(3) if measure_time: dr.sync_thread() t2 = time.time() t_primal = t2 - t1 print(f"Primal time: {t_primal}") record_dict[f"t-primal{i}"] = t_primal with dr.isolate_grad(): _ = wos.solve_grad(points_in = points_el, active_conf_in = active_conf, split = split, dL = dL, max_depth_split = max_split_depth, conf_numbers=confs_opaque, all_inside = True, verbose = verbose, max_length=kill_step, tput_kill = kill_rate) #dr.set_log_level(0) if measure_time: dr.sync_thread() t3 = time.time() t_grad = t3 - t2 print(f"Grad time: {t_grad}") record_dict[f"t-grad{i}"] = t_grad loss_reg = 0 if λ_L1 > 0: reg_L1 = wos.input.compute_regularization(λ_L1, RegularizationType.tensorL1) dr.backward(reg_L1) loss_reg += dr.sum(reg_L1)[0] if λ_TV > 0: reg_TV = wos.input.compute_regularization(λ_TV, RegularizationType.TV) dr.backward(reg_TV) loss_reg += dr.sum(reg_TV)[0] if plot: iter_plot(wos, bbox_plot, path, f"{i}", primals, primals_std, electrode_nums, compute_std = compute_std, wos_obj = wos_obj, max_range = max_range) coeff = wos.input.get_coefficient("diffusion") grad_np = dr.grad(coeff.tensor).numpy() opt.step() post_process(opt) wos.update(opt) wos_dummy.update(opt) if not centered_dirichlet and (max_dirichlet > 0): dirichlet_points = wos.input.compute_high_conductance_points(max_num_points=max_dirichlet, cond_threshold= cond_threshold, grad_threshold=grad_threshold, merge_distance = merge_distance) if dirichlet_points.shape[0] == 1: wos.input.shape.update_in_boundaries_circle(origins = dirichlet_points, radius = dirichlet_radius, dirichlet_values = [dirichlet_offset]) wos_dummy.input.shape.update_in_boundaries_circle(origins = dirichlet_points, radius = dirichlet_radius, dirichlet_values = None) else: selected_point = sampler.next_uint32_bounded(dirichlet_points.shape[0])[0] wos_dummy.input.shape.update_in_boundaries_circle(origins = [dirichlet_points[selected_point]], radius = dirichlet_radius, dirichlet_values = [dirichlet_offset]) wos.input.shape.update_in_boundaries_circle(origins = dirichlet_points, radius = dirichlet_radius, dirichlet_values = None) record_dict[f"dirichletpoints-{i+1}"] = np.array(dirichlet_points) if wos.use_accel: wos.input.create_accelaration() wos_dummy.input.create_accelaration() if measure_time: dr.sync_thread() t4 = time.time() t_accel = t4 - t3 print(f"Accel time : {t_accel}") record_dict[f"t-accel{i}"] = t_accel record_dict[f"grad-{i+1}"] = np.array(grad_np.squeeze()) record_dict[f"primals-{i+1}"] = np.array(primals) for key in opt.keys(): record_dict[f"{key}-{i+1}"] = opt[key].numpy() loss_reg_list.append(loss_reg) loss_list.append(np.array(losses)) record_dict["loss"] = np.array(loss_list) record_dict["loss-reg"] = np.array(loss_reg_list) print(f"Iteration {i} is finished. Loss = {np.array(losses).sum() + loss_reg}") #print(time.time() - t) print("Optimization Ended! Animations will be generated.") plot_summary(loss_list, loss_reg_list, path, log=False) plot_summary(loss_list, loss_reg_list, path, log=True) if wos_obj is not None: plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "end-scaled", coeff_obj = wos_obj.input.α, max_range = max_range) plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "end", coeff_obj = wos_obj.input.α) else: plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "end-scaled", coeff_obj = None, max_range = max_range) plot_coeff(wos.input.α, wos.input.shape, bbox_plot, path, "end", coeff_obj = None) if fileset is None: create_animation(record_dict, path, num_iter, bbox_plot, wos, resolution = [1024, 1024], max_range = max_range, wos_obj = wos_obj, opt_param = "diffusion.texture.tensor") create_animation(record_dict, path, num_iter, bbox_plot, wos, resolution = [1024, 1024], wos_obj = wos_obj, opt_param = "diffusion.texture.tensor") else: create_animation(record_dict, path, num_iter, bbox_plot, wos, resolution = [1024, 1024], max_range = max_range, wos_obj = wos_obj, opt_param = "diffusion.texture.tensor", fileset = fileset) np.save(os.path.join(path, "record.npy"), record_dict) print("Animations are generated.")