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")
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 options["interaction_order"] = 2 options["matrix_ratio"] = 2 options["n_cpu"] = 0
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")
