def ExpandBank():
hep = HEPBankReducedSmooth
t = np.linspace(0, 350, 3500)
t1 = cp.Uniform(0, 150)
t2 = cp.Uniform(100, 260)
t1 = cp.Normal(70, 1)
t2 = cp.Normal(115, 1)
pdf = cp.J(t1, t2)
polynomials = cp.orth_ttr(order=2, dist=pdf) #No good for dependent
# polynomials = cp.orth_bert(N=2,dist=pdf)
# polynomials = cp.orth_gs(order=2,dist=pdf)
# polynomials = cp.orth_chol(order=2,dist=pdf)
if 1:
nodes, weights = cp.generate_quadrature(order=2,
domain=pdf,
rule="Gaussian")
# nodes, weights = cp.generate_quadrature(order=2, domain=pdf, rule="C")
# nodes, weights = cp.generate_quadrature(order=9, domain=pdf, rule="L")
print nodes.shape
samples = np.array([hep(t, *node) for node in nodes.T])
hepPCE = cp.fit_quadrature(polynomials, nodes, weights, samples)
else:
nodes = pdf.sample(10, 'S')
samples = np.array([hep(t, *node) for node in nodes.T])
hepPCE = cp.fit_regression(polynomials, nodes, samples, rule='T')
return hepPCE
def multi_fidelity_update(self, y, radius, high_fidelity):
new_points = super().multi_fidelity_update(y, radius, high_fidelity)
new_evals = [
high_fidelity.eval(z_) - self.eval(z_) for z_ in new_points.T
]
new_poly = cpy.fit_regression(self.expansion, new_points, new_evals)
self.proxy = self.proxy + new_poly
def KG(z, evls, pnts, gp, kernel, NSAMPS=30, DEG=3, sampling=False):
# Find initial minimum value from GP model
min_val = 1e100
X_sample = pnts
Y_sample = evls
#for x0 in [np.random.uniform(XL, XU, size=DIM) for oo in range(20)]:
x0 = np.random.uniform(XL, XU, size=DIM)
res = mini(gp, x0=x0,
bounds=[(XL, XU)
for ss in range(DIM)]) #, method='Nelder-Mead')
#res = mini(expected_improvement, x0=x0[0], bounds=[(XL, XU) for ss in range(DIM)], args=(X_sample, Y_sample, gp))#, callback=callb)
# if res.fun < min_val:
min_val = res.fun
min_x = res.x
# estimate min(f^{n+1}) with MC simulation
MEAN = 0
points = np.atleast_2d(np.append(X_sample, z)).T
m, s = gp(z, return_std=True)
distribution = cp.J(cp.Normal(0, s))
samples = distribution.sample(NSAMPS, rule='Halton')
PCEevals = []
for pp in range(NSAMPS):
# construct future GP, using z as the next point
evals = np.append(evls, m + samples[pp])
#evals = np.append(evls, m + np.random.normal(0, s))
gpnxt = GaussianProcessRegressor(kernel=kernel,
n_restarts_optimizer=35,
random_state=98765,
normalize_y=True)
gpnxt.fit(points, evals)
# convinience function
def gpf_next(x, return_std=False):
alph, astd = gpnxt.predict(np.atleast_2d(x), return_std=True)
alph = alph[0]
if return_std:
return (alph, astd)
else:
return alph
res = mini(gpf_next, x0=x0, bounds=[(XL, XU) for ss in range(DIM)])
min_next_val = res.fun
min_next_x = res.x
#print('+++++++++ ', res.fun)
#MEAN += min_next_val
PCEevals.append(min_next_val)
if not sampling:
polynomial_expansion = cp.orth_ttr(DEG, distribution)
foo_approx = cp.fit_regression(polynomial_expansion, samples, PCEevals)
MEAN = cp.E(foo_approx, distribution)
else:
MEAN = np.mean(PCEevals)
#print(PCEevals, '...', MEAN)
#hey
#MEAN /= NSAMPS
return min_val - MEAN
def polynomial_chaos_sens(Ns_pc,
jpdf,
polynomial_order,
poly=None,
return_reg=False):
N_terms = int(len(jpdf) / 2)
# 1. generate orthogonal polynomials
poly = poly or cp.orth_ttr(polynomial_order, jpdf)
# 2. generate samples with random sampling
samples_pc = jpdf.sample(size=Ns_pc, rule='R')
# 3. evaluate the model, to do so transpose samples and hash input data
transposed_samples = samples_pc.transpose()
samples_z = transposed_samples[:, :N_terms]
samples_w = transposed_samples[:, N_terms:]
model_evaluations = linear_model(samples_w, samples_z)
# 4. calculate generalized polynomial chaos expression
gpce_regression = cp.fit_regression(poly, samples_pc, model_evaluations)
# 5. get sensitivity indices
Spc = cp.Sens_m(gpce_regression, jpdf)
Stpc = cp.Sens_t(gpce_regression, jpdf)
if return_reg:
return Spc, Stpc, gpce_regression
else:
return Spc, Stpc
def EHI(x,
gp1,
gp2,
xi=0.,
x2=None,
MD=None,
NSAMPS=200,
PCE=False,
ORDER=2,
PAR_RES=100):
mu1, std1 = gp1(x, return_std=True)
mu2, std2 = gp2(x, return_std=True)
a, b, c = parEI(gp1, gp2, x2, '', EI=False, MD=MD, PAR_RES=PAR_RES)
par = b.T[c, :]
par += xi
MEAN = 0 # running sum for observed hypervolume improvement
if not PCE: # Monte Carlo Sampling
for ii in range(NSAMPS):
# add new point to Pareto Front
evl = [np.random.normal(mu1, std1), np.random.normal(mu2, std2)]
pears = np.append(par.T, evl, 1).T
idx = is_pareto_efficient_simple(pears)
newPar = pears[idx, :]
# check if Pareto front improvemed from this point
if idx[-1]:
MEAN += H(newPar) - H(par)
return (MEAN / NSAMPS)
else:
# Polynomial Chaos
# (assumes 2 objective functions)
distribution = cp.J(cp.Normal(0, std1), cp.Normal(0, std2))
# sparse grid samples
samples = distribution.sample(NSAMPS, rule='Halton')
PCEevals = []
for pp in range(NSAMPS):
# add new point to Pareto Front
evl = [np.random.normal(mu1, std1), np.random.normal(mu2, std2)]
pears = np.append(par.T, evl, 1).T
idx = is_pareto_efficient_simple(pears)
newPar = pears[idx, :]
# check if Pareto front improvemes
if idx[-1]:
PCEevals.append(H(newPar) - H(par))
else:
PCEevals.append(0)
polynomial_expansion = cp.orth_ttr(ORDER, distribution)
foo_approx = cp.fit_regression(polynomial_expansion, samples, PCEevals)
MEAN = cp.E(foo_approx, distribution)
return (MEAN)
def test_regression():
dist = cp.Iid(cp.Normal(), dim)
orth, norms = cp.orth_ttr(order, dist, retall=1)
data = dist.sample(samples)
vals = np.zeros((samples, size))
cp.fit_regression(orth, data, vals, "LS")
cp.fit_regression(orth, data, vals, "T", order=0)
cp.fit_regression(orth, data, vals, "TC", order=0)
def __init__(self,
dimension=None,
input=None,
output=None,
order=None):
self.dimension = dimension
self.input = np.transpose(input)
self.output = output
self.order = order
self.distribution = cp.Iid(cp.Uniform(0, 1), self.dimension)
orthogonal_expansion = cp.orth_ttr(self.order, self.distribution)
self.poly = cp.fit_regression(orthogonal_expansion, self.input,
self.output)
def test_circuit_model_order_2(self, order_cp: int = 2, bool_plot: bool = False):
dim = 6
key = ["R_b1", "R_b2", "R_f", "R_c1", "R_c2", "beta"]
sobol_indices_quad_constantine = np.array(
[5.0014515064e-01, 4.1167859899e-01, 7.4006053045e-02, 2.1802568214e-02, 5.1736552010e-08,
1.4938996627e-05])
M_constantine = np.array([50, 1e2, 5e2, 1e3, 5e3, 1e4, 5e4])
sobol_indices_error_constantine = np.transpose(np.array(
[[6.1114622870e-01, 2.7036543475e-01, 1.5466638009e-01, 1.2812367577e-01, 5.0229955234e-02,
3.5420048253e-02, 1.4486328386e-02],
[6.0074404490e-01, 3.2024096457e-01, 1.2296426366e-01, 9.6725945246e-02, 5.3143328175e-02,
3.2748864016e-02, 1.1486316472e-02],
[1.1789694228e-01, 4.6150927239e-02, 2.6268692965e-02, 1.8450563871e-02, 8.3656592318e-03,
5.8550974309e-03, 2.8208921925e-03],
[3.8013619286e-02, 1.6186288112e-02, 8.9893920304e-03, 6.3911249578e-03, 2.6219049423e-03,
1.9215077698e-03, 9.5390224479e-04],
[1.2340746448e-07, 4.8204289233e-08, 3.0780845307e-08, 2.5240466147e-08, 1.0551377101e-08,
6.9506139894e-09, 3.3372151408e-09],
[3.4241277775e-05, 1.8074628532e-05, 7.1554659714e-06, 5.0303467614e-06, 2.7593313990e-06,
1.9529470403e-06, 7.2840043686e-07]]))
x_lower = np.array([50, 25, 0.5, 1.2, 0.25, 50]) # table 3, constantine-2017
x_upper = np.array([150, 70, 3.0, 2.5, 1.2, 300]) # table 3, constantine-2017
circuit_model = CircuitModel()
n_samples = M_constantine
iN_vec = n_samples.astype(int) # 8 if calc_second_order = False, else 14
no_runs = np.zeros(len(iN_vec))
indices = np.zeros(shape=(len(iN_vec), dim))
indices_error = np.zeros(shape=(len(iN_vec), dim))
idx = 0
n_trials = 1
no_runs_averaged = 1
dist = cp.J(cp.Uniform(x_lower[0], x_upper[0]), cp.Uniform(x_lower[1], x_upper[1]),
cp.Uniform(x_lower[2], x_upper[2]), cp.Uniform(x_lower[3], x_upper[3]),
cp.Uniform(x_lower[4], x_upper[4]), cp.Uniform(x_lower[5], x_upper[5]))
for iN in iN_vec:
tmp_indices_error_av = np.zeros(dim)
for i_trial in range(0, n_trials):
seed = int(np.random.rand(1) * 2 ** 32 - 1)
random_state = RandomState(seed)
# https://github.com/jonathf/chaospy/issues/81
dist_samples = dist.sample(iN) # random samples or abscissas of polynomials ?
values_f, _, _ = circuit_model.eval_model_averaged(dist_samples, no_runs_averaged,
random_state=random_state)
# Approximation with Chaospy
poly = cp.orth_ttr(order_cp, dist)
approx_model = cp.fit_regression(poly, dist_samples, values_f)
tmp_indices_total = cp.Sens_t(approx_model, dist)
tmp_error = relative_error_constantine_2017(tmp_indices_total, sobol_indices_quad_constantine)
tmp_indices_error_av = tmp_indices_error_av + tmp_error
print(iN)
indices_error[idx, :] = tmp_indices_error_av / n_trials
indices[idx, :] = tmp_indices_total
no_runs[idx] = iN
idx = idx + 1
if bool_plot:
col = np.array(
[[0, 0.4470, 0.7410], [0.8500, 0.3250, 0.0980], [0.9290, 0.6940, 0.1250], [0.4940, 0.1840, 0.5560],
[0.4660, 0.6740, 0.1880], [0.3010, 0.7450, 0.9330]])
plt.figure()
for i in range(0, dim):
plt.semilogx(no_runs, indices[:, i], '.--', label='%s (SALib)' % key[i], color=col[i, :])
plt.semilogx([no_runs[0], max(no_runs)], sobol_indices_quad_constantine[i] * np.ones(2), 'k:',
label='Reference values', color=col[i, :])
plt.xlabel('Number of samples')
plt.ylabel('Sobol\' total indices')
plt.legend()
plt.figure()
for i in range(0, dim):
plt.loglog(no_runs, indices_error[:, i], '.--', label=key[i]+'(PC Approximation)', color=col[i, :])
plt.loglog(M_constantine, sobol_indices_error_constantine[:, i], '.k:', color=col[i, :])
plt.xlabel('Number of samples')
plt.ylabel('Relative error (Sobol\' total indices)')
plt.grid(True, 'minor', 'both')
plt.legend()
plt.show()
# assure that it ran
assert(True, True)
def u(x, a, I):
return I * np.exp(-a * x)
dist_R = cp.J(cp.Normal(), cp.Normal())
C = [[1, 0.5], [0.5, 1]]
mu = [0, 0]
dist_Q = cp.MvNormal(mu, C)
P = cp.orth_ttr(2, dist_R)
nodes_R = dist_R.sample(2 * len(P), "M")
nodes_Q = dist_Q.inv(dist_R.fwd(nodes_R))
x = np.linspace(0, 1, 100)
samples_u = [u(x, *node) for node in nodes_Q.T]
u_hat = cp.fit_regression(P, nodes_R, samples_u)
#Rosenblat transformation using pseudo spectral
def u(x, a, I):
return I * np.exp(-a * x)
C = [[1, 0.5], [0.5, 1]]
mu = np.array([0, 0])
dist_R = cp.J(cp.Normal(), cp.Normal())
dist_Q = cp.MvNormal(mu, C)
P = cp.orth_ttr(2, dist_R)
nodes_R, weights_R = cp.generate_quadrature(3, dist_R)
print("\n Uncertainty measures (averaged)\n")
print('\n E(Y) | Std(Y) \n')
plt.figure('mean')
for model, name, color in [
(quadratic_area_model, 'Quadratic model', '#dd3c30'),
(logarithmic_area_model, 'Logarithmic model', '#2775b5')
]:
sample_scheme = 'R'
# create samples
samples = jpdf.sample(Ns, sample_scheme)
# create orthogonal polynomials
orthogonal_polynomials = cp.orth_ttr(polynomial_order, jpdf)
# evaluate the model for all samples
Y_area = model(pressure_range, samples)
# polynomial chaos expansion
polynomial_expansion = cp.fit_regression(orthogonal_polynomials, samples,
Y_area.T)
# calculate statistics
plotMeanConfidenceAlpha = 5
expected_value = cp.E(polynomial_expansion, jpdf)
variance = cp.Var(polynomial_expansion, jpdf)
standard_deviation = cp.Std(polynomial_expansion, jpdf)
prediction_interval = cp.Perc(
polynomial_expansion,
[plotMeanConfidenceAlpha / 2., 100 - plotMeanConfidenceAlpha / 2.],
jpdf)
print('{:2.5f} | {:2.5f} : {}'.format(
np.mean(expected_value) * unit_m2_cm2,
np.mean(std) * unit_m2_cm2, name))
# compute sensitivity indices
def test_regression():
dist = cp.Iid(cp.Normal(), dim)
orth, norms = cp.expansion.stieltjes(order, dist, retall=1)
data = dist.sample(samples)
vals = np.zeros((samples, size))
cp.fit_regression(orth, data, vals)
def linear_model(request, expansion_small, samples, evaluations):
return chaospy.fit_regression(expansion_small,
samples,
evaluations,
model=LINEAR_MODELS[request.param])
def check_convergence(samples,
data,
joint_dist,
max_order,
norm_ord=None,
ref_values=None,
zero_offset=0.0):
"""
Args:
samples := (first axis must be along sample index not input index)
model_evals :=
norm_ord := any of the orders of norms supported by numpy.linalg.norm
ref_values(dict) := a dictionary of reference values to compare each case
max_order(int) :=
Calculate and display convergence of error with respect to the mean, and random check values.
1. Determine "maximum/reference" order
2. calculate reference values for E, var, Sm, St
3. For each order calculate the error wrt to the reference value for all possible sample factors
3.a. The results will be stored in a dict like
{measure:
{order:
[[sample_sizes],
[error_value]]
}
}
4. Once complete plot the convergence of each measure
fig_idxs = {measure:idx for idx,measure in enumerate(errors_dict.keys())}
for measure, value in errors_dict.iteritems():
plt.figure(fig_idxs[measure])
for order,data in value.iteritems():
plt.plot(value[
"""
orders = range(1, max_order)
measures = ["mean", "var"]
n_pts_per_order = 10
if len(data.shape) > 1:
model_dim = data.shape[-1] #TODO this is only valid for 1D arrays
else:
model_dim = 1
error_dim = 3
input_dim = len(joint_dist)
error_dict = {
measure:
{order: np.zeros((error_dim, n_pts_per_order))
for order in orders}
for measure in measures
}
submeasures = ["sens_m", "sens_t"]
suberror_dict = {
submeasure: {
par: {
order: np.zeros((error_dim, n_pts_per_order))
for order in orders
}
for par in range(input_dim)
}
for submeasure in submeasures
}
residual_error_dict = {
idx:
{order: np.zeros((error_dim, n_pts_per_order))
for order in orders}
for idx in range(model_dim)
}
raw_sensitivities = {
submeasure: {
par: {
order: np.zeros((2, n_pts_per_order, *data.shape[1::]))
for order in orders
}
for par in range(input_dim)
}
for submeasure in submeasures
}
raw_measures = {
measure: {
order: np.zeros((2, n_pts_per_order) + data.shape[1::])
for order in orders
}
for measure in measures
}
if ref_values is None:
#Calculate reference values
orthoPoly = cp.orth_ttr(max_order, joint_dist)
expansion_polynomial = cp.fit_regression(orthoPoly,
samples.transpose(), data)
ref_values = calculate_uqsa_measures(joint_dist, expansion_polynomial)
# Monte Carlo Estimates
ref_values["mean"] = np.mean(data, axis=0)
ref_values["var"] = np.var(data, axis=0)
for order in orders:
dim = input_dim
ncoefs = cp.bertran.terms(order, dim)
sample_sizes = np.linspace(ncoefs,
samples.shape[0],
n_pts_per_order,
dtype="int")
orthoPoly = cp.orth_ttr(order, joint_dist)
for idx, sample_size in enumerate(sample_sizes):
expansion_polynomial = cp.fit_regression(
orthoPoly, samples[0:sample_size].transpose(),
data[0:sample_size])
uqsa_data = calculate_uqsa_measures(joint_dist,
expansion_polynomial)
uhat = np.array(
[expansion_polynomial(*sample) for sample in samples])
err = np.abs(uhat - data)
rel_err = err / data
if len(err.shape) == 1:
err.shape = (err.shape[0], 1)
rel_err.shape = (rel_err.shape[0], 1)
abs_err_norm = np.array(
[np.linalg.norm(ui) / len(ui) for ui in err.T])
rel_err_norm = np.array(
[np.linalg.norm(ui) / len(ui) for ui in rel_err.T])
for uidx, err_val in enumerate(rel_err_norm):
residual_error_dict[uidx][order][
0] = sample_sizes #np.tile(sample_sizes, rel_err_norm.shape + (1,)).T
residual_error_dict[uidx][order][1, idx] = err_val
residual_error_dict[uidx][order][2, idx] = abs_err_norm[uidx]
for measure in measures:
raw_measures[measure][order][0] = np.tile(
sample_sizes, uqsa_data[measure].shape + (1, )).T
err = np.abs(uqsa_data[measure] - ref_values[measure])
u = err / ref_values[measure] #TODO what if zero ref measure
raw_measures[measure][order][1, idx] = u #data[measure]
rel_err = np.linalg.norm(u.flat, ord=norm_ord) / len(u.flat)
abs_err = np.linalg.norm(
err.flat, ord=norm_ord
) #THIS DOESN'T MAKE ANY SENSE (averaging unnormalized absolute errors)
# Store measures in dict position idx
error_dict[measure][order][0] = sample_sizes
error_dict[measure][order][1, idx] = rel_err
error_dict[measure][order][2, idx] = abs_err
for submeasure in submeasures:
for par, value in suberror_dict[submeasure].items():
par_idx = int(par)
raw_sensitivities[submeasure][par][order][0] = np.tile(
sample_sizes,
uqsa_data[submeasure][par_idx].shape + (1, )).T
err = np.abs(uqsa_data[submeasure][par_idx] -
ref_values[submeasure][par_idx])
u = err / (np.abs(ref_values[submeasure][par_idx]) +
zero_offset) #TODO what if zero ref measure
raw_sensitivities[submeasure][par][order][
1, idx] = uqsa_data[submeasure][par_idx]
rel_err = np.linalg.norm(u.flat, ord=norm_ord)
abs_err = np.linalg.norm(err.flat, ord=norm_ord)
# Store measures in dict position idx
value[order][0] = sample_sizes
value[order][1, idx] = rel_err
value[order][2, idx] = abs_err
error_dict.update(suberror_dict)
error_dict["res_err"] = residual_error_dict
return error_dict, raw_measures, raw_sensitivities
dataPoints[k] = ws[idx]
samples_u[k] = u[idx]
for j in range(0,SimLength):
dist = cp.Normal(np.mean(WindSpeed_all[:,j]),np.std(WindSpeed_all[:,j]))
orthPoly = cp.orth_ttr(polyOrder, dist)
dataPoints_initial = dist.sample(NoOfSamples[i],rule='L')
dataPoints = np.zeros(NoOfSamples[i])
samples_u = np.zeros(NoOfSamples[i])
#idx = nNoOfSamplesp.zeros(NoOfSamples[i])
u = Gamma_all[:,j]
ws= WindSpeed_all[:,j]
for k in range(0,NoOfSamples[i]):
idx= (np.abs(ws - dataPoints_initial[k])).argmin()
dataPoints[k] = ws[idx]
samples_u[k] = u[idx]
approx = cp.fit_regression(orthPoly, dataPoints, samples_u)
GammaMeanPCE[i,j] = cp.E(approx, dist)
GammaStdPCE[i,j] = cp.Std(approx, dist)
print(i,j)
#%%
timestr = time.strftime("%Y%m%d")
f = open(timestr+'_GammaMean.pckl', 'wb')
pickle.dump(GammaMean, f)
f.close()
f = open(timestr+'_GammaStd.pckl', 'wb')
pickle.dump(GammaStd, f)
f.close()
def u(x,a, I):
return I*np.exp(-a*x)
dist_R = cp.J(cp.Normal(), cp.Normal())
C = [[1, 0.5], [0.5, 1]]
mu = [0, 0]
dist_Q = cp.MvNormal(mu, C)
P = cp.orth_ttr(2, dist_R)
nodes_R = dist_R.sample(2*len(P), "M")
nodes_Q = dist_Q.inv(dist_R.fwd(nodes_R))
x = np.linspace(0, 1, 100)
samples_u = [u(x, *node) for node in nodes_Q.T]
u_hat = cp.fit_regression(P, nodes_R, samples_u)
#Rosenblat transformation using pseudo spectral
def u(x,a, I):
return I*np.exp(-a*x)
C = [[1,0.5],[0.5,1]]
mu = np.array([0, 0])
dist_R = cp.J(cp.Normal(), cp.Normal())
dist_Q = cp.MvNormal(mu, C)
P = cp.orth_ttr(2, dist_R)
#Net.Control_Input('Trials/StochasticDemandsPWGInput.csv')
Net.Control_Input(Directory+'Demands.csv')
Net.MOC_Run(10)
Output[:,i] = Net.nodes[1].TranH
#Net.MOC_Run(86350)
#Net.geom_Plot(plot_Node_Names = True)
#Net.transient_Node_Plot(['6','10','13','16','21','24','31'])
#Net.transient_Node_Plot(['1','2','3','4','5','6'])
#for Node in Net.nodes:
# np.save(Directory +'MeasureData'+str(Node.Name)+'.npy',Node.TranH)
#for Node in Net.nodes:
# pp.scatter([int(Node.Name)], [np.mean(Node.TranH)])
#PE = np.zeros(9999)#999)
#KE = np.zeros(9999)
#for pipe in Net.pipes:
# PE += np.array(pipe.PE)
# KE += np.array(pipe.KE)
polynomial_expansion = cp.orth_ttr(1, distribution)
foo_approx = cp.fit_regression(polynomial_expansion, samples[:10], Output[:,:10].T)
expected = cp.E(foo_approx, distribution)
deviation = cp.Std(foo_approx, distribution)
x,y = normal_dist(expected[-1],deviation[-1]**2)
P, norms = cp.orth_ttr(order, dist, retall=True) nodes, weights = cp.generate_quadrature(order+1, dist, rule="G") solves = [u(x, s[0], s[1]) for s in nodes.T] U_hat = cp.fit_quadrature(P, nodes, weights, solves, norms=norms) mean = cp.E(U_hat, dist) var = cp.Var(U_hat, dist) ## Polynomial chaos expansion ## using Point collocation method and quasi-random samples order = 5 P = cp.orth_ttr(order, dist) nodes = dist.sample(2*len(P), "M") solves = [u(x, s[0], s[1]) for s in nodes.T] U_hat = cp.fit_regression(P, nodes, solves, rule="T") mean = cp.E(U_hat, dist) var = cp.Var(U_hat, dist) ## Polynomial chaos expansion ## using Intrusive Gallerkin method # :math: # u' = -a*u # d/dx sum(c*P) = -a*sum(c*P) # <d/dx sum(c*P),P[k]> = <-a*sum(c*P), P[k]> # d/dx c[k]*<P[k],P[k]> = -sum(c*<a*P,P[k]>) # d/dx c = -E( outer(a*P,P) ) / E( P*P ) # # u(0) = I
Var1 = cp.Var(U_hat, dist)
print('Polynome de chaos utilisant la methode Pseudo-Spectrale')
print('et une quadrature Gaussienne :')
print('E : ',E1)
print('Var : ',Var1)
u_up1=E1+np.sqrt(Var1)
u_dw1=E1-np.sqrt(Var1)
# polynome de chaos
# utilisant la methode "Point Collocation" et des tirages pseudo aleatoires
ordre = 5
P = cp.orth_ttr(ordre, dist)
nodes = dist.sample(2*len(P), "M")
solves = [u(t, s[0], s[1]) for s in nodes.T]
U_hat = cp.fit_regression(P, nodes, solves, rule="T")
E2= cp.E(U_hat, dist)
Var2 = cp.Var(U_hat, dist)
print(' ')
print('Polynome de chaos utilisant la methode "Point Collocation"')
print('et des tirages pseudo aleatoires :')
print('E : ',E2)
print('Var : ',Var2)
#plot
fig, ax = plt.subplots(1)
rcParams['xtick.labelsize'] = 14
rcParams['ytick.labelsize'] = 14
rcParams['font.size']= 16
xlabel('t (s)', fontsize=14)
stateTensor = pool.map(Simulate,samples.T)
savemat(saveDir+'MC',{'states':stateTensor, 'samples':samples})
else: # Polynomial Chaos Expansion !!!!
if args.type == 'qmc':
#Quasi MonteCarlo with 1/4 number of MC samples and PCE built from it
samples = pdf.sample(n,'S')
stateTensor = pool.map(Simulate,samples.T)
if not args.no_save:
savemat(saveDir+'SobolMC',{'states':stateTensor, 'samples':samples})
# data = loadmat('./data/SobolMC')
# samples = data['samples']
# stateTensor = data['states']
polynomials = cp.orth_ttr(order=2, dist=pdf)
PCE = cp.fit_regression(polynomials, samples, stateTensor)
elif args.type == 'pce':
#Quadrature based PCE
polynomials = cp.orth_ttr(order=2, dist=pdf)
samples,weights = cp.generate_quadrature(order=2, domain=pdf, rule="Gaussian")
stateTensor = pool.map(Simulate,samples.T)
PCE = cp.fit_quadrature(polynomials,samples,weights,stateTensor)
data = loadmat(saveDir+'MC') #Load the MC samples for an apples-to-apples comparison
pceTestPoints = data['samples']
stateTensorPCE = np.array([PCE(*point) for point in pceTestPoints.T])
Expectation = cp.E(poly=PCE,dist=pdf)
if not args.no_save:
savemat(saveDir+'PCE2',{'states':stateTensorPCE, 'samples':pceTestPoints,'mean':Expectation})
# savemat('./data/PCE2',{'states':stateTensorPCE[:,:,:,0], 'samples':pceTestPoints,'mean':Expectation})
def plot_figures():
"""Plot figures for tutorial."""
numpy.random.seed(1000)
def foo(coord, param):
return param[0] * numpy.e**(-param[1] * coord)
coord = numpy.linspace(0, 10, 200)
distribution = cp.J(cp.Uniform(1, 2), cp.Uniform(0.1, 0.2))
samples = distribution.sample(50)
evals = numpy.array([foo(coord, sample) for sample in samples.T])
plt.plot(coord, evals.T, "k-", lw=3, alpha=0.2)
plt.xlabel(r"\verb;coord;")
plt.ylabel(r"function evaluations \verb;foo;")
plt.savefig("demonstration.png")
plt.clf()
samples = distribution.sample(1000, "H")
evals = [foo(coord, sample) for sample in samples.T]
expected = numpy.mean(evals, 0)
deviation = numpy.std(evals, 0)
plt.fill_between(coord,
expected - deviation,
expected + deviation,
color="k",
alpha=0.3)
plt.plot(coord, expected, "k--", lw=3)
plt.xlabel(r"\verb;coord;")
plt.ylabel(r"function evaluations \verb;foo;")
plt.title("Results using Monte Carlo simulation")
plt.savefig("results_montecarlo.png")
plt.clf()
polynomial_expansion = cp.orth_ttr(8, distribution)
foo_approx = cp.fit_regression(polynomial_expansion, samples, evals)
expected = cp.E(foo_approx, distribution)
deviation = cp.Std(foo_approx, distribution)
plt.fill_between(coord,
expected - deviation,
expected + deviation,
color="k",
alpha=0.3)
plt.plot(coord, expected, "k--", lw=3)
plt.xlabel(r"\verb;coord;")
plt.ylabel(r"function evaluations \verb;foo;")
plt.title("Results using point collocation method")
plt.savefig("results_collocation.png")
plt.clf()
absissas, weights = cp.generate_quadrature(8, distribution, "C")
evals = [foo(coord, val) for val in absissas.T]
foo_approx = cp.fit_quadrature(polynomial_expansion, absissas, weights,
evals)
expected = cp.E(foo_approx, distribution)
deviation = cp.Std(foo_approx, distribution)
plt.fill_between(coord,
expected - deviation,
expected + deviation,
color="k",
alpha=0.3)
plt.plot(coord, expected, "k--", lw=3)
plt.xlabel(r"\verb;coord;")
plt.ylabel(r"function evaluations \verb;foo;")
plt.title("Results using psuedo-spectral projection method")
plt.savefig("results_spectral.png")
plt.clf()
# calculate sensitivity indices
A_s, B_s, C_s, f_A, f_B, f_C, S_mc, ST_mc = mc_sensitivity_linear(Ns_mc, jpdf, w)
Sensitivities=np.column_stack((S_mc,s**2))
row_labels= ['S_'+str(idx) for idx in range(1,Nrv+1)]
print("First Order Indices")
print(pd.DataFrame(Sensitivities,columns=['Smc','Sa'],index=row_labels).round(3))
# end Monte Carlo
# Polychaos computations
Ns_pc = 80
samples_pc = jpdf.sample(Ns_pc)
polynomial_order = 4
poly = cp.orth_ttr(polynomial_order, jpdf)
Y_pc = linear_model(w, samples_pc.T)
approx = cp.fit_regression(poly, samples_pc, Y_pc, rule="T")
exp_pc = cp.E(approx, jpdf)
std_pc = cp.Std(approx, jpdf)
print("Statistics polynomial chaos\n")
print('\n E(Y) | std(Y) \n')
print('pc : {:2.5f} | {:2.5f}'.format(float(exp_pc), std_pc))
S_pc = cp.Sens_m(approx, jpdf)
Sensitivities=np.column_stack((S_mc,S_pc, s**2))
print("\nFirst Order Indices")
print(pd.DataFrame(Sensitivities,columns=['Smc','Spc','Sa'],index=row_labels).round(3))
# print("\nRelative errors")
import chaospy
import chaospy as cp
import pandas as pd
import numpy as np
QUAD_ORDER = 18
quad = False
def f(x, y):
return (1 - x)**2 * 10 * (y - x**2)**2
distribution = chaospy.J(chaospy.Normal(0, 1), chaospy.Normal(0, 1))
if quad:
polynomial_expansion = cp.orth_ttr(QUAD_ORDER, distribution)
X, W = chaospy.generate_quadrature(QUAD_ORDER, distribution, rule="G")
evals = [f(x[0], x[1]) for x in X.T]
foo_approx = cp.fit_quadrature(polynomial_expansion, X, W, evals)
else:
dat = pd.read_csv('./dakota_tabular.dat', sep=r'\s+')
polynomial_expansion = cp.orth_ttr(QUAD_ORDER, distribution)
samples = np.array([dat.x1, dat.x2])
evals = dat.response_fn_1
foo_approx = cp.fit_regression(polynomial_expansion, samples, evals)
total = chaospy.descriptives.sensitivity.total.Sens_t(foo_approx, distribution)
main = chaospy.descriptives.sensitivity.main.Sens_m(foo_approx, distribution)
def gpc(dists, distsMeta, wallModel, order, hdf5group, sampleScheme='M'):
print "\n GeneralizedPolynomialChaos - order {}\n".format(order)
dim = len(dists)
expansionOrder = order
numberOfSamples = 4 * cp.terms(expansionOrder, dim)
# Sample in independent space
samples = dists.sample(numberOfSamples, sampleScheme).transpose()
model = wallModel(distsMeta)
# Evaluate the model (which is not linear obviously)
pool = multiprocessing.Pool()
data = pool.map(model, samples)
pool.close()
pool.join()
C_data = [retval[0] for retval in data]
a_data = [retval[1] for retval in data]
C_data = np.array(C_data)
a_data = np.array(a_data)
# Orthogonal C_polynomial from marginals
orthoPoly = cp.orth_ttr(expansionOrder, dists)
for data, outputName in zip([C_data, a_data], ['Compliance', 'Area']):
# Fit the model together in independent space
C_polynomial = cp.fit_regression(orthoPoly, samples.transpose(), data)
# save data to dictionary
plotMeanConfidenceAlpha = 5
C_mean = cp.E(C_polynomial, dists)
C_std = cp.Std(C_polynomial, dists)
Si = cp.Sens_m(C_polynomial, dists)
STi = cp.Sens_t(C_polynomial, dists)
C_conf = cp.Perc(
C_polynomial,
[plotMeanConfidenceAlpha / 2., 100 - plotMeanConfidenceAlpha / 2.],
dists)
a = np.linspace(0, 100, 1000)
da = a[1] - a[0]
C_cdf = cp.Perc(C_polynomial, a, dists)
C_pdf = da / (C_cdf[1::] - C_cdf[0:-1])
# Resample to generate full histogram
samples2 = dists.sample(numberOfSamples * 100, sampleScheme)
C_data2 = C_polynomial(*samples2).transpose()
# save in hdf5 file
solutionDataGroup = hdf5group.create_group(outputName)
solutionData = {
'mean': C_mean,
'std': C_std,
'confInt': C_conf,
'Si': Si,
'STi': STi,
'cDataGPC': C_data,
'samplesGPC': samples,
'cData': C_data2,
'samples': samples2.transpose(),
'C_pdf': C_pdf
}
for variableName, variableValue in solutionData.iteritems():
solutionDataGroup.create_dataset(variableName, data=variableValue)
def collocation_model(expansion_small, samples_small, evaluations_small):
return chaospy.fit_regression(expansion_small, samples_small,
evaluations_small)
def analyse(self, data_frame=None):
"""Perform PCE analysis on input `data_frame`.
Parameters
----------
data_frame : pandas DataFrame
Input data for analysis.
Returns
-------
PCEAnalysisResults
Use it to get the sobol indices and other information.
"""
def sobols(P, coefficients):
""" Utility routine to calculate sobols based on coefficients
"""
A = np.array(P.coefficients) != 0
multi_indices = np.array(
[P.exponents[A[:, i]].sum(axis=0) for i in range(A.shape[1])])
sobol_mask = multi_indices != 0
_, index = np.unique(sobol_mask, axis=0, return_index=True)
index = np.sort(index)
sobol_idx_bool = sobol_mask[index]
sobol_idx_bool = np.delete(sobol_idx_bool, [0], axis=0)
n_sobol_available = sobol_idx_bool.shape[0]
if len(coefficients.shape) == 1:
n_out = 1
else:
n_out = coefficients.shape[1]
n_coeffs = coefficients.shape[0]
sobol_poly_idx = np.zeros([n_coeffs, n_sobol_available])
for i_sobol in range(n_sobol_available):
sobol_poly_idx[:, i_sobol] = np.all(
sobol_mask == sobol_idx_bool[i_sobol], axis=1)
sobol = np.zeros([n_sobol_available, n_out])
for i_sobol in range(n_sobol_available):
sobol[i_sobol] = np.sum(np.square(
coefficients[sobol_poly_idx[:, i_sobol] == 1]),
axis=0)
idx_sort_descend_1st = np.argsort(sobol[:, 0], axis=0)[::-1]
sobol = sobol[idx_sort_descend_1st, :]
sobol_idx_bool = sobol_idx_bool[idx_sort_descend_1st]
sobol_idx = [0 for _ in range(sobol_idx_bool.shape[0])]
for i_sobol in range(sobol_idx_bool.shape[0]):
sobol_idx[i_sobol] = np.array(
[i for i, x in enumerate(sobol_idx_bool[i_sobol, :]) if x])
var = ((coefficients[1:]**2).sum(axis=0))
sobol = sobol / var
return sobol, sobol_idx, sobol_idx_bool
if data_frame is None:
raise RuntimeError("Analysis element needs a data frame to "
"analyse")
elif data_frame.empty:
raise RuntimeError(
"No data in data frame passed to analyse element")
qoi_cols = self.qoi_cols
results = {
'statistical_moments': {},
'percentiles': {},
'sobols_first': {k: {}
for k in qoi_cols},
'sobols_second': {k: {}
for k in qoi_cols},
'sobols_total': {k: {}
for k in qoi_cols},
'correlation_matrices': {},
'output_distributions': {},
'fit': {},
'Fourier_coefficients': {},
}
# Get sampler informations
P = self.sampler.P
nodes = self.sampler._nodes
weights = self.sampler._weights
regression = self.sampler.regression
# Extract output values for each quantity of interest from Dataframe
# samples = {k: [] for k in qoi_cols}
# for run_id in data_frame[('run_id', 0)].unique():
# for k in qoi_cols:
# data = data_frame.loc[data_frame[('run_id', 0)] == run_id][k]
# samples[k].append(data.values.flatten())
samples = {k: [] for k in qoi_cols}
for k in qoi_cols:
samples[k] = data_frame[k].values
# Compute descriptive statistics for each quantity of interest
for k in qoi_cols:
# Approximation solver
if regression:
fit, fc = cp.fit_regression(P, nodes, samples[k], retall=1)
else:
fit, fc = cp.fit_quadrature(P,
nodes,
weights,
samples[k],
retall=1)
results['fit'][k] = fit
results['Fourier_coefficients'][k] = fc
# Percentiles: 1%, 10%, 50%, 90% and 99%
P01, P10, P50, P90, P99 = cp.Perc(
fit, [1, 10, 50, 90, 99], self.sampler.distribution).squeeze()
results['percentiles'][k] = {
'p01': P01,
'p10': P10,
'p50': P50,
'p90': P90,
'p99': P99
}
if self.sampling: # use chaospy's sampling method
# Statistical moments
mean = cp.E(fit, self.sampler.distribution)
var = cp.Var(fit, self.sampler.distribution)
std = cp.Std(fit, self.sampler.distribution)
results['statistical_moments'][k] = {
'mean': mean,
'var': var,
'std': std
}
# Sensitivity Analysis: First, Second and Total Sobol indices
sobols_first_narr = cp.Sens_m(fit, self.sampler.distribution)
sobols_second_narr = cp.Sens_m2(fit, self.sampler.distribution)
sobols_total_narr = cp.Sens_t(fit, self.sampler.distribution)
sobols_first_dict = {}
sobols_second_dict = {}
sobols_total_dict = {}
for i, param_name in enumerate(self.sampler.vary.vary_dict):
sobols_first_dict[param_name] = sobols_first_narr[i]
sobols_second_dict[param_name] = sobols_second_narr[i]
sobols_total_dict[param_name] = sobols_total_narr[i]
results['sobols_first'][k] = sobols_first_dict
results['sobols_second'][k] = sobols_second_dict
results['sobols_total'][k] = sobols_total_dict
else: # use PCE coefficients
# Statistical moments
mean = fc[0]
var = np.sum(fc[1:]**2, axis=0)
std = np.sqrt(var)
results['statistical_moments'][k] = {
'mean': mean,
'var': var,
'std': std
}
# Sensitivity Analysis: First, Second and Total Sobol indices
sobol, sobol_idx, _ = sobols(P, fc)
varied = [_ for _ in self.sampler.vary.get_keys()]
S1 = {_: np.zeros(sobol.shape[-1]) for _ in varied}
ST = {_: np.zeros(sobol.shape[-1]) for _ in varied}
#S2 = {_ : {__: np.zeros(sobol.shape[-1]) for __ in varied} for _ in varied}
#for v in varied: del S2[v][v]
S2 = {
_: np.zeros((len(varied), sobol.shape[-1]))
for _ in varied
}
for n, si in enumerate(sobol_idx):
if len(si) == 1:
v = varied[si[0]]
S1[v] = sobol[n]
elif len(si) == 2:
v1 = varied[si[0]]
v2 = varied[si[1]]
#S2[v1][v2] = sobol[n]
#S2[v2][v1] = sobol[n]
S2[v1][si[1]] = sobol[n]
S2[v2][si[0]] = sobol[n]
for i in si:
ST[varied[i]] += sobol[n]
results['sobols_first'][k] = S1
results['sobols_second'][k] = S2
results['sobols_total'][k] = ST
# Correlation matrix
results['correlation_matrices'][k] = cp.Corr(
fit, self.sampler.distribution)
# Output distributions
results['output_distributions'][k] = cp.QoI_Dist(
fit, self.sampler.distribution)
return PCEAnalysisResults(raw_data=results,
samples=data_frame,
qois=self.qoi_cols,
inputs=list(self.sampler.vary.get_keys()))
def analyse(self, data_frame=None):
"""Perform PCE analysis on input `data_frame`.
Parameters
----------
data_frame : :obj:`pandas.DataFrame`
Input data for analysis.
Returns
-------
dict:
Contains analysis results in sub-dicts with keys -
['statistical_moments', 'percentiles', 'sobol_indices',
'correlation_matrices', 'output_distributions']
"""
if data_frame is None:
raise RuntimeError("Analysis element needs a data frame to "
"analyse")
elif data_frame.empty:
raise RuntimeError(
"No data in data frame passed to analyse element")
qoi_cols = self.qoi_cols
results = {
'statistical_moments': {},
'percentiles': {},
'sobols_first': {k: {}
for k in qoi_cols},
'sobols_second': {k: {}
for k in qoi_cols},
'sobols_total': {k: {}
for k in qoi_cols},
'correlation_matrices': {},
'output_distributions': {},
}
# Get sampler informations
P = self.sampler.P
nodes = self.sampler._nodes
weights = self.sampler._weights
regression = self.sampler.regression
# Extract output values for each quantity of interest from Dataframe
samples = {k: [] for k in qoi_cols}
for run_id in data_frame[('run_id', 0)].unique():
for k in qoi_cols:
data = data_frame.loc[data_frame[('run_id', 0)] == run_id][k]
samples[k].append(data.values.flatten())
# Compute descriptive statistics for each quantity of interest
for k in qoi_cols:
# Approximation solver
if regression:
fit = cp.fit_regression(P, nodes, samples[k])
else:
fit = cp.fit_quadrature(P, nodes, weights, samples[k])
# Statistical moments
mean = cp.E(fit, self.sampler.distribution)
var = cp.Var(fit, self.sampler.distribution)
std = cp.Std(fit, self.sampler.distribution)
results['statistical_moments'][k] = {
'mean': mean,
'var': var,
'std': std
}
# Percentiles: 10% and 90%
P10 = cp.Perc(fit, 10, self.sampler.distribution)
P90 = cp.Perc(fit, 90, self.sampler.distribution)
results['percentiles'][k] = {'p10': P10, 'p90': P90}
# Sensitivity Analysis: First, Second and Total Sobol indices
sobols_first_narr = cp.Sens_m(fit, self.sampler.distribution)
sobols_second_narr = cp.Sens_m2(fit, self.sampler.distribution)
sobols_total_narr = cp.Sens_t(fit, self.sampler.distribution)
sobols_first_dict = {}
sobols_second_dict = {}
sobols_total_dict = {}
for i, param_name in enumerate(self.sampler.vary.vary_dict):
sobols_first_dict[param_name] = sobols_first_narr[i]
sobols_second_dict[param_name] = sobols_second_narr[i]
sobols_total_dict[param_name] = sobols_total_narr[i]
results['sobols_first'][k] = sobols_first_dict
results['sobols_second'][k] = sobols_second_dict
results['sobols_total'][k] = sobols_total_dict
# Correlation matrix
results['correlation_matrices'][k] = cp.Corr(
fit, self.sampler.distribution)
# Output distributions
results['output_distributions'][k] = cp.QoI_Dist(
fit, self.sampler.distribution)
return PCEAnalysisResults(raw_data=results,
samples=data_frame,
qois=self.qoi_cols,
inputs=list(self.sampler.vary.get_keys()))
u2 = cp.Uniform(0,1) joint_distribution = cp.J(u1, u2) # 2. generate orthogonal polynomials polynomial_order = 3 poly = cp.orth_ttr(polynomial_order, joint_distribution) # 3.1 generate samples number_of_samples = 100 samples = joint_distribution.sample(size=number_of_samples, rule='R') # 3.2 evaluate the simple model for all samples model_evaluations = samples[0]+samples[1]*samples[0] # 3.3 use regression to generate the polynomial chaos expansion gpce_regression = cp.fit_regression(poly, samples, model_evaluations) # end example linear regression # _Spectral Projection_ # spectral projection in chaospy cp.fit_quadrature? # end spectral projection in chaospy # example spectral projection # 1. define marginal and joint distributions u1 = cp.Uniform(0,1) u2 = cp.Uniform(0,1) joint_distribution = cp.J(u1, u2)
####
# Plotting input distributions
#pp.figure()
#pp.hist(samples[0,:],density=True,color='k',bins=40,alpha=0.50,label='Samples')
#d = np.linspace(min(samples[0,:]),max(samples[0,:]),1000)
#pp.plot(d,cp.Normal(1,0.4).pdf(d),'k',label='Roughness PDF')
#pp.xlabel('Roughness (mm)')
#pp.ylabel('Frequency')
#pp.show()
Node = 4
ConditionPoints = 100
Order = 3
polynomial_expansion = cp.orth_ttr(Order, distribution)
foo_approx = cp.fit_regression(polynomial_expansion, samples[:ConditionPoints], output[:ConditionPoints,Node,:])
coefs_kernal = cp.descriptives.misc.QoI_Dist(foo_approx,distribution)
#pp.figure(figsize=(10,6))
#axs = []
#axs.append(pp.subplot2grid((2,3),(0,0),colspan = 3))
#axs.append(pp.subplot2grid((2,3),(1,0)))
#axs.append(pp.subplot2grid((2,3),(1,1)))
#axs.append(pp.subplot2grid((2,3),(1,2)))
##axs[0].plot(Transient_Times,np.mean(output[:,Node,:].T,axis=1),'k--')
##axs[0].fill_between(Transient_Times,np.percentile(output[:,Node,:].T,5,axis=1),np.percentile(output[:,Node,:].T,95,axis=1),alpha = 0.5)
##axs[0].plot(Transient_Times,cp.E(foo_approx,demand_distribution),'k')
Input_MZ_MY_Turb2 = [yaw_1_train_scaled, yaw_2_train_scaled, Distance_train_scaled, MZ_MY_scaled]
Dist_max = np.max(Input_Power2[2])
########## Creating the individual surrogate models for the power and the DEL of the upstream and downstream turbine ###############################
####################################################################################################################################################
# Creating the surrogate model for the power of the upstream turbine
distribution1 = cp.J(cp.Normal(0, 4.95/30))
orthogonal_expansion_ttr1 = cp.orth_ttr(3, distribution1 )
Matrix = []
Input = Input_Power1;
for drand in range(0, 9):
I_rand = random.sample(range(1, len(Input[0])), int(0.9*len(Input[0])))
approx_model_ttr_Power1 = cp.fit_regression(orthogonal_expansion_ttr1, [Input[0][I_rand]],Input[1][I_rand])
Coefs = []
for dq in range(0, len(approx_model_ttr_Power1.keys)):
a = approx_model_ttr_Power1.A[approx_model_ttr_Power1.keys[dq]]
Coefs.append(a.tolist())
Matrix.append(Coefs)
Coefs = np.mean(Matrix, axis = 0)
for dq in range(0, len(approx_model_ttr_Power1.keys)):
approx_model_ttr_Power1.A[approx_model_ttr_Power1.keys[dq]] = Coefs[dq]
# Creating the surrogate model for the power of the downstream turbine
distribution2 = cp.J(cp.Normal(0, 4.95/30), cp.Normal(0, 4.95/30), cp.Uniform(0, 1))
orthogonal_expansion_ttr2 = cp.orth_ttr(4, distribution2 )
Input = Input_Power2;
Matrix = []
solves1.append(qoi[0:6])
solves2.append(qoi[6])
solves3.append(qoi[7])
# Create surrogate model
#u_hat(x,t;q)=sum_n C_n(x) * P_n(q)
qoi1_hat = cp.fit_regression(Polynomials, nodes, solves1,rule=rgm_rule)
qoi2_hat = cp.fit_regression(Polynomials, nodes, solves2,rule=rgm_rule)
qoi3_hat = cp.fit_regression(Polynomials, nodes, solves3,rule=rgm_rule)
#output qoi metrics
mean = cp.E(qoi1_hat, joint_KL)
var = cp.Var(qoi1_hat, joint_KL)
std = np.sqrt(var)
cv = np.divide(np.array(std), np.array(mean))
kurt = cp.Kurt(qoi1_hat,joint_KL)
skew = cp.Skew(qoi1_hat,joint_KL)
metrics = np.array([mean, std,var,cv,kurt,skew]).T
rawdata = np.array(qoi1_hat(*joint_KL.sample(10**5))).T#np.array(solves1)
prodata = np.column_stack((qoi_names, metrics.astype(np.object)))
#prodata[:,1].astype(float)
def analyse(self, data_frame=None):
"""Perform PCE analysis on input `data_frame`.
Parameters
----------
data_frame : :obj:`pandas.DataFrame`
Input data for analysis.
Returns
-------
dict:
Contains analysis results in sub-dicts with keys -
['statistical_moments', 'percentiles', 'sobol_indices',
'correlation_matrices', 'output_distributions']
"""
if data_frame is None:
raise RuntimeError("Analysis element needs a data frame to "
"analyse")
elif data_frame.empty:
raise RuntimeError(
"No data in data frame passed to analyse element")
qoi_cols = self.qoi_cols
results = {
'statistical_moments': {},
'percentiles': {},
'sobols_first': {k: {}
for k in qoi_cols},
'sobols_second': {k: {}
for k in qoi_cols},
'sobols_total': {k: {}
for k in qoi_cols},
'correlation_matrices': {},
'output_distributions': {},
}
# Get the Polynomial
P = self.sampler.P
# Get the PCE variante to use (Regression or Projection)
regression = self.sampler.regression
# Compute nodes (and weights)
if regression:
nodes = cp.generate_samples(order=self.sampler.n_samples,
domain=self.sampler.distribution,
rule=self.sampler.rule)
else:
nodes, weights = cp.generate_quadrature(
order=self.sampler.quad_order,
dist=self.sampler.distribution,
rule=self.sampler.rule,
sparse=self.sampler.quad_sparse,
growth=self.sampler.quad_growth)
# Extract output values for each quantity of interest from Dataframe
samples = {k: [] for k in qoi_cols}
for run_id in data_frame.run_id.unique():
for k in qoi_cols:
data = data_frame.loc[data_frame['run_id'] == run_id][k]
samples[k].append(data.values)
# Compute descriptive statistics for each quantity of interest
for k in qoi_cols:
# Approximation solver
if regression:
if samples[k][0].dtype == object:
for i in range(self.sampler.count):
samples[k][i] = samples[k][i].astype("float64")
fit = cp.fit_regression(P, nodes, samples[k], "T")
else:
fit = cp.fit_quadrature(P, nodes, weights, samples[k])
# Statistical moments
mean = cp.E(fit, self.sampler.distribution)
var = cp.Var(fit, self.sampler.distribution)
std = cp.Std(fit, self.sampler.distribution)
results['statistical_moments'][k] = {
'mean': mean,
'var': var,
'std': std
}
# Percentiles (Pxx)
P10 = cp.Perc(fit, 10, self.sampler.distribution)
P90 = cp.Perc(fit, 90, self.sampler.distribution)
results['percentiles'][k] = {'p10': P10, 'p90': P90}
# Sensitivity Analysis: First, Second and Total Sobol indices
sobols_first_narr = cp.Sens_m(fit, self.sampler.distribution)
sobols_second_narr = cp.Sens_m2(fit, self.sampler.distribution)
sobols_total_narr = cp.Sens_t(fit, self.sampler.distribution)
sobols_first_dict = {}
sobols_second_dict = {}
sobols_total_dict = {}
ipar = 0
i = 0
for param_name in self.sampler.vary.get_keys():
j = self.sampler.params_size[ipar]
sobols_first_dict[param_name] = sobols_first_narr[i:i + j]
sobols_second_dict[param_name] = sobols_second_narr[i:i + j]
sobols_total_dict[param_name] = sobols_total_narr[i:i + j]
i += j
ipar += 1
results['sobols_first'][k] = sobols_first_dict
results['sobols_second'][k] = sobols_second_dict
results['sobols_total'][k] = sobols_total_dict
# Correlation matrix
results['correlation_matrices'][k] = cp.Corr(
fit, self.sampler.distribution)
# Output distributions
results['output_distributions'][k] = cp.QoI_Dist(
fit, self.sampler.distribution)
return results
Alpha = cp.Normal(1,0.1) Beta = cp.Normal(0.1,0.01) F = cp.Normal(0.02,0.001) K = cp.Uniform(0.01,0.05) Distributions = cp.J(Alpha,Beta,F,K) maxT = 60.0 dT = 0.002 time = np.arange(0,maxT+dT,dT) Order = 3 NoSamples = 40 Output = TurbData[:NoSamples,:,-1] polynomial_expansion = cp.orth_ttr(Order, Distributions) foo_approx = cp.fit_regression(polynomial_expansion, Samples[:,:NoSamples], Output[:,-1]) expected = cp.E(foo_approx, Distributions) deviation = cp.Std(foo_approx, Distributions) COV = cp.Cov(foo_approx, Distributions) #Perc = cp.Perc(foo_approx,[5,95],Distributions) f,axs = pp.subplots(figsize=(9, 6),nrows = 1,ncols = 1,sharex=True) axs.plot(time[1:],expected,'k') axs.fill_between(time[1:],expected+deviation,expected-deviation,color='k',alpha=0.25) #axs.fill_between(time[1:],Perc[0],Perc[1],colour = 'k',alpha= 0.25) pp.show()
