| import argparse |
| import mitsuba as mi |
| mi.set_variant("cuda_ad_rgb") |
| import numpy as np |
| import os |
| from python2D.optimizations.variable.textures_variable import * |
| from python2D.optimizations.variable.optimize_variable import * |
| from python2D.optimizations.sketch import * |
| from PDE2D.utils import * |
| from PDE2D.BoundaryShape import * |
| from PDE2D.Solver import * |
| from PDE2D import PATH, GreenSampling, Split |
|
|
|
|
|
|
| root_directory = os.path.join(PATH, "output2D", "optimizations", "variable") |
| def main(): |
| parser = argparse.ArgumentParser(description='''Optimization Sphere''') |
| parser.add_argument('--spp', default = 12, type=int) |
| parser.add_argument('--primalspp', default = 14, type=int) |
| parser.add_argument('--objspp', default = 14, type=int) |
| parser.add_argument('--seedobj', default = 16, type=int) |
| parser.add_argument('--seed', default = 243, type=int) |
| parser.add_argument('--confiter', default = 6, type=int) |
| parser.add_argument('--iternum', default = 512, type=int) |
| parser.add_argument("--lr", default = "0.1", type = float) |
| parser.add_argument("--epsilon", default = "1e-2", type = float) |
| parser.add_argument("--plot", action="store_true") |
| parser.add_argument("--split", default = "normal", type = str) |
| parser.add_argument("--noaccel", action="store_true") |
| parser.add_argument("--splitdepth", default=250, type=int) |
| parser.add_argument("--computevariance", action = "store_true") |
| parser.add_argument("--regularization", default = "none", type = str) |
| parser.add_argument("--regL", default = "0.01", type = float) |
| parser.add_argument("--scaletexture", default = 1.0, type=float) |
| parser.add_argument("--biastexture", default = 0.0, type=float) |
| parser.add_argument("--conf", default = "1", type = str) |
| parser.add_argument("--verbose", action = "store_true") |
| parser.add_argument("--stepnum", default = 1, type = int) |
| parser.add_argument("--res", default = 32, type = float) |
| parser.add_argument("--averagepixel", action = "store_true") |
| parser.add_argument("--coeff", default = "source", type = str) |
| parser.add_argument("--dirichlet", action = "store_true") |
| parser.add_argument("--restensor", default = 16, type = int) |
| parser.add_argument("--screening", default = 0, type = float) |
| parser.add_argument("--measuretime", action = "store_true") |
| parser.add_argument("--confboundary", type = int, default = -1) |
| parser.add_argument("--zeroboundary", action = "store_true") |
| parser.add_argument("--visconf", default = -1, type = int) |
|
|
| args = parser.parse_args() |
| step_num = args.stepnum |
| centered = not args.averagepixel |
| bbox = [[-1,-1],[1, 1]] |
| compute_variance = args.computevariance |
| use_accel = not args.noaccel |
| split_depth = args.splitdepth |
| e_shell = args.epsilon |
| plot = args.plot |
| seed_obj = args.seedobj |
| seed = args.seed |
| res_primal = int(args.res) |
| resolution_primal = [res_primal, res_primal] |
| spp_obj = 2 ** args.objspp |
| spp = 2 ** args.spp |
| primal_spp = 2 ** args.primalspp |
| conf_per_iter = args.confiter |
| num_iter = args.iternum |
| learning_rate = args.lr |
| λ = args.regL |
| bias = args.biastexture |
| scale = args.scaletexture |
| coeff_name = args.coeff |
| only_dirichlet = args.dirichlet |
| res_tensor = args.restensor |
| resolution_tensor = [res_tensor, res_tensor] |
| screening = args.screening |
|
|
| if coeff_name == "diffusion" and bias == 0: |
| raise Exception("Please give a positive bias value.") |
| |
| |
| if args.split == "none": |
| split = Split.Naive |
| elif args.split == "agressive": |
| split = Split.Agressive |
| elif args.split == "normal": |
| split = Split.Normal |
| else: |
| raise Exception("No such split is defined.") |
| |
|
|
| if args.regularization == "none": |
| regularization = RegularizationType.none |
| elif args.regularization == "L2": |
| regularization = RegularizationType.L2 |
| elif args.regularization == "tensorL2": |
| regularization = RegularizationType.tensoL2 |
| elif args.regularization == "L1": |
| regularization = RegularizationType.L1 |
| elif args.regularization == "tensorL1": |
| regularization = RegularizationType.tensorL1 |
| elif args.regularization == "TV": |
| regularization = RegularizationType.TV |
| elif args.regularization == "gradL1": |
| regularization = RegularizationType.gradL1 |
| elif args.regularization == "gradL2": |
| regularization = RegularizationType.gradL2 |
| elif args.regularization == "screeningL1": |
| regularization = RegularizationType.screeningL1 |
| elif args.regularization == "screeningL2": |
| regularization = RegularizationType.screeningL2 |
| else: |
| raise Exception("No such regularization is defined.") |
| |
| conf_name = f"conf{args.conf}" |
| centered_name = "centered" if centered else "avg" |
| res_name = f"res{args.res}" |
| screening_name = f"screen{screening}" |
| spp_name = f"spp{args.primalspp}_{args.spp}" |
| restensor_name = f"restensor{res_tensor}" |
| seed_name = f"seed{seed}" |
| e_name = f"epsilon{args.epsilon}" |
| reg_name = "none" if args.regularization == "none" else f"{args.regularization}-{λ}" |
| scale_name = f"scale{scale}-bias{bias}" |
| boundary_name = "dirichlet" if only_dirichlet else "mixed" |
|
|
| if args.visconf < 0: |
| vis_confs = [] |
| else: |
| vis_confs = [dr.opaque(UInt32, args.visconf, shape =(1))] |
|
|
|
|
| dirichlet, neumann = load_boundary_data(only_dirichlet | (coeff_name == "diffusion"), zero = (coeff_name == "source")) |
| |
| |
| if args.confboundary == -1: |
| if coeff_name == "source": |
| boundary_conf = 1 |
| elif coeff_name == "screening": |
| boundary_conf = 2 |
| elif coeff_name == "diffusion": |
| boundary_conf = 3 |
| else: |
| boundary_conf = args.confboundary |
| |
| boundary = load_bunny(dirichlet = dirichlet, neumann = neumann, all_dirichlet = only_dirichlet, epsilon=e_shell, conf = boundary_conf) |
| |
| obj_name = f"{coeff_name}-{conf_name}" |
| image_obj = objectives[obj_name] |
|
|
| image_obj *= scale |
| image_obj += bias |
|
|
| |
| image_begin = np.zeros(resolution_tensor) |
| |
| |
| image_begin *= scale |
| image_begin += bias |
|
|
| if coeff_name == "diffusion": |
| if args.zeroboundary: |
| grad_points = boundary.create_boundary_points(resolution = 64, spp = 2) |
| elif not only_dirichlet: |
| grad_points = boundary.create_neumann_points(resolution = 64, spp = 2) |
| else: |
| grad_points = None |
| α_obj = TextureCoefficient("diffusion", bbox, image_obj, grad_zero_points=grad_points, out_val = bias) |
| α = TextureCoefficient("diffusion", bbox, image_begin, grad_zero_points=grad_points, out_val = bias) |
| σ = ConstantCoefficient("screening", screening) |
| data_holder_obj = DataHolder(boundary, α = α_obj, σ = σ) |
| data_holder = DataHolder(boundary, α = α, σ = σ) |
| elif coeff_name == "screening": |
| σ_obj = TextureCoefficient("screening", bbox, image_obj, out_val = bias) |
| σ = TextureCoefficient("screening", bbox, image_begin, out_val = bias) |
| data_holder_obj = DataHolder(boundary, σ = σ_obj) |
| data_holder = DataHolder(boundary, σ = σ) |
| elif coeff_name == "source": |
| f_obj = TextureCoefficient("source", bbox, image_obj, out_val = bias) |
| f = TextureCoefficient("source", bbox, image_begin, out_val = bias) |
| σ = ConstantCoefficient("screening", screening) |
| data_holder_obj = DataHolder(boundary, f = f_obj, σ = σ) |
| data_holder = DataHolder(boundary, f = f, σ = σ) |
|
|
|
|
| opt_variable_name = f"{coeff_name}.texture.tensor" |
| wos_obj = WostVariable(data_holder_obj, green_sampling=GreenSampling.Polynomial, use_accelaration = use_accel) |
|
|
| opt_params = [opt_variable_name] |
| wos = WostVariable(data_holder, green_sampling=GreenSampling.Polynomial, use_accelaration = use_accel, opt_params = opt_params) |
|
|
| |
| def postprocess(opt, min_val, max_val): |
| opt[opt_variable_name] = dr.clip(opt[opt_variable_name], min_val, max_val) |
| |
| post_process = lambda opt : postprocess(opt, bias, 1.2 * np.max(image_obj)) |
|
|
| folder0 = f"{conf_name}-{coeff_name}" |
| if args.confboundary != -1: |
| folder0 += f"b{boundary_conf}" |
| folder1 = f"{boundary_name}-{res_name}-{scale_name}-{centered_name}" |
| folder1 += f"-{screening_name}" if coeff_name!="screening" else "" |
| folder2 = f"{spp_name}-{seed_name}-{e_name}" |
| folder3 = f"{restensor_name}-{reg_name}" |
| folder3 += f"-stepnum{step_num}" if step_num > 1 else "" |
| path_obj = os.path.join(root_directory, "objectives", folder0, folder1) |
| path = os.path.join(root_directory, folder0, folder1, folder2, folder3) |
| print(path) |
| create_path(path_obj) |
| create_path(path) |
|
|
| create_path(os.path.join(path, "npy", "primal")) |
| create_path(os.path.join(path, "npy", "grad")) |
| create_path(os.path.join(path, "npy", "tensor")) |
|
|
| coeff_obj = wos_obj.input.get_coefficient(coeff_name) |
| image_obj_ = plot_coeff(coeff_obj, wos.input.shape, bbox, path_obj, "objective", resolution = [256, 256], out_val = bias) |
| image_obj_ = plot_coeff(coeff_obj, wos.input.shape, bbox, path, "objective", resolution = [256, 256], out_val = bias) |
|
|
| obj_results = [] |
| for s in range(seed_obj): |
| file = f"{s}.npy" |
| filepath = os.path.join(path_obj, file) |
| if not os.path.isfile(filepath): |
| print(f"Generating objective results for seed {s}.") |
| tensor, std = compute_primals(wos_obj, Split.Agressive, s, bbox, resolution_primal, spp_obj, centered, split_depth, compute_variance, confs_iter = 16) |
| np.save(filepath, tensor) |
| if compute_variance: |
| filepath_std = os.path.join(path_obj, f"{s}_std.npy") |
| np.save(filepath_std, std) |
| obj_iter = np.load(filepath, allow_pickle = True) |
| obj_results.append(obj_iter) |
|
|
| obj_results = np.mean(np.array(obj_results), axis = 0) |
| max_range = [bias, 1.1 * np.max(image_obj_)] |
|
|
| print("Objective Results are loaded.") |
| if plot: |
| iter_plot(wos_obj, bbox, path, "objective", compute_std = compute_variance, out_val = bias, opt_param = coeff_name) |
|
|
| wos = optimize_variable(path, wos, wos_obj, obj_results, coeff_name, split, bbox, resolution_primal, spp, primal_spp, seed, conf_per_iter, split_depth, |
| num_iter, learning_rate, regularization, λ, post_process, centered, plot, compute_variance, args.verbose, max_range, out_val = bias, |
| measure_time=args.measuretime, vis_confs=vis_confs) |
| |
| |
| |
| if __name__ == "__main__": |
| main() |
