def test_10_RandomParameters(self): """ Testing RandomParameters """ global folder, plot test_name = 'pygpc_test_10_RandomParameters' print(test_name) parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) parameters["x2"] = pygpc.Beta(pdf_shape=[5, 5], pdf_limits=[0, 1]) parameters["x3"] = pygpc.Beta(pdf_shape=[5, 2], pdf_limits=[0, 1]) parameters["x4"] = pygpc.Beta(pdf_shape=[2, 5], pdf_limits=[0, 1]) parameters["x5"] = pygpc.Beta(pdf_shape=[0.75, 0.75], pdf_limits=[0, 1]) parameters["x6"] = pygpc.Norm(pdf_shape=[5, 1]) if plot: ax = parameters["x1"].plot_pdf() ax = parameters["x2"].plot_pdf() ax = parameters["x3"].plot_pdf() ax = parameters["x4"].plot_pdf() ax = parameters["x5"].plot_pdf() ax = parameters["x6"].plot_pdf() ax.legend(["x1", "x2", "x3", "x4", "x5", "x6"]) ax.savefig(os.path.join(folder, test_name) + ".png")
def test_8_GPU(self): """ Testing GPU functionalities """ global folder, gpu test_name = 'pygpc_test_8_GPU' print(test_name) if gpu: # define model model = pygpc.testfunctions.DiscontinuousRidgeManufactureDecay() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) parameters["x2"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["GPU"] = False # define test grid grid = pygpc.RandomGrid(parameters_random=problem.parameters_random, options={"n_grid": 100, "seed": 1}) # setup gPC gpc = pygpc.Reg(problem=problem, order=[8, 8], order_max=8, order_max_norm=0.8, interaction_order=2, interaction_order_current=2, options=options, validation=None) # init gPC matrices gpc.init_gpc_matrix() # set some coeffs coeffs = np.random.rand(gpc.basis.n_basis, 2) # get approximation gpc.get_approximation(coeffs=coeffs, x=grid.coords_norm) print("done!\n") else: print("Skipping GPU test...\n")
import pygpc from collections import OrderedDict fn_results = 'tmp/mestatic' # filename of output save_session_format = ".hdf5" # file format of saved gpc session ".hdf5" (slow) or ".pkl" (fast) #%% # Loading the model and defining the problem # ------------------------------------------ # define model model = pygpc.testfunctions.SurfaceCoverageSpecies() # define problem parameters = OrderedDict() parameters["rho_0"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) parameters["beta"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 20]) parameters["alpha"] = 1. problem = pygpc.Problem(model, parameters) #%% # Setting up the algorithm # ------------------------ # gPC options options = dict() options["method"] = "reg" options["solver"] = "Moore-Penrose" options["settings"] = None options["order"] = [10, 10] options["order_max"] = 10
import pygpc import numpy as np from collections import OrderedDict fn_results = 'tmp/electrode' # filename of output save_session_format = ".hdf5" # file format of saved gpc session ".hdf5" (slow) or ".pkl" (fast) # define model model = pygpc.testfunctions.ElectrodeModel() # define problem parameters = OrderedDict() # Set parameters mu_n_Qdl = 0.67 parameters["n_Qdl"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[mu_n_Qdl * 0.9, mu_n_Qdl * 1.1]) mu_Qdl = 6e-7 parameters["Qdl"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[mu_Qdl * 0.9, mu_Qdl * 1.1]) mu_n_Qd = 0.95 mu_n_Qd_end = 1.0 parameters["n_Qd"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[mu_n_Qd * 0.9, mu_n_Qd_end]) mu_Qd = 4e-10 parameters["Qd"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[mu_Qd * 0.9, mu_Qd * 1.1]) Rs_begin = 0 Rs_end = 1000 parameters["Rs"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[Rs_begin, Rs_end]) mu_Rct = 10e3 parameters["Rct"] = pygpc.Beta(pdf_shape=[1, 1],
:math:`p_{ij} \\in \\mathbb{N}, {1,...,n}` and u is uniform random number :math:`u \\in [0,1]` """ ############################################################################### # Constructing a simple LHS design # -------------------------------- # We are going to create a simple LHS design for 2 random variables with 5 sampling points: import pygpc import matplotlib.pyplot as plt import numpy as np from collections import OrderedDict # define parameters parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[-np.pi, np.pi]) parameters["x2"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[-np.pi, np.pi]) # define grid lhs = pygpc.LHS(parameters_random=parameters, n_grid=0) # draw samples pi = lhs.get_lhs_grid(dim=2, n=5) # plot fig = plt.figure(figsize=(4, 4)) plt.scatter(pi[:, 0], pi[:, 1]) plt.grid(True) # \\rho_{rg_{X_i}, rg_{X_j}} = \\frac{cov(rg_{X_i}, rg_{X_j})}{\\sigma_{rg} \\sigma_{rg}}
# Beta distributed random variables # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # Probability density function: # # .. math:: # # p(x) = \left(\frac{\Gamma(p)\Gamma(q)}{\Gamma(p+q)}(b-a)^{(p+q-1)}\right)^{-1} (x-a)^{(p-1)} (b-x)^{(q-1)} # # The shape parameters of beta distributed random variable are defined with the parameter pdf_shape :math:`=[p, q]` # and the limits with pdf_limits :math:`=[a, b]`. import pygpc from collections import OrderedDict parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[5, 5], pdf_limits=[0, 1]) parameters["x2"] = pygpc.Beta(pdf_shape=[5, 2], pdf_limits=[0, 1]) parameters["x3"] = pygpc.Beta(pdf_shape=[2, 10], pdf_limits=[0, 1]) parameters["x4"] = pygpc.Beta(pdf_shape=[0.75, 0.75], pdf_limits=[0, 1]) parameters["x5"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) ax = parameters["x1"].plot_pdf() ax = parameters["x2"].plot_pdf() ax = parameters["x3"].plot_pdf() ax = parameters["x4"].plot_pdf() ax = parameters["x5"].plot_pdf() ax.legend(["x1", "x2", "x3", "x4", "x5"]) #%% # Normal distributed random variables # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ # Probability density function:
# We are going to compare the forward approximation method (most exact but needs additional simulations) with the # first and second order approximations. For each method, we define different distances/radii :math:`dx`: methods = ["FD_fwd", "FD_1st", "FD_2nd"] dx = [1e-3, 0.1, 0.2] #%% # We are going to compare the methods using the "Peaks" function and we are defining # the parameter space by setting up the problem: # define model model = pygpc.testfunctions.Peaks() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[1.2, 2]) parameters["x2"] = 1. parameters["x3"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 0.6]) problem = pygpc.Problem(model, parameters) #%% # Depending on the grid and its density, the methods will behave differently. # Here, we use 100 random sampling points in the parameter space defined before. # define grid n_grid = 100 grid = pygpc.Random(parameters_random=problem.parameters_random, n_grid=n_grid, seed=1) #%%
#%% # Setting up the gPC and the grid of sampling points # ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ import pygpc import numpy as np from collections import OrderedDict # define model model = pygpc.testfunctions.DiscontinuousRidgeManufactureDecay() # define parameters parameters = OrderedDict() for i_dim in range(n_dim): parameters["x" + str(i_dim)] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[1.2, 2]) # define problem problem = pygpc.Problem(model, parameters) # define grid options = dict() grid = pygpc.Random(parameters_random=problem.parameters_random, n_grid=n_samples, options={ "n_grid": n_samples, "seed": 1 }) # define gPC gpc = pygpc.Reg(problem=problem,
def test_12_Matlab_gpc(self): """ Algorithm: RegAdaptive Method: Regression Solver: Moore-Penrose Grid: RandomGrid """ global folder, plot, matlab test_name = 'pygpc_test_12_Matlab_gpc' print(test_name) if matlab: import matlab.engine from templates.MyModel_matlab import MyModel_matlab # define model model = MyModel_matlab(fun_path=os.path.join(pygpc.__path__[0], "testfunctions")) # define problem (the parameter names have to be the same as in the model) parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[-np.pi, np.pi]) parameters["x2"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[-np.pi, np.pi]) parameters["x3"] = 0. parameters["a"] = 7. parameters["b"] = 0.1 problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["order_start"] = 5 options["order_end"] = 20 options["solver"] = "LarsLasso" options["interaction_order"] = 2 options["order_max_norm"] = 0.7 options["n_cpu"] = 0 options["adaptive_sampling"] = True options["gradient_enhanced"] = True options["fn_results"] = os.path.join(folder, test_name) options["eps"] = 0.0075 options["matlab_model"] = True # define algorithm algorithm = pygpc.RegAdaptive(problem=problem, options=options) # run gPC algorithm gpc, coeffs, results = algorithm.run() if plot: # Validate gPC vs original model function (2D-surface) pygpc.validate_gpc_plot(gpc=gpc, coeffs=coeffs, random_vars=list(problem.parameters_random.keys()), n_grid=[51, 51], output_idx=0, fn_out=None, n_cpu=options["n_cpu"]) # Post-process gPC pygpc.get_sensitivities_hdf5(fn_gpc=options["fn_results"], output_idx=None, calc_sobol=True, calc_global_sens=True, calc_pdf=True, algorithm="sampling", n_samples=1e3) # Validate gPC vs original model function (Monte Carlo) nrmsd = pygpc.validate_gpc_mc(gpc=gpc, coeffs=coeffs, n_samples=int(1e4), output_idx=0, n_cpu=options["n_cpu"], smooth_pdf=True, fn_out=None, plot=plot) files_consistent, error_msg = pygpc.check_file_consistency(options["fn_results"] + ".hdf5") print("> Maximum NRMSD (gpc vs original): {:.2}%".format(np.max(nrmsd))) # self.expect_true(np.max(nrmsd) < 0.1, 'gPC test failed with NRMSD error = {:1.2f}%'.format(np.max(nrmsd)*100)) print("> Checking file consistency...") self.expect_true(files_consistent, error_msg) print("done!\n") else: print("Skipping Matlab test...")
def test_7_MERegAdaptiveProjection_gpc(self): """ Algorithm: MERegAdaptiveProjection Method: Regression Solver: Moore-Penrose Grid: RandomGrid """ global folder, plot test_name = 'pygpc_test_7_MERegAdaptiveProjection_gpc' print(test_name) # define model model = pygpc.testfunctions.DiscontinuousRidgeManufactureDecay() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) parameters["x2"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["method"] = "reg" options["solver"] = "Moore-Penrose" options["settings"] = None options["order_start"] = 0 options["order_end"] = 15 options["interaction_order"] = 2 options["matrix_ratio"] = 2 options["projection"] = True options["n_cpu"] = 0 options["gradient_enhanced"] = True options["gradient_calculation"] = "standard_forward" options["error_type"] = "loocv" options["n_samples_validation"] = 1e4 options["qoi"] = "all" options["classifier"] = "learning" options["classifier_options"] = {"clusterer": "KMeans", "n_clusters": 2, "classifier": "MLPClassifier", "classifier_solver": "lbfgs"} options["n_samples_discontinuity"] = 10 options["adaptive_sampling"] = True options["eps"] = 0.01 options["n_grid_init"] = 10 options["GPU"] = False options["fn_results"] = os.path.join(folder, test_name) # define algorithm algorithm = pygpc.MERegAdaptiveProjection(problem=problem, options=options) # run gPC algorithm gpc, coeffs, results = algorithm.run() if plot: # Validate gPC vs original model function (2D-surface) pygpc.validate_gpc_plot(gpc=gpc, coeffs=coeffs, random_vars=list(problem.parameters_random.keys()), n_grid=[51, 51], output_idx=0, fn_out=None, n_cpu=options["n_cpu"]) # Post-process gPC pygpc.get_sensitivities_hdf5(fn_gpc=options["fn_results"], output_idx=None, calc_sobol=True, calc_global_sens=True, calc_pdf=True, algorithm="sampling", n_samples=1e3) # Validate gPC vs original model function (Monte Carlo) nrmsd = pygpc.validate_gpc_mc(gpc=gpc, coeffs=coeffs, n_samples=int(1e4), output_idx=0, n_cpu=options["n_cpu"], smooth_pdf=True, fn_out=None, plot=plot) files_consistent, error_msg = pygpc.check_file_consistency(options["fn_results"] + ".hdf5") print("> Maximum NRMSD (gpc vs original): {:.2}%".format(np.max(nrmsd))) # self.expect_true(np.max(nrmsd) < 0.1, 'gPC test failed with NRMSD error = {:1.2f}%'.format(np.max(nrmsd)*100)) print("> Checking file consistency...") self.expect_true(files_consistent, error_msg) print("done!\n")
def test_0_Static_gpc_quad(self): """ Algorithm: Static Method: Quadrature Solver: NumInt Grid: TensorGrid """ global folder, plot test_name = 'pygpc_test_0_Static_gpc_quad' print(test_name) # define model model = pygpc.testfunctions.Peaks() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[1.2, 2]) parameters["x2"] = 1.25 parameters["x3"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 0.6]) problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["method"] = "quad" options["solver"] = "NumInt" options["settings"] = None options["order"] = [9, 9] options["order_max"] = 9 options["interaction_order"] = 2 options["error_type"] = "nrmsd" options["n_cpu"] = 0 options["fn_results"] = os.path.join(folder, test_name) options["GPU"] = False # generate grid grid = pygpc.TensorGrid(parameters_random=problem.parameters_random, options={"grid_type": ["jacobi", "jacobi"], "n_dim": [9, 9]}) # define algorithm algorithm = pygpc.Static(problem=problem, options=options, grid=grid) # run gPC algorithm gpc, coeffs, results = algorithm.run() # Post-process gPC pygpc.get_sensitivities_hdf5(fn_gpc=options["fn_results"], output_idx=None, calc_sobol=True, calc_global_sens=True, calc_pdf=True, algorithm="standard", n_samples=1e3) # Validate gPC vs original model function (Monte Carlo) nrmsd = pygpc.validate_gpc_mc(gpc=gpc, coeffs=coeffs, n_samples=int(1e4), output_idx=0, fn_out=None, plot=plot) files_consistent, error_msg = pygpc.check_file_consistency(options["fn_results"] + ".hdf5") print("> Maximum NRMSD (gpc vs original): {:.2}%".format(np.max(nrmsd))) # self.expect_true(np.max(nrmsd) < 0.1, 'gPC test failed with NRMSD error = {:1.2f}%'.format(np.max(nrmsd)*100)) print("> Checking file consistency...") self.expect_true(files_consistent, error_msg) print("done!\n")
def test_3_StaticProjection_gpc(self): """ Algorithm: StaticProjection Method: Regression Solver: Moore-Penrose Grid: RandomGrid """ global folder, plot test_name = 'pygpc_test_3_StaticProjection_gpc' print(test_name) # define model model = pygpc.testfunctions.GenzOscillatory() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1., 1.], pdf_limits=[0., 1.]) parameters["x2"] = pygpc.Beta(pdf_shape=[1., 1.], pdf_limits=[0., 1.]) problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["method"] = "reg" options["solver"] = "Moore-Penrose" options["settings"] = None options["order"] = [10] options["order_max"] = 10 options["interaction_order"] = 1 options["n_cpu"] = 0 options["error_type"] = "nrmsd" options["error_norm"] = "relative" options["matrix_ratio"] = 2 options["qoi"] = 0 options["n_grid_gradient"] = 50 options["fn_results"] = os.path.join(folder, test_name) options["gradient_enhanced"] = True # define algorithm algorithm = pygpc.StaticProjection(problem=problem, options=options) # run gPC algorithm gpc, coeffs, results = algorithm.run() if plot: # Validate gPC vs original model function (2D-surface) pygpc.validate_gpc_plot(gpc=gpc, coeffs=coeffs, random_vars=list(problem.parameters_random.keys()), n_grid=[51, 51], output_idx=0, fn_out=None, n_cpu=options["n_cpu"]) # Post-process gPC pygpc.get_sensitivities_hdf5(fn_gpc=options["fn_results"], output_idx=None, calc_sobol=True, calc_global_sens=True, calc_pdf=True, algorithm="sampling", n_samples=1e3) # Validate gPC vs original model function (Monte Carlo) nrmsd = pygpc.validate_gpc_mc(gpc=gpc, coeffs=coeffs, n_samples=int(1e4), output_idx=0, n_cpu=options["n_cpu"], smooth_pdf=False, fn_out=None, plot=plot) files_consistent, error_msg = pygpc.check_file_consistency(options["fn_results"] + ".hdf5") print("> Maximum NRMSD (gpc vs original): {:.2}%".format(np.max(nrmsd))) # self.expect_true(np.max(nrmsd) < 0.1, 'gPC test failed with NRMSD error = {:1.2f}%'.format(np.max(nrmsd)*100)) print("> Checking file consistency...") self.expect_true(files_consistent, error_msg) print("done!\n")
import pygpc from collections import OrderedDict fn_results = 'tmp/mestaticprojection' # filename of output save_session_format = ".hdf5" # file format of saved gpc session ".hdf5" (slow) or ".pkl" (fast) #%% # Loading the model and defining the problem # ------------------------------------------ # define model model = pygpc.testfunctions.DiscontinuousRidgeManufactureDecay() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) parameters["x2"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[0, 1]) problem = pygpc.Problem(model, parameters) #%% # Setting up the algorithm # ------------------------ # gPC options options = dict() options["method"] = "reg" options["solver"] = "Moore-Penrose" options["settings"] = None options["order"] = [3, 3] options["order_max"] = 3 options["interaction_order"] = 2
import pygpc from collections import OrderedDict from tutorials.PyRates_CNS_Model_old import PyRates_CNS_Model import warnings warnings.filterwarnings("ignore", category=RuntimeWarning) warnings.filterwarnings("ignore", category=FutureWarning) fn_results = os.path.join( os.path.split(pygpc.__path__[0])[0], "tutorials", "datasets", "PyRates_CNS_GPC_new") model = PyRates_CNS_Model() # define problem (the parameter names have to be the same as in the model) parameters = OrderedDict() parameters["w_ein_pc"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[5.4, 21.6]) parameters["w_iin_pc"] = pygpc.Beta(pdf_shape=[1, 1], pdf_limits=[11.8125, 47.25]) problem = pygpc.Problem(model, parameters) # gPC options options = dict() options["solver"] = "LarsLasso" options["settings"] = None options["order_start"] = 3 options["order_end"] = 15 options["seed"] = 1 options["projection"] = False options["order_max_norm"] = 1. options["interaction_order"] = 2 options["matrix_ratio"] = 2
import pygpc from collections import OrderedDict fn_results = 'tmp/staticprojection' # filename of output save_session_format = ".hdf5" # file format of saved gpc session ".hdf5" (slow) or ".pkl" (fast) #%% # Loading the model and defining the problem # ------------------------------------------ # define model model = pygpc.testfunctions.GenzOscillatory() # define problem parameters = OrderedDict() parameters["x1"] = pygpc.Beta(pdf_shape=[1., 1.], pdf_limits=[0., 1.]) parameters["x2"] = pygpc.Beta(pdf_shape=[1., 1.], pdf_limits=[0., 1.]) problem = pygpc.Problem(model, parameters) #%% # Setting up the algorithm # ------------------------ # gPC options options = dict() options["method"] = "reg" options["solver"] = "Moore-Penrose" options["settings"] = None options["order"] = [10] options["order_max"] = 10 options["interaction_order"] = 1