# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# Validate gPC vs original model function
pygpc.validate_gpc_plot(session=session,
coeffs=coeffs,
random_vars=["Rd", "n_Qd"],
n_grid=[51, 51],
output_idx=500,
fn_out=None,
n_cpu=session.n_cpu)
#%%
# Validate gPC vs original model function (Monte Carlo)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
nrmsd = pygpc.validate_gpc_mc(session=session,
coeffs=coeffs,
n_samples=int(1e4),
output_idx=500,
n_cpu=session.n_cpu,
fn_out=None)
print("> Maximum NRMSD (gpc vs original): {:.2}%".format(max(nrmsd)))
#%%
# Mean and std of the real part of the model
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
# Result
_ = plt.figure(figsize=[15, 7])
_ = plt.imshow(plt.imread("../images/modified_Randles_circuit_GPC_re.png"))
_ = plt.axis('off')
#%%
# Mean and std of the imaginary part of the model
calc_global_sens=True,
calc_pdf=True,
algorithm="sampling",
n_samples=1e3)
#%%
# Validation
# ----------
# Validate gPC vs original model function (2D-surface)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
pygpc.validate_gpc_plot(session=session,
coeffs=coeffs,
random_vars=list(problem.parameters_random.keys()),
n_grid=[51, 51],
output_idx=[0],
fn_out=None,
folder=None,
n_cpu=session.n_cpu)
#%%
# Validate gPC vs original model function (Monte Carlo)
# ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
nrmsd = pygpc.validate_gpc_mc(session=session,
coeffs=coeffs,
n_samples=int(1e4),
output_idx=[0],
fn_out=None,
folder=None,
plot=True,
n_cpu=session.n_cpu)
print("> Maximum NRMSD (gpc vs original): {:.2}%".format(max(nrmsd)))
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...")
# define algorithm
algorithm = pygpc.Static(problem=problem,
options=options,
grid=grid)
# Initialize gPC Session
session = pygpc.Session(algorithm=algorithm)
# run gPC session
session, coeffs, results = session.run()
err[i_g, i_o, i_n] = pygpc.validate_gpc_mc(session=session,
coeffs=coeffs,
n_samples=int(1e4),
n_cpu=0,
output_idx=0,
fn_out=None,
plot=False)
n_grid[i_o] = grid.n_grid
err_mean = np.mean(err, axis=2)
err_std = np.std(err, axis=2)
#%%
# Results
# ^^^^^^^
# Even after a small set of repititions the :math:`\varphi_P` optimizing ESE will produce
# the best results regarding the aformentioned criteria, while also having less variation
# in its pseudo-random design. Thus is it possible to half the the root-mean-squared error
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")
# run gPC session
session, coeffs, results = session.run()
# Post-process gPC and add results to .hdf5 file
pygpc.get_sensitivities_hdf5(fn_gpc=session.fn_results,
output_idx=None,
calc_sobol=True,
calc_global_sens=True,
calc_pdf=True,
n_samples=1e4)
# Validate gPC vs original model function
pygpc.validate_gpc_plot(session=session,
coeffs=coeffs,
random_vars=["x1", "x2"],
n_grid=[51, 51],
output_idx=0,
fn_out=session.fn_results + '_val',
n_cpu=session.n_cpu)
# Validate gPC vs original model function (Monte Carlo)
nrmsd = pygpc.validate_gpc_mc(session=session,
coeffs=coeffs,
n_samples=int(1e4),
output_idx=0,
n_cpu=session.n_cpu,
fn_out=session.fn_results + '_mc')
print("done!\n")
# run gPC algorithm
gpc, coeffs, results = algorithm.run()
# Post-process gPC and add results to .hdf5 file
pygpc.get_sensitivities_hdf5(fn_gpc=options["fn_results"],
output_idx=None,
calc_sobol=True,
calc_global_sens=True,
calc_pdf=True,
n_samples=1e4)
# Validate gPC vs original model function
pygpc.validate_gpc_plot(gpc=gpc,
coeffs=coeffs,
random_vars=["x1", "x2"],
n_grid=[51, 51],
output_idx=0,
fn_out=gpc.options["fn_results"] + '_validation_plot',
n_cpu=options["n_cpu"])
# 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=gpc.options["n_cpu"],
fn_out=gpc.options["fn_results"] +
'_validation_mc')
print("done!\n")
