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
