def _compute_pls(self, X, y):
_pls = pls(self.options["n_comp"])
# As of sklearn 0.24.1 zeroed outputs raises an exception while sklearn 0.23 returns zeroed x_rotations
# For now the try/except below is a workaround to restore the 0.23 behaviour
try:
self.coeff_pls = _pls.fit(X.copy(), y.copy()).x_rotations_
except StopIteration:
self.coeff_pls = np.zeros((X.shape[1], self.options["n_comp"]))
return X, y
def _new_train_init(self):
if self.name in ["MFKPLS", "MFKPLSK"]:
_pls = pls(self.options["n_comp"])
# As of sklearn 0.24.1 PLS with zeroed outputs raises an exception while sklearn 0.23 returns zeroed x_rotations
# For now the try/except below is a workaround to restore the 0.23 behaviour
try:
# PLS is done on the highest fidelity identified by the key None
self.m_pls = _pls.fit(
self.training_points[None][0][0].copy(),
self.training_points[None][0][1].copy(),
)
self.coeff_pls = self.m_pls.x_rotations_
except StopIteration:
self.coeff_pls = np.zeros(
self.training_points[None][0][0].shape[1],
self.options["n_comp"])
xt = []
yt = []
i = 0
while self.training_points.get(i, None) is not None:
xt.append(self.training_points[i][0][0])
yt.append(self.training_points[i][0][1])
i = i + 1
xt.append(self.training_points[None][0][0])
yt.append(self.training_points[None][0][1])
self._check_list_structure(xt, yt)
self._check_param()
X = self.X
y = self.y
_, _, self.X_offset, self.y_mean, self.X_scale, self.y_std = standardization(
np.concatenate(xt, axis=0), np.concatenate(yt, axis=0))
nlevel = self.nlvl
# initialize lists
self.optimal_noise_all = nlevel * [0]
self.D_all = nlevel * [0]
self.F_all = nlevel * [0]
self.p_all = nlevel * [0]
self.q_all = nlevel * [0]
self.optimal_rlf_value = nlevel * [0]
self.optimal_par = nlevel * [{}]
self.optimal_theta = nlevel * [0]
self.X_norma_all = [(x - self.X_offset) / self.X_scale for x in X]
self.y_norma_all = [(f - self.y_mean) / self.y_std for f in y]
def standardize(self):
"""
Standardize Kriging samples and create regression matrix.
Returns:
None
"""
Kriging.standardize(self)
# Calculate PLS coeff
_pls = pls(self.n_princomp)
if self.standardization is True:
coeff_pls = _pls.fit(self.KrigInfo["X_norm"].copy(), self.KrigInfo['y'].copy()).x_rotations_
else:
coeff_pls = _pls.fit(self.KrigInfo["X"].copy(), self.KrigInfo['y'].copy()).x_rotations_
self.KrigInfo["plscoeff"] = coeff_pls
def _new_train_init(self):
xt = []
yt = []
i = 0
_pls = pls(self.options["n_comp"])
# PLS done on the highest fidelity identified by the key None
self.m_pls = _pls.fit(
self.training_points[None][0][0].copy(),
self.training_points[None][0][1].copy(),
)
self.coeff_pls = self.m_pls.x_rotations_
while self.training_points.get(i, None) is not None:
xt.append(self.training_points[i][0][0])
yt.append(self.training_points[i][0][1])
i = i + 1
xt.append(self.training_points[None][0][0])
yt.append(self.training_points[None][0][1])
self._check_list_structure(xt, yt)
self._check_param()
X = self.X
y = self.y
_, _, self.X_mean, self.y_mean, self.X_std, self.y_std = standardization(
np.concatenate(xt, axis=0), np.concatenate(yt, axis=0))
# self.X_mean, self.y_mean, self.X_std, \
# self.y_std = 0.,0.,1.,1.
nlevel = self.nlvl
# initialize lists
self.noise = nlevel * [0]
self.D_all = nlevel * [0]
self.F_all = nlevel * [0]
self.p_all = nlevel * [0]
self.q_all = nlevel * [0]
self.optimal_rlf_value = nlevel * [0]
self.optimal_par = nlevel * [{}]
self.optimal_theta = nlevel * [0]
self.X_norma_all = [(x - self.X_mean) / self.X_std for x in X]
self.y_norma_all = [(f - self.y_mean) / self.y_std for f in y]
def _new_train(self):
"""
Overrides KrgBased implementation
Trains the Multi-Fidelity model
"""
xt = []
yt = []
i = 0
_pls = pls(self.options['n_comp'])
self.m_pls = _pls.fit(self.training_points[None][0][0].copy(),
self.training_points[None][0][1].copy())
self.coeff_pls = self.m_pls.x_rotations_
while (self.training_points.get(i, None) is not None):
xt.append(self.training_points[i][0][0])
yt.append(self.training_points[i][0][1])
i = i + 1
xt.append(self.training_points[None][0][0])
yt.append(self.training_points[None][0][1])
self._check_list_structure(xt, yt)
self._check_param()
X = self.X
y = self.y
_, _, self.X_mean, self.y_mean, self.X_std, \
self.y_std = standardization(np.concatenate(xt,axis=0), np.concatenate(yt,axis=0))
# self.X_mean, self.y_mean, self.X_std, \
# self.y_std = 0.,0.,1.,1.
nlevel = self.nlvl
n_samples = self.nt_all
# initialize lists
self.noise = nlevel * [0]
self.D_all = nlevel * [0]
self.F_all = nlevel * [0]
self.p_all = nlevel * [0]
self.q_all = nlevel * [0]
self.optimal_rlf_value = nlevel * [0]
self.optimal_par = nlevel * [{}]
self.optimal_theta = nlevel * [0]
self.X_norma_all = [(x - self.X_mean) / self.X_std for x in X]
self.y_norma_all = [(f - self.y_mean) / self.y_std for f in y]
for lvl in range(nlevel):
self.X_norma = self.X_norma_all[lvl]
self.y_norma = self.y_norma_all[lvl]
# Calculate matrix of distances D between samples
self.D_all[lvl] = l1_cross_distances(self.X_norma)
# Regression matrix and parameters
self.F_all[lvl] = self.options['poly'](self.X_norma)
self.p_all[lvl] = self.F_all[lvl].shape[1]
# Concatenate the autoregressive part for levels > 0
if lvl > 0:
F_rho = self.options['rho_regr'](self.X_norma)
self.q_all[lvl] = F_rho.shape[1]
self.F_all[lvl] = np.hstack((F_rho * np.dot(
self._predict_intermediate_values(
self.X_norma, lvl, descale=False),
np.ones((1, self.q_all[lvl]))), self.F_all[lvl]))
else:
self.q_all[lvl] = 0
n_samples_F_i = self.F_all[lvl].shape[0]
if n_samples_F_i != n_samples[lvl]:
raise Exception("Number of rows in F and X do not match. Most "
"likely something is going wrong with the "
"regression model.")
if int(self.p_all[lvl] + self.q_all[lvl]) >= n_samples_F_i:
raise Exception(
("Ordinary least squares problem is undetermined "
"n_samples=%d must be greater than the regression"
" model size p+q=%d.") %
(n_samples[i], self.p_all[lvl] + self.q_all[lvl]))
# Determine Gaussian Process model parameters
self.F = self.F_all[lvl]
D, self.ij = self.D_all[lvl]
self._lvl = lvl
self.nt = self.nt_all[lvl]
self.q = self.q_all[lvl]
self.p = self.p_all[lvl]
self.optimal_rlf_value[lvl], self.optimal_par[lvl], self.optimal_theta[lvl] = \
self._optimize_hyperparam(D)
if self.options['eval_noise']:
tmp_list = self.optimal_theta[lvl]
self.optimal_theta[lvl] = tmp_list[:-1]
self.noise[lvl] = tmp_list[-1]
del self.y_norma, self.D
if self.options['eval_noise'] and self.options['optim_var']:
for lvl in range(self.nlvl - 1):
self.set_training_values(X[lvl],
self._predict_intermediate_values(
X[lvl], lvl + 1),
name=lvl)
self.set_training_values(
X[-1], self._predict_intermediate_values(X[-1], self.nlvl))
self.options['eval_noise'] = False
self._new_train()
def _compute_pls(self, X, y):
_pls = pls(self.options['n_comp'])
self.coeff_pls = _pls.fit(X.copy(), y.copy()).x_rotations_
return X, y
def ge_compute_pls(X, y, n_comp, pts, delta_x, xlimits, extra_points):
"""
Gradient-enhanced PLS-coefficients.
Parameters
----------
X: np.ndarray [n_obs,dim]
- - The input variables.
y: np.ndarray [n_obs,1]
- The output variable
n_comp: int
- Number of principal components used.
pts: dict()
- The gradient values.
delta_x: real
- The step used in the FOTA.
xlimits: np.ndarray[dim, 2]
- The upper and lower var bounds.
extra_points: int
- The number of extra points per each training point.
Returns
-------
Coeff_pls: np.ndarray[dim, n_comp]
- The PLS-coefficients.
XX: np.ndarray[extra_points*nt, dim]
- Extra points added (when extra_points > 0)
yy: np.ndarray[extra_points*nt, 1]
- Extra points added (when extra_points > 0)
"""
nt, dim = X.shape
XX = np.empty(shape=(0, dim))
yy = np.empty(shape=(0, 1))
_pls = pls(n_comp)
coeff_pls = np.zeros((nt, dim, n_comp))
for i in range(nt):
if dim >= 3:
sign = np.roll(bbdesign(int(dim), center=1), 1, axis=0)
_X = np.zeros((sign.shape[0], dim))
_y = np.zeros((sign.shape[0], 1))
sign = sign * delta_x * (xlimits[:, 1] - xlimits[:, 0])
_X = X[i, :] + sign
for j in range(1, dim + 1):
sign[:, j - 1] = sign[:, j - 1] * pts[None][j][1][i, 0]
_y = y[i, :] + np.sum(sign, axis=1).reshape((sign.shape[0], 1))
else:
_X = np.zeros((9, dim))
_y = np.zeros((9, 1))
# center
_X[:, :] = X[i, :].copy()
_y[0, 0] = y[i, 0].copy()
# right
_X[1, 0] += delta_x * (xlimits[0, 1] - xlimits[0, 0])
_y[1, 0] = _y[0, 0].copy() + pts[None][1][1][i, 0] * delta_x * (
xlimits[0, 1] - xlimits[0, 0]
)
# up
_X[2, 1] += delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[2, 0] = _y[0, 0].copy() + pts[None][2][1][i, 0] * delta_x * (
xlimits[1, 1] - xlimits[1, 0]
)
# left
_X[3, 0] -= delta_x * (xlimits[0, 1] - xlimits[0, 0])
_y[3, 0] = _y[0, 0].copy() - pts[None][1][1][i, 0] * delta_x * (
xlimits[0, 1] - xlimits[0, 0]
)
# down
_X[4, 1] -= delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[4, 0] = _y[0, 0].copy() - pts[None][2][1][i, 0] * delta_x * (
xlimits[1, 1] - xlimits[1, 0]
)
# right up
_X[5, 0] += delta_x * (xlimits[0, 1] - xlimits[0, 0])
_X[5, 1] += delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[5, 0] = (
_y[0, 0].copy()
+ pts[None][1][1][i, 0] * delta_x * (xlimits[0, 1] - xlimits[0, 0])
+ pts[None][2][1][i, 0] * delta_x * (xlimits[1, 1] - xlimits[1, 0])
)
# left up
_X[6, 0] -= delta_x * (xlimits[0, 1] - xlimits[0, 0])
_X[6, 1] += delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[6, 0] = (
_y[0, 0].copy()
- pts[None][1][1][i, 0] * delta_x * (xlimits[0, 1] - xlimits[0, 0])
+ pts[None][2][1][i, 0] * delta_x * (xlimits[1, 1] - xlimits[1, 0])
)
# left down
_X[7, 0] -= delta_x * (xlimits[0, 1] - xlimits[0, 0])
_X[7, 1] -= delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[7, 0] = (
_y[0, 0].copy()
- pts[None][1][1][i, 0] * delta_x * (xlimits[0, 1] - xlimits[0, 0])
- pts[None][2][1][i, 0] * delta_x * (xlimits[1, 1] - xlimits[1, 0])
)
# right down
_X[8, 0] += delta_x * (xlimits[0, 1] - xlimits[0, 0])
_X[8, 1] -= delta_x * (xlimits[1, 1] - xlimits[1, 0])
_y[8, 0] = (
_y[0, 0].copy()
+ pts[None][1][1][i, 0] * delta_x * (xlimits[0, 1] - xlimits[0, 0])
- pts[None][2][1][i, 0] * delta_x * (xlimits[1, 1] - xlimits[1, 0])
)
# As of sklearn 0.24.1 a zeroed _y raises an exception while sklearn 0.23 returns zeroed x_rotations
# For now the try/except below is a workaround to restore the 0.23 behaviour
try:
_pls.fit(_X.copy(), _y.copy())
coeff_pls[i, :, :] = _pls.x_rotations_
except StopIteration:
coeff_pls[i, :, :] = 0
# Add additional points
if extra_points != 0:
max_coeff = np.argsort(np.abs(coeff_pls[i, :, 0]))[-extra_points:]
for ii in max_coeff:
XX = np.vstack((XX, X[i, :]))
XX[-1, ii] += delta_x * (xlimits[ii, 1] - xlimits[ii, 0])
yy = np.vstack((yy, y[i, 0]))
yy[-1, 0] += (
pts[None][1 + ii][1][i, 0]
* delta_x
* (xlimits[ii, 1] - xlimits[ii, 0])
)
return np.abs(coeff_pls).mean(axis=0), XX, yy
