def test_pce_sensitivities_of_sobol_g_function(self):
nsamples = 2000
nvars, degree = 3, 8
a = np.array([1, 2, 5])[:nvars]
univariate_variables = [uniform(0, 1)] * nvars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
indices = pya.tensor_product_indices([degree] * nvars)
poly.set_indices(indices)
#print('No. PCE Terms',indices.shape[1])
samples = pya.generate_independent_random_samples(
var_trans.variable, nsamples)
samples = (np.cos(np.random.uniform(0, np.pi,
(nvars, nsamples))) + 1) / 2
values = sobol_g_function(a, samples)
basis_matrix = poly.basis_matrix(samples)
weights = 1 / np.sum(basis_matrix**2, axis=1)[:, np.newaxis]
coef = np.linalg.lstsq(basis_matrix * weights,
values * weights,
rcond=None)[0]
poly.set_coefficients(coef)
nvalidation_samples = 1000
validation_samples = pya.generate_independent_random_samples(
var_trans.variable, nvalidation_samples)
validation_values = sobol_g_function(a, validation_samples)
poly_validation_vals = poly(validation_samples)
rel_error = np.linalg.norm(poly_validation_vals - validation_values
) / np.linalg.norm(validation_values)
print('Rel. Error', rel_error)
pce_main_effects, pce_total_effects =\
pya.get_main_and_total_effect_indices_from_pce(
poly.get_coefficients(), poly.get_indices())
interaction_terms, pce_sobol_indices = get_sobol_indices(
poly.get_coefficients(), poly.get_indices(), max_order=3)
mean, variance, main_effects, total_effects, sobol_indices = \
get_sobol_g_function_statistics(a, interaction_terms)
assert np.allclose(poly.mean(), mean, atol=1e-2)
# print((poly.variance(),variance))
assert np.allclose(poly.variance(), variance, atol=1e-2)
# print(pce_main_effects,main_effects)
assert np.allclose(pce_main_effects, main_effects, atol=1e-2)
# print(pce_total_effects,total_effects)
assert np.allclose(pce_total_effects, total_effects, atol=1e-2)
assert np.allclose(pce_sobol_indices, sobol_indices, atol=1e-2)
def help_cross_validate_pce_degree(self, solver_type, solver_options):
print(solver_type, solver_options)
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree = 3
poly.set_indices(pya.compute_hyperbolic_indices(num_vars, degree, 1.0))
# factor of 2 does not pass test but 2.2 does
num_samples = int(poly.num_terms() * 2.2)
coef = np.random.normal(0, 1, (poly.indices.shape[1], 2))
coef[pya.nchoosek(num_vars + 2, 2):, 0] = 0
# for first qoi make degree 2 the best degree
poly.set_coefficients(coef)
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
true_poly = poly
poly = approximate(
train_samples, train_vals, "polynomial_chaos", {
"basis_type": "hyperbolic_cross",
"variable": variable,
"options": {
"verbose": 3,
"solver_type": solver_type,
"min_degree": 1,
"max_degree": degree + 1,
"linear_solver_options": solver_options
}
}).approx
num_validation_samples = 10
validation_samples = pya.generate_independent_random_samples(
variable, num_validation_samples)
assert np.allclose(poly(validation_samples),
true_poly(validation_samples))
poly = copy.deepcopy(true_poly)
approx_res = cross_validate_pce_degree(
poly,
train_samples,
train_vals,
1,
degree + 1,
solver_type=solver_type,
linear_solver_options=solver_options)
assert np.allclose(approx_res.degrees, [2, 3])
def test_approximate_fixed_pce(self):
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree, hcross_strength = 7, 0.4
poly.set_indices(
pya.compute_hyperbolic_indices(num_vars, degree, hcross_strength))
num_samples = poly.num_terms() * 2
degrees = poly.indices.sum(axis=0)
coef = np.random.normal(
0, 1, (poly.indices.shape[1], 2)) / (degrees[:, np.newaxis] + 1)**2
# set some coefficients to zero to make sure that different qoi
# are treated correctly.
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 0] = 0
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 1] = 0
poly.set_coefficients(coef)
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
indices = pya.compute_hyperbolic_indices(num_vars, 1, 1)
nfolds = 10
method = "polynomial_chaos"
options = {
"basis_type": "fixed",
"variable": variable,
"options": {
"linear_solver_options": {},
"indices": indices,
"solver_type": "lstsq"
}
}
approx_list, residues_list, cv_score = \
cross_validate_approximation(
train_samples, train_vals, options, nfolds, method,
random_folds=False)
solver = LinearLeastSquaresCV(cv=nfolds, random_folds=False)
poly.set_indices(indices)
basis_matrix = poly.basis_matrix(train_samples)
solver.fit(basis_matrix, train_vals[:, 0:1])
assert np.allclose(solver.cv_score_, cv_score[0])
solver.fit(basis_matrix, train_vals[:, 1:2])
assert np.allclose(solver.cv_score_, cv_score[1])
def test_pce_basis_expansion(self):
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree, hcross_strength = 7, 0.4
poly.set_indices(
pya.compute_hyperbolic_indices(num_vars, degree, hcross_strength))
num_samples = poly.num_terms() * 2
degrees = poly.indices.sum(axis=0)
coef = np.random.normal(
0, 1, (poly.indices.shape[1], 2)) / (degrees[:, np.newaxis] + 1)**2
# set some coefficients to zero to make sure that different qoi
# are treated correctly.
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 0] = 0
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 1] = 0
poly.set_coefficients(coef)
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
true_poly = poly
poly = approximate(
train_samples, train_vals, "polynomial_chaos", {
"basis_type": "expanding_basis",
"variable": variable,
"options": {
"max_num_expansion_steps_iter": 1,
"verbose": 3,
"max_num_terms": 1000,
"max_num_step_increases": 2,
"max_num_init_terms": 33
}
}).approx
num_validation_samples = 100
validation_samples = pya.generate_independent_random_samples(
variable, num_validation_samples)
validation_samples = train_samples
error = np.linalg.norm(
poly(validation_samples) -
true_poly(validation_samples)) / np.sqrt(num_validation_samples)
assert np.allclose(poly(validation_samples),
true_poly(validation_samples),
atol=1e-8), error
def __init__(self, mesh_dof=100, num_terms=35):
self.mesh = np.linspace(-1., 1., mesh_dof)
self.num_terms = num_terms
variable = [uniform(-1, 2)]
var_trans = pya.AffineRandomVariableTransformation(variable)
self.poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
self.poly.configure(poly_opts)
self.poly.set_indices(
pya.compute_hyperbolic_indices(1, self.num_terms - 1))
def get_quadrature_rule(self):
nvars = self.variable.num_vars()
degrees=[10]*nvars
var_trans = pya.AffineRandomVariableTransformation(self.variable)
gauss_legendre = partial(
pya.gauss_jacobi_pts_wts_1D,alpha_poly=0,beta_poly=0)
univariate_quadrature_rules = [
gauss_legendre,gauss_legendre,pya.gauss_hermite_pts_wts_1D,
pya.gauss_hermite_pts_wts_1D,pya.gauss_hermite_pts_wts_1D]
x,w = pya.get_tensor_product_quadrature_rule(
degrees,self.variable.num_vars(),univariate_quadrature_rules,
var_trans.map_from_canonical_space)
return x,w
def test_approximate_neural_network(self):
np.random.seed(2)
benchmark = setup_benchmark("ishigami", a=7, b=0.1)
nvars = benchmark.variable.num_vars()
nqoi = 1
maxiter = 30000
print(benchmark.variable)
# var_trans = pya.AffineRandomVariableTransformation(
# [stats.uniform(-2, 4)]*nvars)
var_trans = pya.AffineRandomVariableTransformation(benchmark.variable)
network_opts = {
"activation_func": "sigmoid",
"layers": [nvars, 75, nqoi],
"loss_func": "squared_loss",
"var_trans": var_trans,
"lag_mult": 0
}
optimizer_opts = {
"method": "L-BFGS-B",
"options": {
"maxiter": maxiter,
"iprint": -1,
"gtol": 1e-6
}
}
opts = {
"network_opts": network_opts,
"verbosity": 3,
"optimizer_opts": optimizer_opts
}
ntrain_samples = 500
train_samples = pya.generate_independent_random_samples(
var_trans.variable, ntrain_samples)
train_samples = var_trans.map_from_canonical_space(
np.cos(np.random.uniform(0, np.pi, (nvars, ntrain_samples))))
train_vals = benchmark.fun(train_samples)
opts = {
"network_opts": network_opts,
"verbosity": 3,
"optimizer_opts": optimizer_opts,
"x0": 10
}
approx = approximate(train_samples, train_vals, "neural_network",
opts).approx
nsamples = 100
error = compute_l2_error(approx, benchmark.fun, var_trans.variable,
nsamples)
print(error)
assert error < 6e-2
def test_pce_sensitivities_of_ishigami_function(self):
nsamples = 1500
nvars, degree = 3, 18
univariate_variables = [uniform(-np.pi, 2 * np.pi)] * nvars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
indices = pya.compute_hyperbolic_indices(nvars, degree, 1.0)
poly.set_indices(indices)
#print('No. PCE Terms',indices.shape[1])
samples = pya.generate_independent_random_samples(
var_trans.variable, nsamples)
values = ishigami_function(samples)
basis_matrix = poly.basis_matrix(samples)
coef = np.linalg.lstsq(basis_matrix, values, rcond=None)[0]
poly.set_coefficients(coef)
nvalidation_samples = 1000
validation_samples = pya.generate_independent_random_samples(
var_trans.variable, nvalidation_samples)
validation_values = ishigami_function(validation_samples)
poly_validation_vals = poly(validation_samples)
abs_error = np.linalg.norm(poly_validation_vals - validation_values
) / np.sqrt(nvalidation_samples)
#print('Abs. Error',abs_error)
pce_main_effects, pce_total_effects =\
pya.get_main_and_total_effect_indices_from_pce(
poly.get_coefficients(), poly.get_indices())
mean, variance, main_effects, total_effects, sobol_indices, \
sobol_interaction_indices = get_ishigami_funciton_statistics()
assert np.allclose(poly.mean(), mean)
assert np.allclose(poly.variance(), variance)
assert np.allclose(pce_main_effects, main_effects)
assert np.allclose(pce_total_effects, total_effects)
interaction_terms, pce_sobol_indices = get_sobol_indices(
poly.get_coefficients(), poly.get_indices(), max_order=3)
assert np.allclose(pce_sobol_indices, sobol_indices)
def test_approximate_polynomial_chaos_custom_poly_type(self):
benchmark = setup_benchmark("ishigami", a=7, b=0.1)
nvars = benchmark.variable.num_vars()
# this test purposefully select wrong variable to make sure
# poly_type overide is activated
univariate_variables = [stats.beta(5, 5, -np.pi, 2 * np.pi)] * nvars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
# specify correct basis so it is not chosen from var_trans.variable
poly_opts = {"var_trans": var_trans}
# but rather from another variable which will invoke Legendre polys
basis_opts = pya.define_poly_options_from_variable(
pya.IndependentMultivariateRandomVariable([stats.uniform()] *
nvars))
poly_opts["poly_types"] = basis_opts
options = {
"poly_opts": poly_opts,
"variable": variable,
"options": {
"max_num_step_increases": 1
}
}
ntrain_samples = 400
train_samples = np.random.uniform(-np.pi, np.pi,
(nvars, ntrain_samples))
train_vals = benchmark.fun(train_samples)
approx = approximate(train_samples,
train_vals,
method="polynomial_chaos",
options=options).approx
nsamples = 100
error = compute_l2_error(approx,
benchmark.fun,
approx.var_trans.variable,
nsamples,
rel=True)
# print(error)
assert error < 1e-4
assert np.allclose(approx.mean(), benchmark.mean, atol=error)
def test_pce_basis_expansion(self):
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree, hcross_strength = 7, 0.4
poly.set_indices(
pya.compute_hyperbolic_indices(num_vars, degree, hcross_strength))
num_samples = poly.num_terms() * 2
degrees = poly.indices.sum(axis=0)
poly.set_coefficients((np.random.normal(0, 1, poly.indices.shape[1]) /
(degrees + 1)**2)[:, np.newaxis])
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
true_poly = poly
poly = approximate(train_samples, train_vals, 'polynomial_chaos', {
'basis_type': 'expanding_basis',
'variable': variable
})
num_validation_samples = 100
validation_samples = pya.generate_independent_random_samples(
variable, num_validation_samples)
validation_samples = train_samples
error = np.linalg.norm(
poly(validation_samples) -
true_poly(validation_samples)) / np.sqrt(num_validation_samples)
assert np.allclose(
poly(validation_samples),true_poly(validation_samples),atol=1e-8),\
error
def test_cross_validate_pce_degree(self):
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree = 3
poly.set_indices(pya.compute_hyperbolic_indices(num_vars, degree, 1.0))
num_samples = poly.num_terms() * 2
poly.set_coefficients(
np.random.normal(0, 1, (poly.indices.shape[1], 1)))
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
true_poly = poly
poly = approximate(train_samples, train_vals, 'polynomial_chaos', {
'basis_type': 'hyperbolic_cross',
'variable': variable
})
num_validation_samples = 10
validation_samples = pya.generate_independent_random_samples(
variable, num_validation_samples)
assert np.allclose(poly(validation_samples),
true_poly(validation_samples))
poly = copy.deepcopy(true_poly)
poly, best_degree = cross_validate_pce_degree(poly, train_samples,
train_vals, 1,
degree + 2)
assert best_degree == degree
def test_cross_validate_approximation_after_regularization_selection(self):
"""
This test is useful as it shows how to use cross_validate_approximation
to produce a list of approximations on each cross validation fold
once regularization parameters have been chosen.
These can be used to show variance in predictions of values,
sensitivity indices, etc.
Ideally this could be avoided if sklearn stored the coefficients
and alphas for each fold and then we can just find the coefficients
that correspond to the first time the path drops below the best_alpha
"""
num_vars = 2
univariate_variables = [stats.uniform(-1, 2)] * num_vars
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree, hcross_strength = 7, 0.4
poly.set_indices(
pya.compute_hyperbolic_indices(num_vars, degree, hcross_strength))
num_samples = poly.num_terms() * 2
degrees = poly.indices.sum(axis=0)
coef = np.random.normal(
0, 1, (poly.indices.shape[1], 2)) / (degrees[:, np.newaxis] + 1)**2
# set some coefficients to zero to make sure that different qoi
# are treated correctly.
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 0] = 0
II = np.random.permutation(coef.shape[0])[:coef.shape[0] // 2]
coef[II, 1] = 0
poly.set_coefficients(coef)
train_samples = pya.generate_independent_random_samples(
variable, num_samples)
train_vals = poly(train_samples)
# true_poly = poly
result = approximate(train_samples, train_vals, "polynomial_chaos", {
"basis_type": "expanding_basis",
"variable": variable
})
# Even with the same folds, iterative methods such as Lars, LarsLasso
# and OMP will not have cv_score from approximate and cross validate
# approximation exactly the same because iterative methods interpolate
# residuals to compute cross validation scores
nfolds = 10
linear_solver_options = [{
"alpha": result.reg_params[0]
}, {
"alpha": result.reg_params[1]
}]
indices = [
result.approx.indices[:, np.where(np.absolute(c) > 0)[0]]
for c in result.approx.coefficients.T
]
options = {
"basis_type": "fixed",
"variable": variable,
"options": {
"linear_solver_options": linear_solver_options,
"indices": indices
}
}
approx_list, residues_list, cv_score = \
cross_validate_approximation(
train_samples, train_vals, options, nfolds, "polynomial_chaos",
random_folds="sklearn")
assert (np.all(cv_score < 6e-14) and np.all(result.scores < 4e-13))
def test_marginalize_polynomial_chaos_expansions(self):
univariate_variables = [uniform(-1, 2), norm(0, 1), uniform(-1, 2)]
variable = pya.IndependentMultivariateRandomVariable(
univariate_variables)
var_trans = pya.AffineRandomVariableTransformation(variable)
num_vars = len(univariate_variables)
poly = pya.PolynomialChaosExpansion()
poly_opts = pya.define_poly_options_from_variable_transformation(
var_trans)
poly.configure(poly_opts)
degree = 2
indices = pya.compute_hyperbolic_indices(num_vars, degree, 1)
poly.set_indices(indices)
poly.set_coefficients(np.ones((indices.shape[1], 1)))
pce_main_effects, pce_total_effects =\
pya.get_main_and_total_effect_indices_from_pce(
poly.get_coefficients(), poly.get_indices())
print(poly.num_terms())
for ii in range(num_vars):
# Marginalize out 2 variables
xx = np.linspace(-1, 1, 101)
inactive_idx = np.hstack(
(np.arange(ii), np.arange(ii + 1, num_vars)))
marginalized_pce = pya.marginalize_polynomial_chaos_expansion(
poly, inactive_idx, center=True)
mvals = marginalized_pce(xx[None, :])
variable_ii = variable.all_variables()[ii:ii + 1]
var_trans_ii = pya.AffineRandomVariableTransformation(variable_ii)
poly_ii = pya.PolynomialChaosExpansion()
poly_opts_ii = \
pya.define_poly_options_from_variable_transformation(
var_trans_ii)
poly_ii.configure(poly_opts_ii)
indices_ii = compute_hyperbolic_indices(1, degree, 1.)
poly_ii.set_indices(indices_ii)
poly_ii.set_coefficients(np.ones((indices_ii.shape[1], 1)))
pvals = poly_ii(xx[None, :])
# import matplotlib.pyplot as plt
# plt.plot(xx, pvals)
# plt.plot(xx, mvals, '--')
# plt.show()
assert np.allclose(mvals, pvals - poly.mean())
assert np.allclose(poly_ii.variance() / poly.variance(),
pce_main_effects[ii])
poly_ii.coefficients /= np.sqrt(poly.variance())
assert np.allclose(poly_ii.variance(), pce_main_effects[ii])
# Marginalize out 1 variable
xx = pya.cartesian_product([xx] * 2)
inactive_idx = np.array([ii])
marginalized_pce = pya.marginalize_polynomial_chaos_expansion(
poly, inactive_idx, center=True)
mvals = marginalized_pce(xx)
variable_ii = variable.all_variables()[:ii] +\
variable.all_variables()[ii+1:]
var_trans_ii = pya.AffineRandomVariableTransformation(variable_ii)
poly_ii = pya.PolynomialChaosExpansion()
poly_opts_ii = \
pya.define_poly_options_from_variable_transformation(
var_trans_ii)
poly_ii.configure(poly_opts_ii)
indices_ii = pya.compute_hyperbolic_indices(2, degree, 1.)
poly_ii.set_indices(indices_ii)
poly_ii.set_coefficients(np.ones((indices_ii.shape[1], 1)))
pvals = poly_ii(xx)
assert np.allclose(mvals, pvals - poly.mean())
# %%
# Here we have intentionally set the coefficients :math:`c`: of the Genz function to be highly anisotropic, to emphasize the properties of the adaptive algorithm.
#
# PCE represent the model output :math:`f(\V{\rv})` as an expansion in orthonormal polynomials,
#
# .. math::
#
# \begin{align*}
# f(\V{\rv}) &\approx f_N(\V{\rv}) = \sum_{\lambda\in\Lambda}\alpha_{\lambda}\phi_{\lambda}(\V{\rv}), & |\Lambda| &= N.
# \end{align*}
#
# where :math:`\lambda=(\lambda_1\ldots,\lambda_d)\in\mathbb{N}_0^d` is a multi-index and :math:`\Lambda` specifies the terms included in the expansion. In :ref:`Polynomial Chaos Regression` we set :math:`\Lambda` to be a total degree expansion. This choice was somewhat arbitray. The exact indices in :math:`\Lambda` should be chosen with more care. The number of terms in a PCE dictates how many samples are need to accurately compute the coefficients of the expansion. Consequently we should choose the index set :math:`\Lambda` in a way that minimizes error for a fixed computational budget. In this tutorial we use an adaptive algorithm to construct an index set that greedily minimizes the error in the PCE.
#
#Before starting the adaptive algorithm we will generate some test data to estimate the error in the PCE as the adaptive algorithm evolves. We will compute the error at each step using a callback function.
var_trans = pya.AffineRandomVariableTransformation(variable)
validation_samples = pya.generate_independent_random_samples(
var_trans.variable, int(1e3))
validation_values = model(validation_samples)
errors = []
num_samples = []
def callback(pce):
error = compute_l2_error(validation_samples, validation_values, pce)
errors.append(error)
num_samples.append(pce.samples.shape[1])
# %%
