def run_mfk_example():
import numpy as np
import matplotlib.pyplot as plt
from smt.applications.mfk import MFK, NestedLHS
# low fidelity model
def lf_function(x):
import numpy as np
return (0.5 * ((x * 6 - 2)**2) * np.sin(
(x * 6 - 2) * 2) + (x - 0.5) * 10.0 - 5)
# high fidelity model
def hf_function(x):
import numpy as np
return ((x * 6 - 2)**2) * np.sin((x * 6 - 2) * 2)
# Problem set up
xlimits = np.array([[0.0, 1.0]])
xdoes = NestedLHS(nlevel=2, xlimits=xlimits)
xt_c, xt_e = xdoes(7)
# Evaluate the HF and LF functions
yt_e = hf_function(xt_e)
yt_c = lf_function(xt_c)
sm = MFK(theta0=np.array(xt_e.shape[1] * [1.0]))
# low-fidelity dataset names being integers from 0 to level-1
sm.set_training_values(xt_c, yt_c, name=0)
# high-fidelity dataset without name
sm.set_training_values(xt_e, yt_e)
# train the model
sm.train()
x = np.linspace(0, 1, 101, endpoint=True).reshape(-1, 1)
# query the outputs
y = sm.predict_values(x)
mse = sm.predict_variances(x)
derivs = sm.predict_derivatives(x, kx=0)
plt.figure()
plt.plot(x, hf_function(x), label="reference")
plt.plot(x, y, linestyle="-.", label="mean_gp")
plt.scatter(xt_e, yt_e, marker="o", color="k", label="HF doe")
plt.scatter(xt_c, yt_c, marker="*", color="g", label="LF doe")
plt.legend(loc=0)
plt.ylim(-10, 17)
plt.xlim(-0.1, 1.1)
plt.xlabel(r"$x$")
plt.ylabel(r"$y$")
plt.show()
def run_mfk_example_1fidelity():
import numpy as np
import matplotlib.pyplot as plt
from smt.applications.mfk import MFK, NestedLHS
# Consider only 1 fidelity level
# high fidelity model
def hf_function(x):
import numpy as np
return ((x * 6 - 2)**2) * np.sin((x * 6 - 2) * 2)
# Problem set up
xlimits = np.array([[0.0, 1.0]])
xdoes = NestedLHS(nlevel=1, xlimits=xlimits, random_state=0)
xt_e = xdoes(7)[0]
# Evaluate the HF function
yt_e = hf_function(xt_e)
sm = MFK(theta0=xt_e.shape[1] * [1.0])
# High-fidelity dataset without name
sm.set_training_values(xt_e, yt_e)
# Train the model
sm.train()
x = np.linspace(0, 1, 101, endpoint=True).reshape(-1, 1)
# Query the outputs
y = sm.predict_values(x)
mse = sm.predict_variances(x)
derivs = sm.predict_derivatives(x, kx=0)
plt.figure()
plt.plot(x, hf_function(x), label="reference")
plt.plot(x, y, linestyle="-.", label="mean_gp")
plt.scatter(xt_e, yt_e, marker="o", color="k", label="HF doe")
plt.legend(loc=0)
plt.ylim(-10, 17)
plt.xlim(-0.1, 1.1)
plt.xlabel(r"$x$")
plt.ylabel(r"$y$")
plt.show()
def test_nested_lhs(self):
xlimits = np.array([[0.0, 1.0], [0.0, 1.0]])
xnorm = NestedLHS(nlevel=3, xlimits=xlimits, random_state=0)
xlow, xmedium, xhigh = xnorm(15)
for items1 in xmedium:
found = False
for items0 in xlow:
if items1.all() == items0.all():
found = True
self.assertTrue(found)
for items1 in xhigh:
found = False
for items0 in xmedium:
if items1.all() == items0.all():
found = True
self.assertTrue(found)
def test_mfk_variance(self):
# To create the doe
# dim = 2
nlevel = 2
ub0 = 10.0
ub1 = 15.0
lb0 = -5.0
lb1 = 0.0
xlimits = np.array([[lb0, ub0], [lb1, ub1]])
# Constants
n_HF = 5 # number of high fidelity points (number of low fi is twice)
xdoes = NestedLHS(nlevel=nlevel, xlimits=xlimits)
x_t_lf, x_t_hf = xdoes(n_HF)
# Evaluate the HF and LF functions
y_t_lf = LF(x_t_lf)
y_t_hf = HF(x_t_hf)
sm = MFK(
theta0=x_t_hf.shape[1] * [1e-2],
print_global=False,
rho_regr="constant",
)
# low-fidelity dataset names being integers from 0 to level-1
sm.set_training_values(x_t_lf, y_t_lf, name=0)
# high-fidelity dataset without name
sm.set_training_values(x_t_hf, y_t_hf)
# train the model
sm.train()
# Validation set
# for validation with LHS
ntest = 1
sampling = LHS(xlimits=xlimits)
x_test_LHS = sampling(ntest)
# y_test_LHS = HF(x_test_LHS)
# compare the mean value between different formula
if print_output:
print("Mu sm : {}".format(sm.predict_values(x_test_LHS)[0, 0]))
print("Mu LG_sm : {}".format(
TestMFK_variance.Mu_LG_sm(x_test_LHS, sm)[0, 0]))
print("Mu LG_LG : {}".format(
TestMFK_variance.Mu_LG_LG(x_test_LHS, sm)[0, 0]))
# self.assertAlmostEqual(
# TestMFK_variance.Mu_LG_sm(x_test_LHS, sm)[0, 0],
# TestMFK_variance.Mu_LG_LG(x_test_LHS, sm)[0, 0],
# delta=1,
# )
self.assertAlmostEqual(
sm.predict_values(x_test_LHS)[0, 0],
TestMFK_variance.Mu_LG_LG(x_test_LHS, sm)[0, 0],
delta=1,
)
# compare the variance value between different formula
(k_0_LG_sm,
k_1_LG_sm) = TestMFK_variance.Cov_LG_sm(x_test_LHS, x_test_LHS, sm)
(k_0_LG_LG,
k_1_LG_LG) = TestMFK_variance.Cov_LG_LG(x_test_LHS, x_test_LHS, sm)
k_0_sm = sm.predict_variances_all_levels(x_test_LHS)[0][0, 0]
k_1_sm = sm.predict_variances_all_levels(x_test_LHS)[0][0, 1]
if print_output:
print("Level 0")
print("Var sm : {}".format(k_0_sm))
print("Var LG_sm : {}".format(k_0_LG_sm[0, 0]))
print("Var LG_LG : {}".format(k_0_LG_LG[0, 0]))
print("Level 1")
print("Var sm : {}".format(k_1_sm))
print("Var LG_sm : {}".format(k_1_LG_sm[0, 0]))
print("Var LG_LG : {}".format(k_1_LG_LG[0, 0]))
# for level 0
self.assertAlmostEqual(k_0_sm, k_0_LG_sm[0, 0], delta=1)
self.assertAlmostEqual(k_0_LG_sm[0, 0], k_0_LG_LG[0, 0], delta=1)
# for level 1
self.assertAlmostEqual(k_1_sm, k_1_LG_sm[0, 0], delta=1)
self.assertAlmostEqual(k_1_LG_sm[0, 0], k_1_LG_LG[0, 0], delta=1)
(
beta_sm_1,
sigma2_sm_1,
beta_sm_2,
sigma2_sm_2,
rho_sm,
sigma2_rho_sm,
beta_LG_1,
sigma2_LG_1,
beta_LG_2,
sigma2_LG_2,
rho_LG,
sigma2_rho_LG,
) = TestMFK_variance.verif_hyperparam(sm, x_test_LHS)
if print_output:
print("Hyperparameters")
print("rho_sm : {}".format(rho_sm))
print("rho_LG : {}".format(rho_LG))
print("sigma2_rho_sm : {}".format(sigma2_rho_sm[0]))
print("sigma2_rho_LG : {}".format(sigma2_rho_LG))
print("beta_sm_1 : {}".format(beta_sm_1))
print("beta_LG_1 : {}".format(beta_LG_1[0, 0]))
print("beta_sm_2 : {}".format(beta_sm_2))
print("beta_LG_2 : {}".format(beta_LG_2))
print("sigma2_sm_1 : {}".format(sigma2_sm_1))
print("sigma2_LG_1 : {}".format(sigma2_LG_1))
print("sigma2_sm_2 : {}".format(sigma2_sm_2))
print("sigma2_LG_2 : {}".format(sigma2_LG_2))
import numpy as np import matplotlib.pyplot as plt from smt.applications.mfk import MFK, NestedLHS from smt.applications.mfkplsk import MFKPLSK from testbed_components import simple_1D_low, simple_1D_high # Problem set up xlimits = np.array([[0.0, 1.0]]) xdoes = NestedLHS(nlevel=2, xlimits=xlimits) xt_c, xt_e = xdoes(4) # Evaluate the HF and LF functions yt_e = simple_1D_high(xt_e) yt_c = simple_1D_low(xt_c) # choice of number of PLS components ncomp = 1 sm = MFKPLSK(n_comp=ncomp, theta0=np.array(ncomp * [1.0])) # low-fidelity dataset names being integers from 0 to level-1 sm.set_training_values(xt_c, yt_c, name=0) # high-fidelity dataset without name sm.set_training_values(xt_e, yt_e) # train the model sm.train() x = np.linspace(0, 1, 101, endpoint=True).reshape(-1, 1) # query the outputs