data/python2D/optimizations/eit_discrete/optimize.py

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.eit_discrete.sketch import *
from mitsuba import Float, UInt32, UInt64, Point2f
import time

def compute_primal(wos : WostConstant, spe : int, delete_injection : bool, 
                   conf_numbers : list[UInt32]):
    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, conf_numbers=conf_numbers, all_inside = True)

    el_tensor = create_electrode_result(L, spe, electrode_nums, apply_normalization = True, compute_std = False)
    return L, el_tensor,electrode_nums

def compute_primals(wos : WostConstant, spe : int, seed : int, delete_injection : bool,  
                    confs_iter : int = 8, num_electrodes : int = 16, 
                    conf_numbers = []):
    num_conf = len(conf_numbers)
    results = 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)
        
        _, signal,  elnums = compute_primal(wos, spe, delete_injection, conf_numbers_i)
        results[begin : end] = signal.numpy()
        electrode_nums[begin : end] = elnums.numpy() 
    return results, electrode_nums

def optimize_eit(path : str, wos : WostConstant, wos_obj : WostConstant,
                spe : int, primal_spe : int, seed : int, conf_per_iter : int,
                res_normalder : int, spp_normalder : int, dist_normalder :int,
                num_iter : int, learning_rate : float,
                post_process : callable,
                plot : bool = True, bbox_plot : list[list[float]] = [[-1.05, -1.05],[1.05, 1.05]],  
                delete_injection : bool = True,
                measure_time = True, 
                vis_confs = [], is_sdf = False):
    set_matplotlib(9)
    num_conf = wos.input.shape.out_boundary.num_confs
    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

    # Record the objective optimization parameters
    record_dict = {}
    if wos_obj is not None:
        if is_sdf:
            record_dict[f"tensor-obj"] = wos_obj.input.shape.in_boundaries[0].tensor.numpy()
            record_dict[f"tensor-0"] = wos.input.shape.in_boundaries[0].tensor.numpy()
        else:
            record_dict[f"origin-obj"] = wos_obj.input.shape.in_boundaries[0].origin.numpy()
            record_dict[f"radius-obj"] = wos_obj.input.shape.in_boundaries[0].radius.numpy()
            record_dict[f"origin-0"] = wos.input.shape.in_boundaries[0].origin.numpy()
            record_dict[f"radius-0"] = wos.input.shape.in_boundaries[0].radius.numpy()
    
    # 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, electrode_nums = compute_primals(wos, primal_spe, seed, delete_injection,
                                                           confs_iter = num_electrodes, num_electrodes= num_electrodes, conf_numbers = conf_numbers_all)
    
    losses = MSE_numpy(primals, objectives)

    # Create the optimizer
    opt = mi.ad.Adam(lr= learning_rate, params = wos.opt_params)
    wos.update(opt)

    loss_list = []
    loss_reg_list = []
    #if max_dirichlet > 0:
    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()
    
    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):
        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)

        obj_opaque = ArrayXf(obj_res_iter.tolist())
        dr.make_opaque(obj_opaque)

        result, _ = wos.create_normal_derivative(res_normalder, spp_normalder, distance = dist_normalder, conf_numbers=confs_opaque)
        #dr.eval(result)
        wos.input.shape.in_boundaries[0].set_normal_derivative(result)
        points, active_conf, electrode_nums = wos.input.shape.out_boundary.create_electrode_points(spe, conf_numbers=confs_opaque)
        
        #dr.set_log_level(3)
        L, _ = wos.solve(points, active_conf, conf_numbers=confs_opaque, all_inside = True)
        el_tensor = create_electrode_result(L, spe, electrode_nums, apply_normalization=True)
        #dr.set_log_level(0)

        loss_grad = compute_loss_grad(result = el_tensor, result_ref = obj_opaque)
        dL = compute_dL(L = L, loss_grad=loss_grad, spe = spe, electrode_nums=electrode_nums, apply_normalization=True)

        signal_np = el_tensor.numpy()
        primals[confs_iter] = signal_np
        losses[confs_iter] = MSE_numpy(signal_np, obj_res_iter)

        _ = wos.solve(points, active_conf, L_in = L, conf_numbers=confs_opaque, dL = dL, 
                      all_inside = True, normal_derivative_dist=dist_normalder, 
                      mode = dr.ADMode.Backward)
        opt.step()
        post_process(opt)
        wos.update(opt)

        record_dict[f"primals-{i+1}"] = np.array(primals)

        
        
        for key in opt.keys():
            record_dict[f"{key}-{i+1}"] = opt[key].numpy()

        
        loss_list.append(np.array(losses))  
        record_dict["loss"] = np.array(loss_list) 
        if is_sdf:
            record_dict[f"tensor-{i+1}"] = opt["inboundary.dirichlet.tensor"].numpy()
        else:
            record_dict[f"origin-{i+1}"] = opt["inboundary.dirichlet.origin"].numpy()
            record_dict[f"radius-{i+1}"] = opt["inboundary.dirichlet.radius"].numpy()

        print(f"Iteration {i} is finished. Loss = {np.array(losses).sum()}")
        #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)
    create_animation_shape(record_dict, path, num_iter-1, bbox_plot, wos, wos_obj = wos_obj, resolution = [1024, 1024], 
                           type = "sdf" if is_sdf else "sphere", plot_center = False)


    np.save(os.path.join(path, "record.npy"), record_dict)
    print("Animations are generated.")