def calculate_RMSE_Rsquared(self, optimiser, nt):
"""
this function calculates the root mean squared error of the interpola-
ted model for a sample of nt test data
Input:
optimiser- optimiser to be used
nt- the size of the sample test data
Output:
RMSE- the root mean squared error of nt sampling points
Rsquared- the correlation coefficient
"""
yi_p, yi, yi_dif, yiyi_p, yiyi, yi_pyi_p = [], [], [], [], [], []
Sample = random.sample([i for i in range(len(self.X))], nt)
Model = kriging(self.X, self.y, name="%s" % self.name)
Model.train(optimiser)
for i, j in enumerate(Sample):
yi_p.append(Model.predict(self.X[j]))
yi.append(self.y[j])
yi_dif.append(yi[i] - yi_p[i])
yiyi_p.append(yi[i] * yi_p[i])
yiyi.append(yi[i] * yi[i])
yi_pyi_p.append(yi_p[i] * yi_p[i])
RMSE = np.sqrt((sum(yi_dif) ** 2.0) / float(nt))
Rsquared = (
(float(nt) * sum(yiyi_p) - sum(yi) * sum(yi_p))
/ (np.sqrt((float(nt) * sum(yiyi) - sum(yi) ** 2.0) * (float(nt) * sum(yi_pyi_p) - sum(yi_p) ** 2.0)))
) ** 2.0
return ["RMSE = %f" % RMSE, "Rsquared = %f" % Rsquared]
def krig_sp():
# Initial random move
norm = 2 * (np.random.rand(2) - 0.5)
norm /= la.norm(norm)
path = [np.array(norm) / 10]
# Start krig model with origin and random displacement
sp = samplingplan(len(norm))
hc = 2 * (sp.optimallhc(2**len(norm)) - 0.5)
krig_init = [[0.0, 0.0]]
for p in hc:
krig_init.append(p)
krig_init = np.array(krig_init)
k = kriging(krig_init, func(krig_init), testfunction=func, name='simple')
k.train()
k.plot()
last_found = norm
for n in range(0, 100):
plt.subplot(221)
pots.plot(k.predict)
found = []
weights = []
for n in range(0, 10):
path = spalgo.act_relax_fd(k.predict,
max_range=1.2,
max_step=0.01,
max_iter=1000)
plt.plot(*zip(*path))
pt = np.array(path[-1])
duplicate = False
for i, p in enumerate(found):
if la.norm(pt - p) < 0.1:
weights[i] += 1
duplicate = True
break
if duplicate:
continue
found.append(pt)
weights.append(1)
imax = weights.index(max(weights))
last_found = found[imax]
plt.plot([last_found[0]], [last_found[1]], marker="+")
plt.subplot(222)
pots.plot(pots.pot)
plt.plot(*zip(*path))
k.addPoint(path[-1], func([last_found]))
k.train()
plt.draw()
plt.pause(0.1)
plt.clf()
def test1():
sp = samplingplan(2)
x = []
for n in range(0, 4):
x.append(np.random.rand(2) * 2 - 1)
x = np.array(x) * 2
# Next, we define the problem we would like to solve
testfun = func
y = testfun(x)
# Now that we have our initial data, we can create an instance of a Kriging model
k = kriging(x, y, testfunction=testfun, name='simple')
k.train()
# Now, five infill points are added. Note that the model is re-trained after each point is added
numiter = 10
for i in range(numiter):
print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
newpoints = k.infill(1)
for point in newpoints:
k.addPoint(point, testfun([point])[0])
k.train()
# And plot the results
k.plot()
def initial_import(self, plot=False):
'''
Loads LHS evaluations and initialises the kriging model.
'''
with open('init_lhs.p', 'rb') as fp:
self.lhs_record = leek.load(fp)
X = self.lhs_record['location']
y = self.lhs_record['value']
print(X)
print(y)
# Adds the LHS evaluations to other history tracking dictionaries.
for ii in range(len(y)):
self.eval_hist['location'].append(list(copy.deepcopy(X[ii])))
self.eval_hist['value'].append(copy.deepcopy(y[ii]))
self.krig_hist['location'].append(list(copy.deepcopy(X[ii])))
self.krig_hist['value'].append(copy.deepcopy(y[ii]))
# Creates either a kriging or regression kriging model
print("Setting up Kriging Model")
if self.regressionswitch == True:
self.krig = regression_kriging(X, y, name='simple', testPoints=250)
else:
self.krig = kriging(X, y, name='simple', testPoints=100)
# Train model
self.krig.train(optimizer='ga')
self.krig.snapshot()
# Displays initial kriging representation of function.
if plot == True:
self.krig.plot()
def calculate_RMSE_Rsquared(self, optimiser, nt):
"""
this function calculates the root mean squared error of the interpola-
ted model for a sample of nt test data
Input:
optimiser- optimiser to be used
nt- the size of the sample test data
Output:
RMSE- the root mean squared error of nt sampling points
Rsquared- the correlation coefficient
"""
yi_p, yi, yi_dif, yiyi_p, yiyi, yi_pyi_p = [], [], [], [], [], []
Sample = random.sample([i for i in range(len(self.X))], nt)
Model = kriging(self.X, self.y, name='%s' % self.name)
Model.train(optimiser)
for i, j in enumerate(Sample):
yi_p.append(Model.predict(self.X[j]))
yi.append(self.y[j])
yi_dif.append(yi[i] - yi_p[i])
yiyi_p.append(yi[i]*yi_p[i])
yiyi.append(yi[i]*yi[i])
yi_pyi_p.append(yi_p[i]*yi_p[i])
RMSE = np.sqrt((sum(yi_dif)**2.) / float(nt))
Rsquared = ((float(nt)*sum(yiyi_p) - sum(yi)*sum(yi_p)) /
(np.sqrt((float(nt)*sum(yiyi) - sum(yi)**2.) *
(float(nt)*sum(yi_pyi_p) - sum(yi_p)**2.))))**2.
return ['RMSE = %f' % RMSE, 'Rsquared = %f' % Rsquared]
def train(self, mode='lhs', **kwargs):
target = []
if mode is 'lhs':
for feature in self.features:
params = SWANParams(drf=feature[0],
cfw=feature[1],
stpm=feature[2],
fidelity_time=self.fidelity[0],
fidelity_space=self.fidelity[1])
target.append(
self.fake_model.output_from_model(
params=params)[self.station])
target = np.asarray(target)
start_time = datetime.now().strftime(DATE_FORMAT)
print(
f'{start_time}: starting to train kriging model '
f'with {self.points_to_train} points for station: {self.station}')
krig = kriging(self.features, target, name='multikrieg')
krig.train(optimizer='ga')
self.krig = krig
end_time = datetime.now().strftime(DATE_FORMAT)
print(f'{end_time}: finished to train kriging model with'
f' {self.points_to_train} points for station: {self.station}')
def krigagemMatrix(self, colY, colX, colZ):
self.X = list(self.matrix[colY, colX, colZ])
testfun = testfunctions().squared
self.y = testfun(self.X)
self.k = kriging(self.X, self.y, testfunction=testfun, testPoints=300)
self.k.train()
self.k.snapshot()
def train_krig(X, y, optimizer='pso'):
"""
:param X:
:param y:
:param optimizer: 'pso', 'ga' (much more faster)
:return:
"""
krig = kriging(X, y, name='multikrieg')
krig.train(optimizer=optimizer)
return krig
def leave_n_out(self, q=5):
'''
:param q: the numer of groups to split the model data inot
:return:
'''
mseArray = []
for i in splitArrays(self.model, 5):
testk = kriging(i[0], i[1])
testk.train()
for j in range(len(i[2])):
mseArray.append(mse(i[3][j], testk.predict(i[2][j])))
del (testk)
return np.average(mseArray), np.std(mseArray)
def leave_n_out(self, q=5):
"""
:param q: the numer of groups to split the model data inot
:return:
"""
mseArray = []
for i in splitArrays(self.model, 5):
testk = kriging(i[0], i[1])
testk.train()
for j in range(len(i[2])):
mseArray.append(mse(i[3][j], testk.predict(i[2][j])))
del (testk)
return np.average(mseArray), np.std(mseArray)
def build_kriging_models(obj_values, inputs, constraints):
"""
Uses the pyKriging package to build a surrogate formulation of an optimization problem
Inputs:
obj_values [array]
inputs [array]
constraints [array]
Outputs:
obj_surrogate callable function(inputs)
constraints_surrogates [array(callable function(inputs))]
surrogate_function callable function(inputs): returns the objective, constraints, and whether it succeeded as an int
"""
#now build surrogates based on these
t1=time.time()
obj_surrogate = kriging(inputs, obj_values , name='simple')
obj_surrogate.train()
constraints_surrogates = []
for j in range(len(constraints[0,:])):
constraint_surrogate = kriging(inputs, constraints[:,j] , name='simple')
constraint_surrogate.train()
constraints_surrogates.append(constraint_surrogate)
t2=time.time()
print 'time to set up = ', t2-t1
surrogate_function = Surrogate_Problem()
surrogate_function.obj_surrogate = obj_surrogate
surrogate_function.constraints_surrogates = constraints_surrogates
return obj_surrogate, constraints_surrogates, surrogate_function
def kriging_model_check(self, k):
lr, lc = np.shape(k.X)[0], np.shape(k.X)[1]
X_c, y_c = np.zeros((lr - 1, lc)), np.zeros(lr - 1)
# time is of the essence
if lr < 8:
sz = 3
elif lr > 12:
sz = 1
else:
sz = 2
test_points = np.random.randint(lr, size=sz) # just three pts
# check several randomly chosen point sets
for i in range(0, len(test_points)):
a = test_points[i]
test_X = k.X[a, :]
compar_y = k.y[a]
print 'kriging check : a : ' + str(a)
# make comparison models
if a != 0 or a != lr:
X_c[0:a / 2, :] = k.X[0:a / 2, :]
X_c[a / 2:a - 1, :] = k.X[a / 2 + 1:a, :]
y_c[0:a / 2] = k.y[0:a / 2]
y_c[a / 2:a - 1] = k.y[a / 2 + 1:a]
elif a == 0:
X_c[:, :] = k.X[1:a, :]
y_c[:] = k.y[1:a]
else:
X_c[:, :] = k.X[0:a - 1, :]
y_c[:] = k.y[0:a - 1]
# compare
k_c = kriging(X_c, y_c)
k_c.train()
test_y = k_c.predict(test_X)
# these ifs prevent infs :/
if compar_y != 0 and test_y != 0:
frac_check = np.abs((compar_y - test_y) / compar_y)
elif compar_y == 0 and test_y != 0:
frac_check = np.abs((compar_y - test_y) / test_y)
else:
frac_check = 0
# update holder numbers
if i == 0:
frac = frac_check
if frac_check > frac:
frac = frac_check
print 'kriging check : largest percentage difference : ' + str(
frac)
return frac
def build_kriging_models(obj_values, inputs, constraints):
"""
Uses the pyKriging package to build a surrogate formulation of an optimization problem
Inputs:
obj_values [array]
inputs [array]
constraints [array]
Outputs:
obj_surrogate callable function(inputs)
constraints_surrogates [array(callable function(inputs))]
surrogate_function callable function(inputs): returns the objective, constraints, and whether it succeeded as an int
"""
#now build surrogates based on these
t1 = time.time()
obj_surrogate = kriging(inputs, obj_values, name='simple')
obj_surrogate.train()
constraints_surrogates = []
for j in range(len(constraints[0, :])):
constraint_surrogate = kriging(inputs,
constraints[:, j],
name='simple')
constraint_surrogate.train()
constraints_surrogates.append(constraint_surrogate)
t2 = time.time()
print('time to set up = ', t2 - t1)
surrogate_function = Surrogate_Problem()
surrogate_function.obj_surrogate = obj_surrogate
surrogate_function.constraints_surrogates = constraints_surrogates
return obj_surrogate, constraints_surrogates, surrogate_function
def add_point(self, xx, fx):
"""Add a new function evaluation
:param xx: Point to add
:param fx: The function value of the point to add
"""
dim = len(xx)
self._realloc(dim)
self.x[self.nump, :] = xx
self.fx[self.nump, :] = fx
self.nump += 1
if self.k is None:
self.k = kriging(self.x[:self.nump+1, :],
self.fx[:self.nump+1, :], self.maxp)
self.k.train()
# add point to kriging model
self.k.addPoint(xx, fx)
self.updated = False
def import_hist(self, plot=False):
'''
Imports saved history files enabling quick restarting in the event of a crash
or other issue.
'''
# Import _hist libraries
with open('krig_hist.p', 'rb') as fp:
self.krig_hist = leek.load(fp)
with open('eval_hist.p', 'rb') as fp:
self.eval_hist = leek.load(fp)
X=[]
y=[]
for ii in range(len(self.krig_hist['value'])):
X.append(list(copy.deepcopy(self.krig_hist['location'][ii])))
if type(self.krig_hist['value'][ii]) == np.ndarray:
y.append(self.krig_hist['value'][ii][0])
else:
y.append(self.krig_hist['value'][ii])
print(type(self.krig_hist['value'][ii]))
X = np.array(X)
y = np.array(y)
# Creates either a kriging or regression kriging model based on
# previous values used.
print("Setting up Kriging Model")
if self.regressionswitch == True:
self.krig = regression_kriging(X, y, name='simple', testPoints=100)
else:
self.krig = kriging(X, y, name='simple', testPoints=100)
# Train model
self.krig.train(optimizer='ga')
self.krig.snapshot()
if plot==True:
self.krig.plot()
def execute(self):
with open(str(self.json_string_in.getValue()), 'r') as files:
string = files.read()
json_dict = demjson.decode(string)
method = json_dict['type']
xmin, xmax, ymin, ymax = float(json_dict['bounding_box']['x_min']), float(json_dict['bounding_box']['x_max']), float(json_dict['bounding_box']['y_min']), float(json_dict['bounding_box']['y_max'])
nx, ny = json_dict['grid_size']['n_x'], json_dict['grid_size']['n_y']
dx = (xmax - xmin) / nx
dy = (ymax - ymin) / ny
X = []
y = []
for point in json_dict['point_values']:
X.append([point['y'], point['x']])
y.append(point['value'])
self.grid = np.zeros((ny,nx))
if method == 'kriging':
k = kriging(np.array(X), np.array(y))
self.status.set('training model...')
k.train()
self.status.set('predicting grid values...')
for i in range(ny):
for j in range(nx):
cell = np.array([ymin + dy * j + .5 * dy, xmin + dx * i + .5 * dx])
self.grid[i][j] = k.predict(cell)
else:
print 'method is not supported'
output = demjson.encode({"raster":self.grid})
print str(output)
tmpFile=tempfile.NamedTemporaryFile(suffix='.json',prefix='tmp', delete=False)
tmpFile.write(str(output))
self.array_string_out.setValue(tmpFile.name)
def AK_MCS(S1, S2, N1, S0):
"""main function for AK-MCS: active learning method based on meta-model kriging
with simulation of Monte Carlo
S1: first selection population in Monte Carlo to construct the meta-model
S2: explained before
S0: the whole population generated by Monte Carlo
return
pf_matrix: the list of all calculated probabilities in every loop
ev_matrix: the list of all evaluation value of performance function by meta-model
U_min: the list of all minimum learning functions U in every loop
return them for the data treatment"""
# INITIALIZATION
#constraction of first model of Kriging
def calcul_prob_kriging(S0):
"""calculate the probability of failure by evaluating the sign of evaluation value"""
S_NEG = []
S_POS = []
for s in S0:
ev_s = k.predict(s)
if ev_s <= 0:
S_NEG.append(s)
else:
S_POS.append(s)
pf = round(float(len(S_NEG)) / float(len(S0)),
4) # take 4 number behind the .
print("failure probability= " + str(pf))
return pf, S_POS, S_NEG
def calcul_u(s):
"""calculate the learning function U"""
pred_s = k.predict(s)
sigma = math.sqrt(
k.predict_var(s)) # k.predict_var is the variance of Kriging
u = abs(pred_s) / sigma
return sigma, u, pred_s
# results of first calcultion
t1 = S1[:, 0] # thickness in S1
E1 = S1[:, 1] # modulu Young in S1
fichier = open('result.txt', 'w')
fichier.close()
for ts, Es in zip(t1, E1):
Y = lanch_calcul(ts, Es)
result = open("result.txt",
'a') # 'a' means open a file for append(write only str)
result.write(str(Y) + '\n')
result.close()
result_name = main_dir + "result.txt"
result_file = open(result_name, "r")
Y = np.loadtxt('result.txt') #
result_file.close()
# library of kriging
k = kriging(S1, Y, name='simple')
k.train()
pred_matrix = [k.predict(s) for s in S1]
#first calculation of probability
print("\n******* Initialization********")
# calculate failure probability
pf, S_POS, S_NEG = calcul_prob_kriging(S0)
plot_prob(S_POS, S_NEG, S1)
#AK_MCS(S1, S2, N1, S0)
#ITERATION
u_min = 1.9 #in case of the initial u_min > 5
iteration = 0
pf_matrix = []
U_min = []
NEW_S1 = S1
NEW_S2 = S2
while u_min < 2:
S1 = NEW_S1
S2 = NEW_S2
U = []
G = []
iteration += 1
print("\n**** iteration number: " + str(iteration) + "****")
for j in range(0, len(S2), 1):
s2 = S2[j]
sigma, u, ev_s = calcul_u(s2)
U.append(u)
G.append(ev_s)
u_min = min(U) # search for the min U
ind_s2min = U.index(u_min)
G_add = G[ind_s2min]
pred_matrix.append(G_add)
U_min.append(u_min) # collect all the Umin in every interation
print("learning function U : ", u_min)
add_s = S2[ind_s2min]
NEW_S1 = np.append(S1, [add_s], axis=0)
NEW_S2 = np.delete(S2, ind_s2min, axis=0)
t_add = add_s[0]
E_add = add_s[1]
add_Y = lanch_calcul(t_add, E_add)
k.addPoint(add_s, add_Y)
k.train()
# calculation failure probability
pf, S_POS, S_NEG = calcul_prob_kriging(S0)
if (iteration % 10) == 0:
plot_prob(S_POS, S_NEG, S1)
else:
pass
pf_matrix.append(pf)
return pf_matrix, U_min
from pyKriging.samplingplan import samplingplan
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(15)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().paulson1
y = testfun(X)
# We can choose between a ga and a pso here
optimizer = 'ga'
# Now that we have our initial data, we can create an instance of a kriging model
print 'Setting up the Kriging Model'
k = kriging(X, y, testfunction=testfun, name='simple_ei', testPoints=300)
k.train(optimizer=optimizer)
k.snapshot()
# Add 10 points based on model error reduction
for i in range(5):
newpoints = k.infill(1, method='error')
for point in newpoints:
print 'Adding point {}'.format(point)
k.addPoint(point, testfun(point)[0])
k.train(optimizer=optimizer)
k.snapshot()
# Infill ten points based on the expected improvement criterion
for i in range(5):
newpoints = k.infill(1, method='ei')
def calculate_SCVR(self, optimiser='pso', plot=0):
"""
this function calculates the standardised cross-validated residual
(SCVR)
value for each sampling point.
Return an nx1 array with the SCVR value of each sampling point. If plot
is 1, then plot scvr vs doe and y_pred vs y.
Input:
optimiser- optimiser to be used
plot- if 1 plots scvr vs doe and y_pred vs y
Output:
predict_list- list with different interpolated kriging models
excluding
each time one point of the sampling plan
predict_varr- list with the square root of the posterior variance
scvr- the scvr as proposed by Jones et al. (Journal of global
optimisation, 13: 455-492, 1998)
"""
y_normalised = (self.y - np.min(self.y)) / (np.max(self.y) -
np.min(self.y))
y_ = np.copy(self.y)
Kriging_models_i, list_arrays, list_ys, train_list = [], [], [], []
for i in range(self.n):
exclude_value = [i]
idx = list(set(range(self.n)) - set(exclude_value))
list_arrays.append(self.X[idx])
list_ys.append(y_[idx])
Kriging_models_i.append(kriging(list_arrays[i], list_ys[i],
name='%s' % self.name))
train_list.append(Kriging_models_i[i].train(optimizer=optimiser))
self.predict_list.append(Kriging_models_i[i].predict(self.X[i]))
self.predict_varr.append(Kriging_models_i[i].predict_var(self.X[i]))
self.scvr.append((y_normalised[i] - Kriging_models_i[i].normy(self.predict_list[i])) /self.predict_varr[i][0, 0])
if plot == 0:
return self.predict_list, self.predict_varr, self.scvr
elif plot == 1:
fig = plt.figure(figsize=(12, 8), facecolor='w', edgecolor='k',
linewidth= 2.0, frameon=True)
ax1 = fig.add_subplot(1, 2, 1)
ax1.scatter([i for i in range(1, self.n+1)], self.scvr, alpha=0.5,
edgecolor='black', facecolor='b', linewidth=2.)
ax1.plot([i for i in range(0, self.n+3)], [3]*(self.n+3), 'r')
ax1.plot([i for i in range(0, self.n+3)], [-3]*(self.n+3), 'r')
ax1.set_xlim(0, self.n+2)
ax1.set_ylim(-4, 4)
ax1.set_xlabel('DoE individual')
ax1.set_ylabel('SCVR')
ax2 = fig.add_subplot(1, 2, 2)
ax2.scatter(self.predict_list, self.y, alpha=0.5,
edgecolor='black', facecolor='b', linewidth=2.)
if np.max(self.y) > 0:
ax2.set_ylim(0, np.max(self.y) + 0.00001)
ax2.set_xlim(0, max(self.predict_list) + 0.00001)
else:
ax2.set_ylim(0, np.min(self.y) - 0.00001)
ax2.set_xlim(0, min(self.predict_list) - 0.00001)
ax2.plot(ax2.get_xlim(), ax2.get_ylim(), ls="-", c=".3")
ax2.set_xlabel('predicted y')
ax2.set_ylabel('y')
plt.show()
return self.predict_list, self.predict_varr, self.scvr
else:
raise ValueError('value for plot should be either 0 or 1')
G11 = convertCtrReal(G1, aG, bG)
S1[:, 0] = E11
S1[:, 1] = G11
E2 = S2[:, 0]
G2 = S2[:, 1]
E22 = convertCtrReal(E2, aE, bE)
G22 = convertCtrReal(G2, aG, bG)
S2[:, 0] = E22
S2[:, 1] = G22
#print(S2)
# *********************** BUILDING INITIAL KRIGING MODEL *********************#
#
#print(len(S1))
#print(len(Y))
k = kriging(S1, Y, name='simple')
k.train()
ev_matrix = [k.predict(s) for s in S1]
# ********************************** PLOT ************************************#
print("\n**** Initialization ****")
#
E0 = S0[:, 0]
G0 = S0[:, 1]
E00 = convertCtrReal(E0, aE, bE)
G00 = convertCtrReal(G0, aG, bG)
S0[:, 0] = E00
S0[:, 1] = G00
#
#umin = 0
def calculate_SCVR(self, optimiser="pso", plot=0):
"""
this function calculates the standardised cross-validated residual
(SCVR)
value for each sampling point.
Return an nx1 array with the SCVR value of each sampling point. If plot
is 1, then plot scvr vs doe and y_pred vs y.
Input:
optimiser- optimiser to be used
plot- if 1 plots scvr vs doe and y_pred vs y
Output:
predict_list- list with different interpolated kriging models
excluding
each time one point of the sampling plan
predict_varr- list with the square root of the posterior variance
scvr- the scvr as proposed by Jones et al. (Journal of global
optimisation, 13: 455-492, 1998)
"""
y_normalised = (self.y - np.min(self.y)) / (np.max(self.y) - np.min(self.y))
y_ = np.copy(self.y)
Kriging_models_i, list_arrays, list_ys, train_list = [], [], [], []
for i in range(self.n):
exclude_value = [i]
idx = list(set(range(self.n)) - set(exclude_value))
list_arrays.append(self.X[idx])
list_ys.append(y_[idx])
Kriging_models_i.append(kriging(list_arrays[i], list_ys[i], name="%s" % self.name))
train_list.append(Kriging_models_i[i].train(optimizer=optimiser))
self.predict_list.append(Kriging_models_i[i].predict(self.X[i]))
self.predict_varr.append(Kriging_models_i[i].predict_var(self.X[i]))
self.scvr.append(
(y_normalised[i] - Kriging_models_i[i].normy(self.predict_list[i])) / self.predict_varr[i][0, 0]
)
if plot == 0:
return self.predict_list, self.predict_varr, self.scvr
elif plot == 1:
fig = plt.figure(figsize=(12, 8), facecolor="w", edgecolor="k", linewidth=2.0, frameon=True)
ax1 = fig.add_subplot(1, 2, 1)
ax1.scatter(
[i for i in range(1, self.n + 1)], self.scvr, alpha=0.5, edgecolor="black", facecolor="b", linewidth=2.0
)
ax1.plot([i for i in range(0, self.n + 3)], [3] * (self.n + 3), "r")
ax1.plot([i for i in range(0, self.n + 3)], [-3] * (self.n + 3), "r")
ax1.set_xlim(0, self.n + 2)
ax1.set_ylim(-4, 4)
ax1.set_xlabel("DoE individual")
ax1.set_ylabel("SCVR")
ax2 = fig.add_subplot(1, 2, 2)
ax2.scatter(self.predict_list, self.y, alpha=0.5, edgecolor="black", facecolor="b", linewidth=2.0)
if np.max(self.y) > 0:
ax2.set_ylim(0, np.max(self.y) + 0.00001)
ax2.set_xlim(0, max(self.predict_list) + 0.00001)
else:
ax2.set_ylim(0, np.min(self.y) - 0.00001)
ax2.set_xlim(0, min(self.predict_list) - 0.00001)
ax2.plot(ax2.get_xlim(), ax2.get_ylim(), ls="-", c=".3")
ax2.set_xlabel("predicted y")
ax2.set_ylabel("y")
plt.show()
return self.predict_list, self.predict_varr, self.scvr
else:
raise ValueError("value for plot should be either 0 or 1")
sys.path.append("../../")
from util import io
import numpy as np
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
from pyKriging.testfunctions import testfunctions
dataFilePath = "../../data/samples-data.data"
labelsFilePath = "../../data/samples-data-labels.data"
def getTrainData():
"""获取训练数据"""
X = io.getData(dataFilePath)
Y = io.getData(labelsFilePath)
return X, Y
X, Y = getTrainData()
k = kriging(X, Y)
k.train()
# k.snapshot()
testX = np.array([-60., 168.3, -121.16, -56.34, -77.])
pdtValue = k.predict(X)
print("pdtValue: {}, label: {}".format(pdtValue, Y[0]))
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
from pyKriging.testfunctions import testfunctions
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(3)
X = sp.optimallhc(30)
# Next, we define the problem we would like to solve
testfun = testfunctions().squared
y = testfun(X)
# Now that we have our initial data, we can create an instance of a kriging model
k = kriging(X, y, testfunction=testfun, testPoints=300)
# The model is then trained
k.train()
k.snapshot()
# It's typically beneficial to add additional points based on the results of the initial training
# The infill method can be used for this
# In this example, we will add nine points in three batches. The model gets trained after each stage
for i in range(10):
print k.history['rsquared'][-1]
print 'Infill iteration {0}'.format(i + 1)
infillPoints = k.infill(10)
# Evaluate the infill points and add them back to the Kriging model
for point in infillPoints:
def train(self):
self.model = kriging(self.data.values[:, :-1], self.data.values[:, -1])
self.model.train()
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(20)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin
y = testfun(X)
# Now that we have our initial data, we can create an instance of a Kriging model
k = kriging(X, y, testfunction=testfun, name='simple')
k.train()
# Now, five infill points are added. Note that the model is re-trained after each point is added
numiter = 5
for i in range(numiter):
print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
newpoints = k.infill(1)
for point in newpoints:
k.addPoint(point, testfun(point)[0])
k.train()
# And plot the results
k.plot()
from pyKriging.utilities import saveModel
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(5)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin
# We generate our observed values based on our sampling plan and the test function
y = testfun(X)
print 'Setting up the Kriging Model'
cvMSE = []
# Now that we have our initial data, we can create an instance of a kriging model
k = kriging(X, y, testfunction=testfun, name='simple', testPoints=300)
k.train(optimizer='ga')
k.snapshot()
# cv = Cross_Validation(k)
# cvMSE.append( cv.leave_n_out(q=5)[0] )
k.plot()
for i in range(15):
print i
newpoints = k.infill(1)
for point in newpoints:
# print 'Adding point {}'.format(point)
k.addPoint(point, testfun(point)[0])
k.train(optimizer='pso')
k.snapshot()
# cv = Cross_Validation(k)
]).T.astype("float32") # shape=[M,2]
pnum = int(np.sum(target_mask / 255)) # 1枚の画像内にある予測しないといけない点の数
startFlag = True
pred_imgs = []
# 範囲ごとのMAEを保存するリスト
maes, mae0, mae05_2, maes_sep = [], [], [], []
for ite, img in enumerate(testImg):
print("{} of {} images".format(ite + 1, testImg.shape[0]))
y = img[maskImg * seaImg > 0]
#pdb.set_trace()
stime = time.time()
k = kriging(X, y, name='InpaintingKriging')
k.train()
train_time = time.time() - stime
print("{}sec for training".format(train_time), end=" ")
pickle.dump(k, open("krigingmodel{}-{}".format(exi, ite + exi_s),
"wb"))
#pdb.set_trace()
Prediction = CuPyPredicter(k)
def predict(xs):
res = np.zeros_like(img).astype("float32")
for iterate, p in enumerate(xs):
print("\r predict ite:{}-point:{} ".format(ite + 1, iterate),
end="")
i = int(p[0])
def min_mode():
# Initial random move
norm = 2 * (np.random.rand(2) - 0.5)
norm /= la.norm(norm)
path = [np.array(norm) / 10]
# Start krig model with origin and random displacement
krig_init = np.array([[0, 0], path[-1]])
k = kriging(krig_init, func(krig_init), testfunction=func, name='simple')
k.train()
plt.show()
for n in range(0, 100):
v = pots.pot(path[-1])
g = pots.grad(path[-1])
h = pots.hess_fd(path[-1], k.predict)
k.addPoint(path[-1], v)
k.train()
plt.subplot(221)
pots.plot(k.predict)
plt.plot(*zip(*path))
plt.subplot(222)
pots.plot()
plt.plot(*zip(*path))
plt.draw()
plt.pause(0.001)
plt.clf()
evals, evecs = la.eig(h)
both = zip(evals, evecs)
both.sort()
evals, evecs = zip(*both)
dots = [np.abs(np.dot(e, path[-1])) for e in evecs]
imax = dots.index(max(dots))
delta = np.zeros(len(path[-1]))
for i in range(0, len(evecs)):
# Change the sign of the step
# along the minimum mode
sign = 1
if i == 0 or i == imax: sign = -1
# Move according to newton raphson
delta -= evecs[i] * np.dot(g, evecs[i]) * sign / evals[i]
# Impose max step size
if la.norm(delta) > 0.1:
delta = 0.1 * delta / la.norm(delta)
path.append(path[-1] + delta)
return path
def main():
t1 = datetime.datetime.now()
''' Modify these values to choose fidelity level
and modeling method '''
# FIDELITY LEVEL: low = 0; med = 1; high = 2
fidelity_level = 2 # 0 or 2 atm.
# MODEL METHOD
model_method = 'k' # k or ck
# ALLOWED TIME (s)
hours = 1.
mins = 30.
secs = 0.
time = hours*60*60 + mins*60 + secs
#
fidelity_method = [fidelity_level, model_method]
from_file = False
nexus = setup(fidelity_method)
optprob = nexus.optimization_problem
surr = nexus.surrogate_data
# surr.plot_from_file(nexus,filename)
# quit()
inpstr = optprob.inputs[:,0]
objstr = optprob.objective[:,0]
print "inputs" + str(inpstr)
print 'object' + str(objstr)
inputstring=''
for var in inpstr:
if not inputstring == '':
if var == 'rcp_tip':
contr = 'tp'
elif var == 'dihedral':
contr = 'do'
else:
contr = var[0:2]
inputstring = inputstring+contr
else:
inputstring = var
savename = model_method+str(fidelity_level)+'-' +'30km'+'2-'+ inputstring+'-'
print 'Files will be saved under prefix : \"' + savename +'\"'
t1b = datetime.datetime.now()
optprob.inputs[:,1] = [20., 0.05]
print nexus.objective()
quit()
if model_method == 'k' and not from_file:
# a = nexus.objective()
surr.sample_plan.size = 40
surr.sample_plan.lhc_type = 'o'
surr.sample_plan.time = time
# surr.create_sample(nexus) # DO THIS JUST FOR CORNERS
# t1b = datetime.datetime.now()
data1 = np.genfromtxt('./rawresults/kriging/k2-30km2-spantp-data.csv',delimiter=',')
# surr.sample_plan.lhc = data1[:,0:2]
surr.X = data1[:,0:2]
surr.y = data1[:,2:4]
# data1 = data1[:,0:2]
# data2 = np.genfromtxt('./results/lfhf/k20-2km25-sptp-exp.csv',delimiter=',')
# surr.sample_plan.lhc = data[0:5,:]
# surr.sample_plan.lhc = np.array([[5.0, 0.1],[5.0, 1.0], [20.0,0.1],[20.0,1.0]]) # span taper
# surr.sample_plan.lhc = np.array([[5, 0.1, 0],[5, 0.1, 45],[5, 1, 0],[5, 1, 45],[20, 0.1, 0],[20, 0.1, 45],[20, 1, 0],[20, 1, 45]])
# surr.sample_plan.lhc = data1[24:30,:]
# data2 = data1[30:36,:]
# data3 = data1[36:44,:]
# print surr.sample_plan.lhc
# quit()
# surr.evaluate_of(nexus)
t2a = datetime.datetime.now()
surr.single_fid_kriging(nexus, improve=False)
# k0 = kriging(data1[:,0:2],data1[:,2])
# k1 = kriging(data2[:,0:2],data2[:,2])
# k0.train()
# k1.train()
k0 = surr.model0
k1 = surr.model1
if len(inpstr) <= 2:
surr.get_plot(nexus,model = k0,zlabel='L/D',mapname='winter')
surr.get_plot(nexus,model = k1,zlabel='Mass(kg)',mapname='copper')
elif len(inpstr) == 3:
surr.get_plot3X(nexus,model=k1,zlabel='L/D',mapname='winter')
surr.get_plot3X(nexus,model=k2,zlabel='Mass (kg)',mapname='copper')
saveModel(surr.model0,'./rawresults/kriging/'+savename+str(t2a)+'-surrmod0'+'.pkl')
saveModel(surr.model1,'./rawresults/kriging/'+savename+str(t2a)+'-surrmod1'+'.pkl')
t2b = datetime.datetime.now()
# quit()
with open('./rawresults/kriging/'+savename+str(t2b)+'-lhc'+str(np.shape(surr.X))+'.csv','w+b') as filec:
wrc=csv.writer(filec)
for i in range(0,np.shape(surr.X)[0]):
row = []
for item in surr.X[i,:]:
row.append(item)
row.append(surr.y[i,0])
row.append(surr.y[i,1])
wrc.writerow(row)
# surr.sample_plan.lhc = data2
# print surr.sample_plan.lhc
# quit()
# surr.evaluate_of(nexus)
# t2b = datetime.datetime.now()
## quit()
# with open('./rawresults/kriging/'+savename+str(t2b)+'-lhc'+str(surr.sample_plan.size)+'.csv','w+b') as filec:
# wrc=csv.writer(filec)
# for i in range(0,np.shape(surr.X)[0]):
# row = []
# for item in surr.X[i,:]:
# row.append(item)
# row.append(surr.y[i,0])
# row.append(surr.y[i,1])
# wrc.writerow(row)
# surr.sample_plan.lhc = data3
# surr.evaluate_of(nexus)
# t2b = datetime.datetime.now()
# with open('./rawresults/kriging/'+savename+str(t2b)+'-lhc'+str(surr.sample_plan.size)+'.csv','w+b') as filec:
# wrc=csv.writer(filec)
# for i in range(0,np.shape(surr.X)[0]):
# row = []
# for item in surr.X[i,:]:
# row.append(item)
# row.append(surr.y[i,0])
# row.append(surr.y[i,1])
# wrc.writerow(row)
# quit()
ke = surr.model0
km = surr.model1
# if len(inpstr) <= 3:
# surr.get_plot(nexus,model=ke,zlabel='L/D',mapname='winter')#surr.modelck0)
# surr.get_plot(nexus,model=km,zlabel='Mass (kg)',mapname='copper')
# quit()
t2 = datetime.datetime.now()
iw = optimizer(nexus,'k')
# quit()
iw.evolve()
t3 = datetime.datetime.now()
iw.show_results(title='Pareto-front')
iw.show_gen_results()
iw.save_results(name = './rawresults/kriging/'+savename+'-lhc'+str(surr.sample_plan.size)+'_opt')
print 'For LHC size: ' + str(np.shape(surr.X))
print 'Setup time = ' + str((t1b-t1).total_seconds()) + ' sec'
print 'Model runs time = ' + str((t2a-t1b).total_seconds()) + ' sec'
print 'Optimisation time = ' + str((t3-t2b).total_seconds()) + ' sec'
print '\n\n Kriging model info:\n'
print 'Thetas L/D : ' + str(surr.model0.theta)
print 'Thetas mass: ' + str(surr.model1.theta)
print 'p L/D : ' + str(surr.model0.pl)
print 'p mass: ' + str(surr.model1.pl)
#####################################################################
elif model_method == 'ck' and not from_file:
surr.sample_plan.lhc_type = 'o'
surr.sample_plan.time = time
t2a = surr.hybrid_cokriging(nexus,'./rawresults/cokriging'+savename)
# surr.save_ck('./results/'+savename+'cokriging') # should be unnecessary
t2 = datetime.datetime.now()
# plotting methods
if len(inpstr) <= 2:
try:
surr.get_plot(nexus,model=surr.model1, model1=surr.modelck0,zlabel='L/D') # mod1 is l/d
except:
print 'no second l/d model?'
try:
surr.get_plot(nexus,model=surr.modelck0) # just plot ck model
except:
print 'no models?'
iw = optimizer(nexus,'ck')
iw.evolve()
iw.show_results(title='')
iw.show_gen_results()
iw.save_results(name = './rawresults/cokriging/'+savename+'opt')
# quit()
######################### FROM FILE
elif model_method == 'ck' and from_file:
# surr.load_ck() # no .pkl
# surr.model999 = loadModel() # pykriging built, need .pkl
surr.load_ck('./results/lfhf/k20ck2-2km25-spantp-cokriging-verysmall')
datac = np.genfromtxt('./results/lfhf/k20-2km25-sptp-cheap-verysmall.csv',delimiter=',')
datae = np.genfromtxt('./results/lfhf/k20-2km25-sptp-exp-verysmall.csv',delimiter=',')
# datae = np.genfromtxt('./results/lfhf/k20-2km25-sptp-exp.csv',delimiter=',')
# k1 = loadModel('./krigingres/avl/k1-2km25-spantp-surrmod0.pkl')
# print k0.theta
# print k1.theta
ck0 = surr.modelck0
# k0 = kriging(datac[:,0:2],datac[:,2])
# k0.train()
# km = kriging(datac[:,0:2],datac[:,3])
# km.train()
# saveModel(km,'./results/lfhf/k20ck2-2km25-spantp-cokriging-verysmall.pkl')
# surr.model0 = k0
k1 = kriging(datae[:,0:2],datae[:,2])
k1.train()
# surr.model1 = k1
t2 = datetime.datetime.now()
a = ck0.predict([7.8,0.38])
b = k1.predict([7.8,0.38])
# surr.get_plot(nexus,model=ck0,zlabel='L/D',mapname='winter')
iw = optimizer(nexus,'k')
# if len(inpstr) <= 2:
surr.get_plot(nexus,model=k1,model1=ck0,zlabel='L/D',mapname='winter')#model1=k1,
## surr.get_plot(nexus,model=k1,model1=ck0,zlabel='L/D')
## surr.get_plot(nexus,model=ke,model1=surr.modelck0,zlabel='L/D')
# elif len(inpstr) <= 3:
# surr.get_plot3X(nexus,model=k, model1=surr.modelck0)
quit()
iw.evolve()
iw.show_results(title='')
iw.show_gen_results()
iw.save_results(name = './rawresults/cokriging/ck2-30km2-'+inputstring)
######################### FROM FILE
elif model_method == 'k' and from_file:
p1 = [6., .4, 30.]
p2 = [12., .6, 15.]
p3 = [17., .2, 47.]
p4 = [8., .8, 8.]
# m10 = loadModel('../results/studies/k0-30km2-lhc10-spantpsw-surrmod0.pkl')
# m20 = loadModel('../results/studies/k0-30km2-spantpsw--lhc20-surrmod0.pkl')
# m30 = loadModel('../results/studies/k0-30km2-spantpsw--lhc30-surrmod0.pkl')
# m40 = loadModel('../results/studies/k0-30km2-spantpsw--lhc40-surrmod0.pkl')
# m50 = loadModel('../results/studies/k0-30km2-spantpsw--lhc50-surrmod0.pkl')
d1 = np.genfromtxt('./rawresults/kriging/k2-30km2-spantpsw-lhc22x3.csv',delimiter=',')
d2 = np.genfromtxt('./rawresults/kriging/k2-30km2-spantpsw-lhc28x3.csv',delimiter=',')
dx1 = d1[:,0:3]
dy1 = d1[:,3:5]
dx2 = d2[:,0:3]
dy2 = d2[:,3:5]
m10 = kriging(dx1,dy1[:,0])
m10.train()
k1m = kriging(dx1,dy1[:,1])
m20 = kriging(dx2,dy2[:,0])
m20.train()
k2m = kriging(dx2,dy2[:,1])
# m10 = loadModel('./rawresults/kriging/k2-30km2-spantpsw-lhc22x3.pkl')
# k1m = loadModel('./rawresults/kriging/k2-30km2-spantpsw-lhc22x3-mass.pkl')
# m20 = loadModel('./rawresults/kriging/k2-30km2-spantpsw-lhc28x3.pkl')
# k2m = loadModel('./rawresults/kriging/k2-30km2-spantpsw-lhc28x3-mass.pkl')
print '\n\n Kriging model info:\n'
print 'For LHC size: ' + str('12,3')
print 'Thetas L/D : ' + str(m10.theta)
print 'Thetas mass: ' + str(k1m.theta)
print 'p L/D : ' + str(m10.pl)
print 'p mass: ' + str(k1m.pl)
print 'For LHC size: ' + str('18,3')
print 'Thetas L/D : ' + str(m20.theta)
print 'Thetas mass: ' + str(k2m.theta)
print 'p L/D : ' + str(m20.pl)
print 'p mass: ' + str(k2m.pl)
# optprob.inputs[:,1] = p1
# p1o = nexus.objective()
# optprob.inputs[:,1] = p2
# p2o = nexus.objective()
# optprob.inputs[:,1] = p3
# p3o = nexus.objective()
# optprob.inputs[:,1] = p4
# p4o = nexus.objective()
# print p4o
# quit()
print '==='+str(p1)
print 'corel: ' + str(-8.758738709620385)
print m10.predict(p1)
print m20.predict(p1)
# print m30.predict(p1)
# print m40.predict(p1)
# print m50.predict(p1)
#
print '==='+str(p2)
print 'corel: ' + str(-1.7228475920765616)
print m10.predict(p2)
print m20.predict(p2)
# print m30.predict(p2)
# print m40.predict(p2)
# print m50.predict(p2)
print '==='+str(p3)
print 'corel: ' + str(-4.1441922666)
print m10.predict(p3)
print m20.predict(p3)
# print m30.predict(p3)
# print m40.predict(p3)
# print m50.predict(p3)
print '==='+str(p4)
print 'corel: ' + str(-5.2278043817745)
print m10.predict(p4)
print m20.predict(p4)
# print m30.predict(p4)
# print m40.predict(p4)
# print m50.predict(p4)
return
from pyKriging.samplingplan import samplingplan
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(15)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin
# We generate our observed values based on our sampling plan and the test function
y = testfun(X)
print('Setting up the Kriging Model')
# Now that we have our initial data, we can create an instance of a kriging model
k = kriging(X, y, testfunction=testfun, name='simple', testPoints=250)
k.train(optimizer='ga')
k.snapshot()
for i in range(5):
newpoints = k.infill(2)
for point in newpoints:
print(('Adding point {}'.format(point)))
k.addPoint(point, testfun(point)[0])
k.train()
k.snapshot()
# #And plot the model
print('Now plotting final results...')
k.plot()
def single_fid_kriging(self, nexus, improve=False):
print "Generating kriging model ..."
"""
single_fidelity_kriging
obj_choice = choice of objective to generate model, 0 for first/default
subsequent functions for others.
At the moment this is only single fidelity kriging.
Will look into allowing both co-kriging and heirarchical kriging
Option = 'heirarchical' or 'hk', and 'cokriging', 'co-kriging'
or 'ck'
"""
if not isinstance(self.y, np.ndarray):
y = np.array(self.y)
else:
y = self.y
if len(y[0, :]) > 1:
two_mod = True
else:
two_mod = False
# check input types
if not isinstance(self.X, np.ndarray):
X = np.array(self.X)
else:
X = self.X
if two_mod:
y0 = y[:, 0]
y1 = y[:, 1]
else:
y0 = y
# print '\n ================= \n'
# print X
# print y
of = self.objective_function
tk1 = time.time()
k0 = kriging(X, y0)
k0.train()
print 'First training: model 0'
if two_mod:
k1 = kriging(X, y1)
k1.train()
print 'First training: model 1'
tk2 = time.time()
# print k.X
# print k.y
print 'Kriging model initial setup time : ' + str(tk2 - tk1) + ' sec'
# We need to check before we update (getting an uninvertible numpy matrix :/ )
# Method 1: remove a point and compare its original predicted value with k_red.predict(x)
# check = self.kriging_model_check(k)
# Method 2: make a new point
checkpt1 = self.scale_points(k0.X.mean(0), nexus)
checkpt2 = self.scale_points(k0.X[0:np.shape(X)[0] / 2, :].mean(0),
nexus)
if improve:
ei = np.minimum(k0.expimp(checkpt1), k0.expimp(checkpt2))
else:
ei = 1.e-10
counter = 0
gain_small = False
print 'precheck : ' + str(ei)
while ei >= 1.e-4 and not gain_small and counter <= 5: # and improve:# guarantees a few updates
print 'Kriging infill iteration ' + str(counter)
newpoints = k0.infill(1) # this is being a wild prick >:(
# print 'are these reasonable' +str(newpoints)
ei = k0.expimp(newpoints)
print 'Expected Improvement : EI(x) = ' + str(ei)
if ei < 1e-4:
gain_small = True
else:
for point in newpoints:
value = of(point, nexus, -1)
# print "\n\n value ===== " + str(value)
if len(value[0]) > 1:
obj_0 = value[0][0]
obj_1 = value[0][1]
else:
obj_0 = value[0]
if value[1] == 0:
k0.addPoint(point, obj_0)
k0.train()
if len(value[0]) > 1 and two_mod:
k1.addPoint(point, obj_1)
k1.train()
counter = counter + 1
tk3 = time.time()
print 'Exit criteria: gain_small = ' + str(
gain_small) + ' counter = ' + str(counter) + '/10'
print 'Kriging model improvement time : ' + str(tk3 - tk2) + ' sec'
print 'Total time : ' + str(tk3 - tk1) + ' sec'
self.model0 = k0
print 'model 0 added'
if two_mod:
self.model1 = k1
print 'model 1 added'
return #k
import unittest import numpy as np import pdb from geomdl import BSpline from geomdl import exchange from geomdl.visualization import VisMPL as vis import pyKriging from pyKriging import matrixops from pyKriging import samplingplan as sp from geomdl import utilities from pyKriging.krige import kriging from matplotlib import cm from mpl_toolkits.mplot3d import Axes3D import matplotlib.pyplot as plt from matplotlib.ticker import LinearLocator, FormatStrFormatter xt = np.array([[0.], [1.], [2.], [3], [4.]]) yt = np.array([0., 1., 1.5, 0.5, 1.0]) # krig_cube = kriging(self.X, self.y, testfunction=none, reg='Cubic') krig_cube = kriging(xt, yt) krig_cube.train() # And plot the results krig_cube.plot1d() krig_cube.plot_likelihood1d() # krig_cube.plot_trend() # krig_cube.plot_rad() pdb.set_trace()
def AK_MCS(S1, S2, N1, S0):
"""main function for AK-MCS: active learning method based on meta-model kriging
with simulation of Monte Carlo
S1: first selection population in Monte Carlo to construct the meta-model
S2: explained before
S0: the whole population generated by Monte Carlo
return
pf_matrix: the list of all calculated probabilities in every loop
ev_matrix: the list of all evaluation value of performance function by meta-model
U_min: the list of all minimum learning functions U in every loop
return them for the data treatment"""
def calcul_prob(S0):
"""calculate the probability of failure by evaluating the sign of evaluation value"""
S_NEG = []
S_POS = []
for s in S0:
ev_s = k.predict(s)
if ev_s<=0:
S_NEG.append(s)
else:
S_POS.append(s)
pf = float(len(S_NEG))/float(len(S0))
print("failure probability= "+str(pf))
return pf, S_POS, S_NEG
def calcul_u(s):
"""calculate the learning funtion U"""
ev_s = k.predict(s)
sigma = math.sqrt(k.predict_var(s)) # k.predict_var si the variance of kriging
u = abs(ev_s)/sigma
return sigma, u, ev_s
Y1 = []
for i in range(N1):
s1 = S1[i]
y1 = volkersen(s1)
Y1.append(y1)
k = kriging(S1, Y1, name='simple')
k.train()
k.plot()
ev_matrix = [k.predict(s) for s in S1]
# ********************************** PLOT ************************************#
print("\n**** Initialization ****")
NEW_S1 = S1
NEW_S2 = S2
# calculate failure probability
pf_matrix = []
pf, S_POS, S_NEG = calcul_prob(S0)
pf_matrix.append(pf)
plot_prob(S_POS,S_NEG, S1)
# ******************************* ITERATION **********************************#
u_min = 1.9 #in case of the initial u_min > 5
iteration = 0
U_min = []
while u_min < 2.:
S1 = NEW_S1
S2 = NEW_S2
U = []
G = []
iteration += 1
print("\n**** iteration number: "+str(iteration)+ "****")
for j in range(0, len(S2), 1):
s2 = S2[j]
sigma, u, ev_s = calcul_u(s2)
U.append(u)
G.append(ev_s)
u_min = min(U)
ind_s2min = U.index(u_min)
G_add = G[ind_s2min]
ev_matrix.append(G_add)
U_min.append(u_min)
print("learning function U : ", u_min)
add_s = S2[ind_s2min]
NEW_S1 = np.append(S1,[add_s],axis=0)
print("thickness and moudul: ", add_s)
print("number of construction ponits: "+str(len(NEW_S1)))
NEW_S2 = np.delete(S2,ind_s2min,axis=0)
# print("add_s= "+str(add_s))
y1 = volkersen(add_s)
Y1.append(y1)
k.addPoint(add_s,y1)
k.train()
#k.plot(show=True)
# calculate failure probability
pf, S_POS, S_NEG = calcul_prob(S0)
# plot figures
plot_prob(S_POS, S_NEG, NEW_S1, [add_s])
pf_matrix.append(pf)
'''X_plot1 = np.arange(-3., 3.1, 0.1)
X_plot2 = []
nPlot = len(X_plot1)
for i in range(nPlot):
Y_SOL = []
for j in range(nPlot):
s_predict = [X_plot1[i],X_plot1[j]]
y_sol = k.predict(s_predict)
Y_SOL.append(y_sol)
POLY = np.polyfit(X_plot1, Y_SOL,3) # coefficient
#print(POLY)
x_sol = root(funcSolPoly, 0.)
# print("x_sol= "+str(x_sol.x[0]))
X_plot2.append(x_sol.x[0])
plotFunction(X_plot1, X_plot2, 'c-', 'Kriging model')
if iteration >= 2 and pf_matrix[iteration-1] == pf_matrix[iteration-2]:
break'''
# print(ev_matrix)
return pf_matrix, ev_matrix, U_min
#!/usr/bin/env python
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(2)
X = sp.optimallhc(20)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().branin
y = testfun(X)
# Now that we have our initial data, we can create an instance of a Kriging model
k = kriging(X, y, testfunction=testfun, name='simple')
k.train()
# Now, five infill points are added. Note that the model is re-trained after each point is added
numiter = 5
for i in range(numiter):
print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
newpoints = k.infill(1)
for point in newpoints:
k.addPoint(point, testfun(point)[0])
k.train()
# And plot the results
k.plot()
return X, Y
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
sp = samplingplan(3)
X = sp.optimallhc(30)
print("[DEBUG] X: {}".format(X))
# Next, we define the problem we would like to solve
testfun = testfunctions().squared
y = testfun(X)
# Now that we have our initial data, we can create an instance of a kriging model
k = kriging(X, y, testfunction=testfun, testPoints=300)
# The model is then trained
k.train()
k.snapshot()
# It's typically beneficial to add additional points based on the results of the initial training
# The infill method can be used for this
# In this example, we will add nine points in three batches. The model gets trained after each stage
for i in range(10):
print(k.history['rsquared'][-1])
print('Infill iteration {0}'.format(i + 1))
infillPoints = k.infill(10)
# Evaluate the infill points and add them back to the Kriging model
for point in infillPoints:
def interpGrid(self):
ptx = np.array(self.x)
pty = np.array(self.y)
z = np.array(self.z)
print(len(ptx), 'length x')
# remove duplicate x values
dups = self.checkdups(self.x)
ptx = np.delete(ptx, dups)
pty = np.delete(pty, dups)
z = np.delete(z, dups)
print(len(ptx), 'length x')
pts = zip(self.x, self.y)
# gridx, gridy = np.mgrid[uprLeft[0]:lwrRight[0]:50j,uprLeft[1]:lwrRight[1]:50j]
gridx, gridy = np.mgrid[self.ext[0]:self.ext[1]:self.ncol*1j,
self.ext[2]:self.ext[3]:self.nrow*1j]
##### using griddata #####
if self.interptype == 'griddata':
from scipy.interpolate import griddata
self.grid = griddata(pts,self.z,(gridx,gridy), method='cubic',fill_value=-3e30)
#### examples from
##### http://stackoverflow.com/questions/24978052/interpolation-over-regular-grid-in-python
##### using radial basis function ####
if self.interptype == 'rbf':
import scipy.interpolate as interpolate
f = interpolate.Rbf(pty, ptx, z, function='linear')
self.grid = f(gridy, gridx)
##### using kriging ####
if self.interptype == 'gauss':
from sklearn.gaussian_process import GaussianProcess
# print math.sqrt(np.var(z))
# gp = GaussianProcess(theta0=0.1, thetaL=1.1, thetaU=10.1, nugget=0.000001)
if np.min(z) <= 0:
thetaL = 0.1
else:
thetaL = np.min(z)
print(np.min(z), thetaL, np.max(z))
# gp = GaussianProcess(regr='quadratic',corr='cubic',theta0=np.min(z),thetaL=thetaL,thetaU=np.max(z),nugget=0.05)
gp = GaussianProcess(theta0=500,thetaL=100,thetaU=2000)
gp.fit(X=np.column_stack([pty,ptx]),y=z)
rr_cc_as_cols = np.column_stack([gridy.flatten(), gridx.flatten()])
self.grid = gp.predict(rr_cc_as_cols).reshape((self.ncol,self.nrow))
if self.interptype == 'krig':
import pyKriging
from pyKriging.krige import kriging
from pyKriging.samplingplan import samplingplan
# The Kriging model starts by defining a sampling plan, we use an optimal Latin Hypercube here
# sp = samplingplan(2)
# X = sp.optimallhc(20)
# print(X)
X = np.array(zip(self.x, self.y))
print(X.shape)
# Next, we define the problem we would like to solve
testfun = pyKriging.testfunctions().squared
# y = testfun(X)
# print(y)
y = self.z
# Now that we have our initial data, we can create an instance of a Kriging model
k = kriging(X, y)#, testfunction=testfun, name='simple')
# k.train()
# Now, five infill points are added. Note that the model is re-trained after each point is added
# numiter = 5
# for i in range(numiter):
# print 'Infill iteration {0} of {1}....'.format(i + 1, numiter)
# newpoints = k.infill(1)
# for point in newpoints:
# k.addPoint(point, testfun(point)[0])
# k.train()
# And plot the results
k.plot()
sys.exit()
self.grid[self.grid < self.minval] = -2.99999989403e+030 #self.minval
self.grid = np.flipud(self.grid.T)
