def predictor(PCE, x_pred):
"""inputs:
PCE: PCE model, dictionary
x_pred: random inputs to be predicted for
outputs:
y_pred: predition on model response, array
"""
# define array of random inputs on the definition range of polynomial basis
x_prediction = npy.zeros(x_pred.shape)
# PCE basis for 1D random variables
basis = npy.zeros((len(x_pred[:,
0]), PCE['n_deg'] + 1, len(PCE['x_prob'])))
# PCE basis for mD random variables
basis_total = npy.ones(
(len(x_pred), math.factorial(PCE['n_deg'] + len(PCE['x_prob'])) /
math.factorial(PCE['n_deg']) / math.factorial(len(PCE['x_prob']))))
i = 0
for key, value in PCE['x_prob'].iteritems():
# generate Gaussian quadrature weighting factors and points first
[alpha, beta, x_quad,
weight] = algPCE.gen_quad(PCE['n_deg'], key, value)
# convert x_pred to the definition range of polynomial basis
x_prediction[:, i] = algPCE.convert_x_inv(x_pred[:, i], key, value)
# use the obtained weighting factors, points, coefficients to generate basis
[basis[:, :, i],
non] = algPCE.gen_basis(PCE['n_deg'], key, value, alpha, beta,
x_prediction[:, i], weight)
i = i + 1
for i in xrange(0, len(x_pred[:, 0])):
for iters in xrange(
0,
math.factorial(PCE['n_deg'] + len(PCE['x_prob'])) /
math.factorial(PCE['n_deg']) /
math.factorial(len(PCE['x_prob']))):
for j in xrange(0, len(PCE['x_prob'])):
basis_total[i, iters] = basis_total[i, iters] * basis[
i,
int(PCE['trunc_index'][iters * len(PCE['x_prob']) + j]), j]
y_pred = (PCE['PCE_coef'] * npy.transpose(basis_total)).sum(0)
PCE_pred = collections.OrderedDict([('y_pred', y_pred),
('basis_total', basis_total)])
return PCE_pred, y_pred
def collocation(n_deg, x_prob, x_exp, y_exp, meta_type):
"""inputs:
n_deg: required degree of PCE, scalar
x_prob: random-input information, dictionary
x_exp: sample points of random inputs
y_exp: corresponding response of x_exp
meta_type: OLS or LARS, string
outputs:
PCE: key information of generated PCE model, dictionary
"""
# PCE basis, weighting factors, quadrature points, for 1D random variables
weight = npy.zeros((n_deg + 1, len(x_prob)))
x_quad = npy.zeros((n_deg + 1, len(x_prob)))
basis_coef = npy.zeros((len(x_exp), n_deg + 1, len(x_prob)))
# PCE coefficients, PCE basis, in multi-dimensional scale
alpha_total = npy.zeros(
(math.factorial(n_deg + len(x_prob)) / math.factorial(n_deg) /
math.factorial(len(x_prob)), 1))
basis_coef_total = npy.ones(
(len(x_exp), math.factorial(n_deg + len(x_prob)) /
math.factorial(n_deg) / math.factorial(len(x_prob)), 1))
i = 0
for key, value in x_prob.iteritems():
# generate Gaussian quadrature weighting factors and points first
[alpha, beta, x_quad[:, i],
weight[:, i]] = algPCE.gen_quad(n_deg, key, value)
# convert x_exp to the specified range for each polynomial basis
x_exp[:, i] = algPCE.convert_x_inv(x_exp[:, i], key, value)
[basis_coef[:, :, i],
non] = algPCE.gen_basis(n_deg, key, value, alpha, beta, x_exp[:, i],
weight[:, i])
# convert x_exp back to the real range
x_exp[:, i] = algPCE.convert_x(x_exp[:, i], key, value)
i = i + 1
index = npy.array([])
for iters in xrange(0, n_deg + 1):
index = npy.append(index, multiIters.multichoose(len(x_prob), iters))
for i in xrange(0, len(x_exp)):
for iters in xrange(
0,
math.factorial(n_deg + len(x_prob)) / math.factorial(n_deg) /
math.factorial(len(x_prob))):
for j in xrange(0, len(x_prob)):
basis_coef_total[
i, iters, 0] = basis_coef_total[i, iters, 0] * basis_coef[
i, int(index[iters * len(x_prob) + j]), j]
weight_total = multiIters.iter_weights(weight, x_prob, n_deg)
if meta_type == 'OLS':
reg = linear_model.LinearRegression()
reg.__init__(fit_intercept=False,
normalize=True,
copy_X=True,
n_jobs=1)
reg.fit(basis_coef_total[:, :, 0], y_exp)
alpha_total[:, 0] = reg.coef_
coef_index = [
i for i, alpha_value in enumerate(alpha_total)
if npy.abs(alpha_value) > 1e-4
]
elif meta_type == 'LARS':
reg = linear_model.LassoLarsCV()
reg.__init__(fit_intercept=True,
verbose=False,
normalize=True,
copy_X=True,
positive=False,
cv=5)
reg.fit(basis_coef_total[:, :, 0], y_exp)
alpha_total[:, 0] = reg.coef_
alpha_total[0, 0] = reg.intercept_
# this is actually the hybrid lars as mentioned in [Blatman and Sudret, 2011]
# make the last step of LARS as OLS on selected basis (which have nonzero coefficients)
coef_index = [
i for i, alpha_value in enumerate(alpha_total)
if npy.abs(alpha_value) > 1e-4
]
reg_ols = linear_model.LinearRegression()
reg_ols.__init__(fit_intercept=False,
normalize=True,
copy_X=True,
n_jobs=1)
reg_ols.fit(basis_coef_total[:, coef_index, 0], y_exp)
alpha_total[coef_index, 0] = reg_ols.coef_
else:
print 'no such meta_type found'
print 'now exiting!'
sys.exit()
PCE = collections.OrderedDict([
('PCE_coef', alpha_total), ('x_quad', x_quad),
('weight_total', weight_total), ('mean', alpha_total[0]),
('variance', [npy.sum(alpha_total[1:] * alpha_total[1:])]),
('n_deg', n_deg), ('x_prob', x_prob), ('trunc_index', index),
('basis_coef_total', basis_coef_total), ('coef_index', coef_index)
])
return PCE
def quadrature(n_deg, x_prob, full_model):
"""inputs:
n_deg: required degree of PCE, scalar
x_prob: random-variable information, dictionary
full_model: real model for evaluation use, function
outputs:
PCE: key information of generated PCE model, dictionary
"""
# PCE basis, weighting factors, quadrature points, for 1D random variables
weight = npy.zeros((n_deg + 1, len(x_prob)))
x_quad = npy.zeros((n_deg + 1, len(x_prob)))
x_quad_pred = npy.zeros((n_deg + 1, len(x_prob)))
basis = npy.zeros((n_deg + 1, n_deg + 1, len(x_prob)))
integration = npy.zeros((n_deg + 1, n_deg + 1, len(x_prob)))
# PCE coefficients, PCE basis, in multi-dimensional scale
alpha_total = npy.zeros(
(math.factorial(n_deg + len(x_prob)) / math.factorial(n_deg) /
math.factorial(len(x_prob)), 1))
basis_total = npy.ones(
((n_deg + 1)**len(x_prob), math.factorial(n_deg + len(x_prob)) /
math.factorial(n_deg) / math.factorial(len(x_prob)), 1))
integration_total = npy.ones(
((n_deg + 1)**len(x_prob), math.factorial(n_deg + len(x_prob)) /
math.factorial(n_deg) / math.factorial(len(x_prob)), 1))
i = 0
for key, value in x_prob.iteritems():
# generate Gaussian quadrature weighting factors and points first
[alpha, beta, x_quad[:, i],
weight[:, i]] = algPCE.gen_quad(n_deg, key, value)
# use the obtained weighting factors, points, coefficients to generate basis
[basis[:, :, i],
integration[:, :,
i]] = algPCE.gen_basis(n_deg, key, value, alpha, beta,
x_quad[:, i], weight[:, i])
# first save the x_quad for prediction use
x_quad_pred[:, i] = x_quad[:, i]
# then convert x_quad to the real range for real model
x_quad[:, i] = algPCE.convert_x(x_quad[:, i], key, value)
i = i + 1
index = npy.array([])
for iters in xrange(0, n_deg + 1):
index = npy.append(index, multiIters.multichoose(len(x_prob), iters))
for iters in xrange(0, len(index) / len(x_prob)):
index_cal = index[iters * len(x_prob):(iters + 1) * len(x_prob)]
basis_total[:, iters,
0] = multiIters.iter_basis(basis, x_prob, n_deg, index_cal)
integration_total[:, iters,
0] = multiIters.iter_basis(integration, x_prob,
n_deg, index_cal)
weight_total = multiIters.iter_weights(weight, x_prob, n_deg)
x_cal = multiIters.iter_x(x_quad, x_prob, n_deg)
y_real = full_model(x_cal)
alpha_total[:, 0] = npy.matmul(weight_total * y_real, basis_total[:, :, 0])
PCE = collections.OrderedDict([
('PCE_coef', alpha_total), ('x_quad', x_quad_pred),
('weight_total', weight_total), ('mean', alpha_total[0]),
('variance', [npy.sum(alpha_total[1:] * alpha_total[1:])]),
('n_deg', n_deg), ('x_prob', x_prob), ('trunc_index', index)
])
return PCE