import openturns as ot
import numpy as np
from matplotlib import pyplot as plt
n_functions = 8
function_factory = ot.LaguerreFactory()
if function_factory.getClassName() == 'KrawtchoukFactory':
function_factory = ot.LaguerreFactory(n_functions, .5)
functions = [function_factory.build(i) for i in range(n_functions)]
measure = function_factory.getMeasure()
if hasattr(measure, 'getA') and hasattr(measure, 'getB'):
x_min = measure.getA()
x_max = measure.getB()
else:
x_min = measure.computeQuantile(1e-3)[0]
x_max = measure.computeQuantile(1. - 1e-3)[0]
n_points = 200
meshed_support = np.linspace(x_min, x_max, n_points)
fig = plt.figure()
ax = fig.add_subplot(111)
for i in range(n_functions):
plt.plot(meshed_support, [functions[i](x) for x in meshed_support],
lw=1.5,
label='$\phi_{' + str(i) + '}(x)$')
plt.xlabel('$x$')
plt.ylabel('$\phi_i(x)$')
plt.xlim(x_min, x_max)
plt.grid()
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width, box.height * 0.9])
plt.legend(loc='upper center', bbox_to_anchor=(.5, 1.25), ncol=4)
#! /usr/bin/env python
from __future__ import print_function
import openturns as ot
# Polynomial factories
factoryCollection = [
ot.LaguerreFactory(2.5),
ot.LegendreFactory(),
ot.HermiteFactory()
]
dim = len(factoryCollection)
basisFactory = ot.OrthogonalProductPolynomialFactory(factoryCollection)
basis = ot.OrthogonalBasis(basisFactory)
print('basis=', basis)
x = [0.5] * dim
for i in range(10):
f = basis.build(i)
print('i=', i, 'f(X)=', f(x))
# Using multi-indices
enum = basis.getEnumerateFunction()
for i in range(10):
indices = enum(i)
f = basis.build(indices)
print('indices=', indices, 'f(X)=', f(x))
# Other factories
factoryCollection = [
ot.OrthogonalUniVariatePolynomialFunctionFactory(ot.LaguerreFactory(2.5)),
ot.HaarWaveletFactory(),
def dali_pce(func,
N,
jpdf_cp,
jpdf_ot,
tol=1e-12,
max_fcalls=1000,
verbose=True,
interp_dict={}):
if not interp_dict: # if dictionary is empty --> cold-start
idx_act = [] # M_activated x N
idx_adm = [] # M_admissible x N
fevals_act = [] # M_activated x 1
fevals_adm = [] # M_admissible x 1
coeff_act = [] # M_activated x 1
coeff_adm = [] # M_admissible x 1
# start with 0 multi-index
knot0 = []
for n in range(N):
# get knots per dimension based on maximum index
kk, ww = seq_lj_1d(order=0, dist=jpdf_cp[n])
knot0.append(kk[0])
feval = func(knot0)
# update activated sets
idx_act.append([0] * N)
coeff_act.append(feval)
fevals_act.append(feval)
# local error indicators
local_error_indicators = np.abs(coeff_act)
# get the OT distribution type of each random variable
dist_types = []
for i in range(N):
dist_type = jpdf_ot.getMarginal(i).getName()
dist_types.append(dist_type)
# create orthogonal univariate bases
poly_collection = ot.PolynomialFamilyCollection(N)
for i in range(N):
if dist_types[i] == 'Uniform':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.LegendreFactory())
elif dist_types[i] == 'Normal':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.HermiteFactory())
elif dist_types[i] == 'Beta':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.JacobiFactory())
elif dist_types[i] == 'Gamma':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.LaguerreFactory())
else:
pdf = jpdf_ot.getDistributionCollection()[i]
algo = ot.AdaptiveStieltjesAlgorithm(pdf)
poly_collection[i] = ot.StandardDistributionPolynomialFactory(
algo)
# create multivariate basis
mv_basis = ot.OrthogonalProductPolynomialFactory(
poly_collection, ot.EnumerateFunction(N))
# get enumerate function (multi-index handling)
enum_func = mv_basis.getEnumerateFunction()
else:
idx_act = interp_dict['idx_act']
idx_adm = interp_dict['idx_adm']
coeff_act = interp_dict['coeff_act']
coeff_adm = interp_dict['coeff_adm']
fevals_act = interp_dict['fevals_act']
fevals_adm = interp_dict['fevals_adm']
mv_basis = interp_dict['mv_basis']
enum_func = interp_dict['enum_func']
# local error indicators
local_error_indicators = np.abs(coeff_adm)
# compute global error indicator
global_error_indicator = local_error_indicators.sum() # max or sum
# fcalls / M approx. terms up to now
fcalls = len(idx_act) + len(idx_adm) # fcalls = M --> approx. terms
# maximum index per dimension
max_idx_per_dim = np.max(idx_act + idx_adm, axis=0)
# univariate knots and polynomials per dimension
knots_per_dim = {}
for n in range(N):
kk, ww = seq_lj_1d(order=max_idx_per_dim[n], dist=jpdf_cp[n])
knots_per_dim[n] = kk
# start iterations
while global_error_indicator > tol and fcalls < max_fcalls:
if verbose:
print(fcalls)
print(global_error_indicator)
# the index added last to the activated set is the one to be refined
last_act_idx = idx_act[-1][:]
# compute the knot corresponding to the lastly added index
last_knot = [
knots_per_dim[n][i] for n, i in zip(range(N), last_act_idx)
]
# get admissible neighbors of the lastly added index
adm_neighbors = admissible_neighbors(last_act_idx, idx_act)
for an in adm_neighbors:
# update admissible index set
idx_adm.append(an)
# find which parameter/direction n (n=1,2,...,N) gets refined
n_ref = np.argmin(
[idx1 == idx2 for idx1, idx2 in zip(an, last_act_idx)])
# sequence of 1d Leja nodes/weights for the given refinement
knots_n, weights_n = seq_lj_1d(an[n_ref], jpdf_cp[int(n_ref)])
# update max_idx_per_dim, knots_per_dim, if necessary
if an[n_ref] > max_idx_per_dim[n_ref]:
max_idx_per_dim[n_ref] = an[n_ref]
knots_per_dim[n_ref] = knots_n
# find new_knot and compute function on new_knot
new_knot = last_knot[:]
new_knot[n_ref] = knots_n[-1]
feval = func(new_knot)
fevals_adm.append(feval)
fcalls += 1 # update function calls
# create PCE basis
idx_system = idx_act + idx_adm
idx_system_single = transform_multi_index_set(idx_system, enum_func)
system_basis = mv_basis.getSubBasis(idx_system_single)
# get corresponding evaluations
fevals_system = fevals_act + fevals_adm
# multi-dimensional knots
M = len(idx_system) # equations terms
knots_md = [[knots_per_dim[n][idx_system[m][n]] for m in range(M)]
for n in range(N)]
knots_md = np.array(knots_md).T
# design matrix
D = get_design_matrix(system_basis, knots_md)
# solve system of equaations
Q, R = scl.qr(D, mode='economic')
c = Q.T.dot(fevals_system)
coeff_system = scl.solve_triangular(R, c)
# find the multi-index with the largest contribution, add it to idx_act
# and delete it from idx_adm
coeff_act = coeff_system[:len(idx_act)].tolist()
coeff_adm = coeff_system[-len(idx_adm):].tolist()
help_idx = np.argmax(np.abs(coeff_adm))
idx_add = idx_adm.pop(help_idx)
pce_coeff_add = coeff_adm.pop(help_idx)
fevals_add = fevals_adm.pop(help_idx)
idx_act.append(idx_add)
coeff_act.append(pce_coeff_add)
fevals_act.append(fevals_add)
# re-compute coefficients of admissible multi-indices
# local error indicators
local_error_indicators = np.abs(coeff_adm)
# compute global error indicator
global_error_indicator = local_error_indicators.sum() # max or sum
# store expansion data in dictionary
interp_dict = {}
interp_dict['idx_act'] = idx_act
interp_dict['idx_adm'] = idx_adm
interp_dict['coeff_act'] = coeff_act
interp_dict['coeff_adm'] = coeff_adm
interp_dict['fevals_act'] = fevals_act
interp_dict['fevals_adm'] = fevals_adm
interp_dict['enum_func'] = enum_func
interp_dict['mv_basis'] = mv_basis
return interp_dict
graphJacobi_temp = factory.build(i).draw(xMinJacobi, xMaxJacobi,
pointNumber)
graphJacobi_temp_draw = graphJacobi_temp.getDrawable(0)
graphJacobi_temp_draw.setLegend("degree " + str(i))
graphJacobi_temp_draw.setColor(colorList[i])
graphJacobi.add(graphJacobi_temp_draw)
return graphJacobi
# %%
# Draw the 5-th first members of the Jacobi family.
# %%
# Create the Jacobi polynomials family using the default Jacobi.ANALYSIS
# parameter set
alpha = 0.5
beta = 1.5
jacobiFamily = ot.JacobiFactory(alpha, beta)
graph = drawFamily(jacobiFamily)
view = viewer.View(graph)
# %%
laguerreFamily = ot.LaguerreFactory(2.75, 1)
graph = drawFamily(laguerreFamily)
view = viewer.View(graph)
# %%
graph = drawFamily(ot.HermiteFactory())
view = viewer.View(graph)
plt.show()
#! /usr/bin/env python
import openturns as ot
# Polynomial factories
factoryCollection = [ot.LaguerreFactory(
2.5), ot.LegendreFactory(), ot.HermiteFactory()]
dim = len(factoryCollection)
basisFactory = ot.OrthogonalProductPolynomialFactory(factoryCollection)
basis = ot.OrthogonalBasis(basisFactory)
print('basis=', basis)
x = [0.5] * dim
for i in range(10):
f = basis.build(i)
print('i=', i, 'f(X)=', f(x))
# Using multi-indices
enum = basis.getEnumerateFunction()
for i in range(10):
indices = enum(i)
f = basis.build(indices)
print('indices=', indices, 'f(X)=', f(x))
# Other factories
factoryCollection = [ot.OrthogonalUniVariatePolynomialFunctionFactory(
ot.LaguerreFactory(2.5)),
ot.HaarWaveletFactory(), ot.FourierSeriesFactory()]
dim = len(factoryCollection)
basisFactory = ot.OrthogonalProductFunctionFactory(factoryCollection)
basis = ot.OrthogonalBasis(basisFactory)
print('basis=', basis)
# %%
# We could also use the automatic selection of the polynomial which corresponds to the distribution: this is done with the `StandardDistributionPolynomialFactory` class.
# %%
for i in range(inputDimension):
marginal = distribution.getMarginal(i)
polyColl[i] = ot.StandardDistributionPolynomialFactory(marginal)
# %%
# In our specific case, we use specific polynomial factories.
# %%
polyColl[0] = ot.HermiteFactory()
polyColl[1] = ot.LegendreFactory()
polyColl[2] = ot.LaguerreFactory(2.75)
# Parameter for the Jacobi factory : 'Probabilty' encoded with 1
polyColl[3] = ot.JacobiFactory(2.5, 3.5, 1)
# %%
# Create the enumeration function.
# %%
# The first possibility is to use the `LinearEnumerateFunction`.
# %%
enumerateFunction = ot.LinearEnumerateFunction(inputDimension)
# %%
# Another possibility is to use the `HyperbolicAnisotropicEnumerateFunction`, which gives less weight to interactions.
# create orthogonal univariate bases
poly_collection = ot.PolynomialFamilyCollection(N)
for i in range(N):
if dist_types[i] == 'Uniform':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.LegendreFactory())
elif dist_types[i] == 'Normal':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.HermiteFactory())
elif dist_types[i] == 'Beta':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.JacobiFactory())
elif dist_types[i] == 'Gamma':
poly_collection[i] = ot.OrthogonalUniVariatePolynomialFamily(
ot.LaguerreFactory())
else:
pdf = jpdf_ot.getDistributionCollection()[i]
algo = ot.AdaptiveStieltjesAlgorithm(pdf)
poly_collection[i] = ot.StandardDistributionPolynomialFactory(algo)
# create multivariate basis
mv_basis = ot.OrthogonalProductPolynomialFactory(poly_collection,
ot.EnumerateFunction(N))
# get enumerate function (multi-index handling)
enum_func = mv_basis.getEnumerateFunction()
max_fcalls = np.linspace(100, 1000, 10).tolist()
meanz = []
varz = []
cv_errz_rms = []
