def test_qei_criterion_default(self): fun = TestEGO.function_test_1d xlimits = np.array([[0.0, 25.0]]) xdoe = FullFactorial(xlimits=xlimits)(3) ydoe = fun(xdoe) ego = EGO(xdoe=xdoe, ydoe=ydoe, n_iter=1, criterion="SBO", xlimits=xlimits, n_start=30) ego._setup_optimizer(fun) ego.gpr.set_training_values(xdoe, ydoe) ego.gpr.train() xtest = np.array([[10.0]]) # test that default virtual point should be equal to 3sigma lower bound kriging interval expected = float( ego.gpr.predict_values(xtest) - 3 * np.sqrt(ego.gpr.predict_variances(xtest))) actual = float(ego._get_virtual_point(xtest, fun(xtest))[0]) self.assertAlmostEqual(expected, actual)
def run_ego_parallel_example(): import numpy as np from smt.applications import EGO from smt.applications.ego import EGO, Evaluator from smt.sampling_methods import FullFactorial import sklearn import matplotlib.pyplot as plt from matplotlib import colors from mpl_toolkits.mplot3d import Axes3D from scipy.stats import norm def function_test_1d(x): # function xsinx import numpy as np x = np.reshape(x, (-1, )) y = np.zeros(x.shape) y = (x - 3.5) * np.sin((x - 3.5) / (np.pi)) return y.reshape((-1, 1)) n_iter = 3 n_parallel = 3 n_start = 50 xlimits = np.array([[0.0, 25.0]]) xdoe = np.atleast_2d([0, 7, 25]).T n_doe = xdoe.size class ParallelEvaluator(Evaluator): """ Implement Evaluator interface using multiprocessing ThreadPool object (Python 3 only). """ def run(self, fun, x): n_thread = 5 # Caveat: import are made here due to SMT documentation building process import numpy as np from sys import version_info from multiprocessing.pool import ThreadPool if version_info.major == 2: return fun(x) # Python 3 only with ThreadPool(n_thread) as p: return np.array([ y[0] for y in p.map( fun, [np.atleast_2d(x[i]) for i in range(len(x))]) ]) criterion = "EI" #'EI' or 'SBO' or 'UCB' qEI = "KBUB" # "KB", "KBLB", "KBUB", "KBRand" ego = EGO( n_iter=n_iter, criterion=criterion, xdoe=xdoe, xlimits=xlimits, n_parallel=n_parallel, qEI=qEI, n_start=n_start, evaluator=ParallelEvaluator(), ) x_opt, y_opt, _, x_data, y_data = ego.optimize(fun=function_test_1d) print("Minimum in x={:.1f} with f(x)={:.1f}".format( float(x_opt), float(y_opt))) x_plot = np.atleast_2d(np.linspace(0, 25, 100)).T y_plot = function_test_1d(x_plot) fig = plt.figure(figsize=[10, 10]) for i in range(n_iter): k = n_doe + (i) * (n_parallel) x_data_k = x_data[0:k] y_data_k = y_data[0:k] x_data_sub = x_data_k.copy() y_data_sub = y_data_k.copy() for p in range(n_parallel): ego.gpr.set_training_values(x_data_sub, y_data_sub) ego.gpr.train() y_ei_plot = -ego.EI(x_plot, y_data_sub) y_gp_plot = ego.gpr.predict_values(x_plot) y_gp_plot_var = ego.gpr.predict_variances(x_plot) x_data_sub = np.append(x_data_sub, x_data[k + p]) y_KB = ego._get_virtual_point(np.atleast_2d(x_data[k + p]), y_data_sub) y_data_sub = np.append(y_data_sub, y_KB) ax = fig.add_subplot(n_iter, n_parallel, i * (n_parallel) + p + 1) ax1 = ax.twinx() (ei, ) = ax1.plot(x_plot, y_ei_plot, color="red") (true_fun, ) = ax.plot(x_plot, y_plot) (data, ) = ax.plot( x_data_sub[:-1 - p], y_data_sub[:-1 - p], linestyle="", marker="o", color="orange", ) (virt_data, ) = ax.plot( x_data_sub[-p - 1:-1], y_data_sub[-p - 1:-1], linestyle="", marker="o", color="g", ) (opt, ) = ax.plot(x_data_sub[-1], y_data_sub[-1], linestyle="", marker="*", color="r") (gp, ) = ax.plot(x_plot, y_gp_plot, linestyle="--", color="g") sig_plus = y_gp_plot + 3.0 * np.sqrt(y_gp_plot_var) sig_moins = y_gp_plot - 3.0 * np.sqrt(y_gp_plot_var) un_gp = ax.fill_between(x_plot.T[0], sig_plus.T[0], sig_moins.T[0], alpha=0.3, color="g") lines = [true_fun, data, gp, un_gp, opt, ei, virt_data] fig.suptitle("EGOp optimization of $f(x) = x \sin{x}$") fig.subplots_adjust(hspace=0.4, wspace=0.4, top=0.8) ax.set_title("iteration {}.{}".format(i, p)) fig.legend( lines, [ "f(x)=xsin(x)", "Given data points", "Kriging prediction", "Kriging 99% confidence interval", "Next point to evaluate", "Expected improvment function", "Virtula data points", ], ) plt.show()