def __init__(self,
nvar,
krigobj=None,
problem=None,
ub=None,
lb=None,
nMC=2e5):
"""
Initialize model
Args:
nvar (int): Number of variables.
krigobj (object): Kriging object, default to None.
problem (str/callable/None): problem type, default to None.
"""
self.nvar = nvar
self.krigobj = krigobj
self.problem = problem
self.n = int(nMC)
if ub is not None and lb is not None:
_, init_mat = sampling("sobolnew",
self.nvar * 2,
self.n,
result="real",
upbound=ub,
lobound=lb)
else:
init_mat, _ = sampling("sobolnew", self.nvar * 2, self.n)
self.A = init_mat[:, :self.nvar]
self.B = init_mat[:, self.nvar:]
del init_mat
self.ya = None
self.yb = None
self.fo_2 = None
self.denom = None
def generate_kriging(n_cpu):
# Initialization
KrigInfo = dict()
kernel = ["gaussian"]
# Sampling
nsample = 40
nvar = 2
ub = np.array([5, 5])
lb = np.array([-5, -5])
nup = 3
sampoption = "halton"
samplenorm, sample = sampling(sampoption,
nvar,
nsample,
result="real",
upbound=ub,
lobound=lb)
X = sample
# Evaluate sample
y1 = evaluate(X, "styblinski")
# Initialize KrigInfo
KrigInfo = initkriginfo()
# Set KrigInfo
KrigInfo["X"] = X
KrigInfo["y"] = y1
KrigInfo["nvar"] = nvar
KrigInfo["problem"] = "styblinski"
KrigInfo["nsamp"] = nsample
KrigInfo["nrestart"] = 7
KrigInfo["ub"] = ub
KrigInfo["lb"] = lb
KrigInfo["kernel"] = kernel
KrigInfo["TrendOrder"] = 0
KrigInfo["nugget"] = -6
# KrigInfo["n_princomp"] = 1
KrigInfo["kernel"] = ["gaussian"]
KrigInfo["nkernel"] = len(KrigInfo["kernel"])
KrigInfo["optimizer"] = "lbfgsb"
# Run Kriging
t = time.time()
krigobj = Kriging(KrigInfo,
standardization=True,
standtype="default",
normy=False,
trainvar=False)
krigobj.train(n_cpu=n_cpu)
loocverr, _ = krigobj.loocvcalc()
elapsed = time.time() - t
print("elapsed time for train Kriging model: ", elapsed, "s")
print("LOOCV error of Kriging model: ", loocverr, "%")
return krigobj
def generate_kriging(n_cpu):
# Sampling
nsample = 20
nvar = 2
nobj = 2
lb = -1 * np.ones(shape=[nvar])
ub = 1 * np.ones(shape=[nvar])
sampoption = "halton"
samplenorm, sample = sampling(sampoption,
nvar,
nsample,
result="real",
upbound=ub,
lobound=lb)
X = sample
# Evaluate sample
global y
y = myproblem(X)
# Initialize KrigInfo
KrigInfo1 = initkriginfo()
# Set KrigInfo
KrigInfo1["X"] = X
KrigInfo1["y"] = y[:, 0].reshape(-1, 1)
KrigInfo1["problem"] = myproblem
KrigInfo1["nrestart"] = 5
KrigInfo1["ub"] = ub
KrigInfo1["lb"] = lb
KrigInfo1["optimizer"] = "lbfgsb"
# Initialize KrigInfo
KrigInfo2 = deepcopy(KrigInfo1)
KrigInfo2['y'] = y[:, 1].reshape(-1, 1)
# Run Kriging
krigobj1 = Kriging(KrigInfo1,
standardization=True,
standtype='default',
normy=False,
trainvar=False)
krigobj1.train(n_cpu=n_cpu)
loocverr1, _ = krigobj1.loocvcalc()
print("LOOCV error of Kriging model: ", loocverr1, "%")
krigobj2 = Kriging(KrigInfo2,
standardization=True,
standtype='default',
normy=False,
trainvar=False)
krigobj2.train(n_cpu=n_cpu)
loocverr2, _ = krigobj2.loocvcalc()
print("LOOCV error of Kriging model: ", loocverr2, "%")
return krigobj1, krigobj2
def predictkrig(krigobj):
nsample = 25
nvar = 2
ub = np.array([5, 5])
lb = np.array([-5, -5])
nup = 3
sampoption = "halton"
# Test Kriging Output
neval = 10000
samplenormout, sampleeval = sampling(sampoption,
nvar,
neval,
result="real",
upbound=ub,
lobound=lb)
xx = np.linspace(-5, 5, 100)
yy = np.linspace(-5, 5, 100)
Xevalx, Xevaly = np.meshgrid(xx, yy)
Xeval = np.zeros(shape=[neval, 2])
Xeval[:, 0] = np.reshape(Xevalx, (neval))
Xeval[:, 1] = np.reshape(Xevaly, (neval))
# Evaluate output
yeval = np.zeros(shape=[neval, 1])
yact = np.zeros(shape=[neval, 1])
yeval, ssqr = krigobj.predict(Xeval, ["pred", "ssqr"])
yact = evaluate(Xeval, "styblinski")
hasil = np.hstack((yeval, yact))
# Evaluate RMSE
subs = np.transpose((yact - yeval))
subs1 = np.transpose((yact - yeval) / yact)
RMSE = np.sqrt(np.sum(subs**2) / neval)
RMSRE = np.sqrt(np.sum(subs1**2) / neval)
MAPE = 100 * np.sum(abs(subs1)) / neval
print("RMSE = ", RMSE)
print("RMSRE = ", RMSRE)
print("MAPE = ", MAPE, "%")
yeval1 = np.reshape(yeval, (100, 100))
x1eval = np.reshape(Xeval[:, 0], (100, 100))
x2eval = np.reshape(Xeval[:, 1], (100, 100))
fig = plt.figure()
ax = fig.gca(projection="3d")
surf = ax.plot_surface(x1eval,
x2eval,
yeval1,
cmap=cm.coolwarm,
linewidth=0,
antialiased=False)
plt.show()
def generate_kriging(n_cpu):
# Sampling
nsample = 10
nvar = 2
lb = np.array([-5, -5])
ub = np.array([5, 5])
sampoption = "halton"
samplenorm, sample = sampling(sampoption,
nvar,
nsample,
result="real",
upbound=ub,
lobound=lb)
X = sample
# Evaluate sample
# global y
y = evaluate(X, "styblinski")
# Initialize KrigInfo
# global KrigInfo
KrigInfo = initkriginfo()
# Set KrigInfo
KrigInfo["X"] = X
KrigInfo["y"] = y
KrigInfo["problem"] = "styblinski"
KrigInfo["nrestart"] = 5
KrigInfo["ub"] = ub
KrigInfo["lb"] = lb
KrigInfo["optimizer"] = "lbfgsb"
# Run Kriging
krigobj = Kriging(KrigInfo,
standardization=True,
standtype='default',
normy=False,
trainvar=False)
krigobj.train(n_cpu=n_cpu)
loocverr, _ = krigobj.loocvcalc()
print("LOOCV error of Kriging model: ", loocverr, "%")
return krigobj
def train(self, parallel=False, disp=True, KPCAkernel="poly"):
"""
Train Kriging model
Args:
parallel (bool): Parallel processing or not. Default to False.
disp (bool): Display process or not. Default to True.
Returns:
None
"""
# Create starting points
if KPCAkernel.lower() == 'poly':
upwstart = np.array([2.5, 2.5, 7])
lowwstart = np.array([-1, -1, 1])
_, wstart = sampling('sobol',
len(upwstart),
1,
result="real",
upbound=upwstart,
lobound=lowwstart)
# wstart = np.array([0,0,0])
elif KPCAkernel.lower() == 'sigmoid':
upwstart = np.array([2.5, 2.5])
lowwstart = np.array([-2, -2])
wstart = np.array([0, 0])
elif KPCAkernel.lower() == 'rbf':
upwstart = np.array([1.5])
lowwstart = np.array([-0.5])
wstart = np.array([0])
elif KPCAkernel.lower() == 'gaussian':
upwstart = np.array([1.5] * self.KrigInfo["nvar"])
lowwstart = np.array([-0.5] * self.KrigInfo["nvar"])
wstart = np.array([0] * self.KrigInfo["nvar"])
elif KPCAkernel.lower() == 'linear':
upwstart = np.array([2.5])
lowwstart = np.array([-2])
wstart = np.array([0])
else:
raise ValueError(KPCAkernel.lower() +
" kernel option is not a valid kernel")
# Define hyperparams bounds
optimbound = np.transpose(np.vstack((lowwstart, upwstart)))
# Run optimization
print("Optimize Hyperparams")
if self.standardization is True:
original_X = self.KrigInfo['X_norm']
self.KrigInfo['orig_X'] = original_X
else:
original_X = self.KrigInfo['X']
self.KrigInfo['orig_X'] = original_X
res = minimize(self.kpcaopt,
wstart,
method='L-BFGS-B',
options={
'maxfun': 50,
'eps': 1e-4
},
bounds=optimbound,
args=(KPCAkernel, original_X))
wopt = res.x
drm, loocverr = self.kpcaopt(wopt, KPCAkernel, original_X, out='all')
self.KrigInfo['kpcaw'] = wopt
return drm, loocverr
def train(self, n_cpu=1, disp=True, pre_theta=None, pool=None):
"""
Train Kriging model
Args:
n_cpu (bool): If > 1, uses parallel processing. Defaults
to 1.
disp (bool, optional): Print updates. Defaults to False.
pre_theta #TODO: document this, if working.
pool (int, optional): A multiprocessing.Pool instance.
Will be passed to functions for use, if specified.
Defaults to None.
Returns:
None
"""
if disp:
print("Begin train hyperparam.")
# Isotropic gaussian kernel
if self.KrigInfo["kernel"] == ["iso_gaussian"
]: # TODO: Should this be in a list?
self.nbhyp = 1
elif len(self.KrigInfo["kernel"]
) != 1 and "iso_gaussian" in self.KrigInfo["kernel"]:
raise NotImplementedError(
"Isotropic Gaussian kernel is not available for composite kernel"
)
else:
if len(self.KrigInfo["ubhyp"]) != self.nbhyp:
self.nbhyp = len(self.KrigInfo["ubhyp"])
# Create multiple starting points
if self.KrigInfo['nrestart'] < 1:
xhyp = self.nbhyp * [0]
else:
if self.nbhyp <= 40:
_, xhyp = sampling('sobol',
len(self.KrigInfo["ubhyp"]),
self.KrigInfo['nrestart'],
result="real",
upbound=self.KrigInfo["ubhyp"],
lobound=self.KrigInfo["lbhyp"])
else:
_, xhyp = sampling('sobolnew',
len(self.KrigInfo["ubhyp"]),
self.KrigInfo['nrestart'],
result="real",
upbound=self.KrigInfo["ubhyp"],
lobound=self.KrigInfo["lbhyp"])
# multiple starting from pre-trained theta:
if pre_theta is not None:
xhyp = np.random.rand(self.KrigInfo['nrestart'] - 1,
len(self.KrigInfo["ubhyp"])) + pre_theta
xhyp = np.vstack((pre_theta, xhyp))
# Optimize hyperparam if number of hyperparameter is 1 using golden section method
if self.nbhyp == 1:
if self.KrigInfo["optimizer"] != "ga":
res = minimize_scalar(likelihood,
bounds=(self.lb, self.ub),
method='golden',
args=(self.KrigInfo, 'default',
self.trainvar))
if self.KrigInfo["kernel"] == ["iso_gaussian"]:
best_x = res.x
else:
best_x = np.array([res.x])
neglnlikecand = likelihood(best_x,
self.KrigInfo,
trainvar=self.trainvar)
else:
best_x, neglnlikecand, _ = uncGA(likelihood,
lb=self.lb,
ub=self.ub,
npop=100,
maxg=100,
args=(self.KrigInfo,
'default',
self.trainvar))
if disp:
print(f"Best hyperparameter is {best_x}")
print(f"With NegLnLikelihood of {neglnlikecand}")
else:
# Set Bounds and Constraints for Optimizer
# Set Bounds for LBSGSB or SLSQP if one is used.
if self.KrigInfo["optimizer"] == "lbfgsb" or self.KrigInfo[
"optimizer"] == "slsqp":
optimbound = np.transpose(
np.vstack(
(self.KrigInfo["lbhyp"], self.KrigInfo["ubhyp"])))
# Set Constraints for Cobyla if used
elif self.KrigInfo["optimizer"] == "cobyla":
optimbound = []
for i in range(len(self.KrigInfo["ubhyp"])):
# params aa and bb are not used, just to avoid error in Cobyla optimizer
optimbound.append(lambda x, Kriginfo, aa, bb, itemp=i: x[
itemp] - self.KrigInfo["lbhyp"][itemp])
optimbound.append(lambda x, Kriginfo, aa, bb, itemp=i: self
.KrigInfo["ubhyp"][itemp] - x[itemp])
else:
optimbound = None
if disp:
print(
f"Training {self.KrigInfo['nrestart']} hyperparameter(s)")
# Train hyperparams
bestxcand, neglnlikecand = self.parallelopt(xhyp,
n_cpu,
optimbound,
disp=disp,
pool=pool)
# Search best hyperparams among the candidates
I = np.argmin(neglnlikecand)
best_x = bestxcand[I, :]
if disp:
print("Single Objective, train hyperparam, end.")
print(f"Best hyperparameter is {best_x}")
print(f"With NegLnLikelihood of {neglnlikecand[I]}")
# Calculate Kriging model based on the best hyperparam.
self.KrigInfo = likelihood(best_x,
self.KrigInfo,
mode='all',
trainvar=self.trainvar)
multiupdate=5,
expconst=expconstlist,
chpconst=cheapconstlist)
xupdate, yupdate, supdate, metricall = mobo.run(disp=True)
return xupdate, yupdate, supdate, metricall
if __name__ == '__main__':
nsample = 20
nvar = 2
lb = np.array([0, 0])
ub = np.array([5, 3])
sampoption = "halton"
n_cpu = 12
samplenorm, sample = sampling(sampoption,
nvar,
nsample,
result="real",
upbound=ub,
lobound=lb)
X = sample
# Evaluate function
y = cust_func(X)
g = exp_const_eval(X)
# Create Kriging
kriglist, expconstlist = construct_krig(X, y, g, lb, ub, n_cpu)
# Optimize
xupdate, yupdate, supdate, metricall = optimize(kriglist, expconstlist)