def test_ei():
np.random.seed(0)
ackley = Ackley(dim=1)
X = np.expand_dims([-15, -10, 0, 1, 20], axis=1)
fX = np.array([ackley.eval(x) for x in X])
gp = GPRegressor(dim=ackley.dim, lb=ackley.lb, ub=ackley.ub)
gp.add_points(X, fX)
# Find the global optimizer of EI
x_true = -1.7558
x_next = ei_ga(X=X,
Xpend=None,
dtol=0.0,
ei_tol=0,
fX=fX,
num_pts=1,
opt_prob=ackley,
surrogate=gp)
assert np.isclose(x_next, x_true, atol=1e-2)
# Find the optimizer at least distance 5 from other points
x_true = 10.6656
x_next = ei_ga(X=X,
Xpend=None,
dtol=5.0,
ei_tol=0,
fX=fX,
num_pts=1,
opt_prob=ackley,
surrogate=gp)
assert np.isclose(x_next, x_true, atol=1e-2)
def test_unit_box():
ackley = Ackley(dim=1)
np.random.seed(0)
x = np.random.rand(30, 1)
fX = np.expand_dims([ackley.eval(y) for y in x], axis=1)
xx = np.expand_dims(np.linspace(0, 1, 100), axis=1)
# RBF with internal scaling to unit hypercube
rbf1 = RBFInterpolant(dim=1, lb=np.zeros(1), ub=100 * np.ones(1), eta=1e-6)
rbf1.add_points(x, fX)
# Normal RBF
rbf2 = RBFInterpolant(dim=1, lb=np.zeros(1), ub=100 * np.ones(1), eta=1e-6)
rbf2.add_points(x, fX)
assert np.max(np.abs(rbf1.predict(xx) - rbf2.predict(xx))) < 1e-10
assert np.max(
np.abs(rbf1.predict_deriv(x[0, :]) -
rbf2.predict_deriv(x[0, :]))) < 1e-10
assert np.max(np.abs(rbf1.X - rbf2.X)) < 1e-10
assert np.max(np.abs(rbf1.fX - rbf2.fX)) < 1e-10
rbf1.reset()
assert rbf1.num_pts == 0 and rbf1.dim == 1
assert rbf1.X.size == 0 and rbf1.fX.size == 0
def test_srbf():
np.random.seed(0)
ackley = Ackley(dim=1)
X = np.expand_dims([-15, -10, 0, 1, 20], axis=1)
fX = np.array([ackley.eval(x) for x in X])
gp = GPRegressor(dim=1)
gp.add_points(X, fX)
# Find the next point with w = 0.25
x_true = 10.50
x_next = candidate_uniform(
num_pts=1, X=X, Xpend=None, fX=fX, num_cand=10000,
surrogate=gp, opt_prob=ackley, weights=[0.25])
assert np.isclose(x_next, x_true, atol=1e-2)
x_next = candidate_srbf(
num_pts=1, X=X, Xpend=None, fX=fX, num_cand=10000,
surrogate=gp, opt_prob=ackley, weights=[0.25],
sampling_radius=0.5)
assert np.isclose(x_next, x_true, atol=1e-2)
# Find the next point with w = 0.75
x_true = -3.395
x_next = candidate_uniform(
num_pts=1, X=X, Xpend=None, fX=fX, num_cand=10000,
surrogate=gp, opt_prob=ackley, weights=[0.75])
assert np.isclose(x_next, x_true, atol=1e-2)
x_next = candidate_srbf(
num_pts=1, X=X, Xpend=None, fX=fX, num_cand=10000,
surrogate=gp, opt_prob=ackley, weights=[0.75],
sampling_radius=0.5)
assert np.isclose(x_next, x_true, atol=1e-2)
def test_ei():
np.random.seed(0)
ackley = Ackley(dim=1)
X = np.expand_dims([-15, -10, 0, 1, 20], axis=1)
fX = np.array([ackley.eval(x) for x in X])
gp = GPRegressor(dim=1)
gp.add_points(X, fX)
# Find the global optimizer of EI
x_true = -3.0556
x_next = expected_improvement_ga(
X=X, Xpend=None, dtol=0.0, ei_tol=0,
fX=fX, num_pts=1, opt_prob=ackley, surrogate=gp)
assert np.isclose(x_next, x_true, atol=1e-2)
x_next = expected_improvement_uniform(
X=X, Xpend=None, dtol=0.0, ei_tol=0,
fX=fX, num_pts=1, opt_prob=ackley, surrogate=gp,
num_cand=10000)
assert np.isclose(x_next, x_true, atol=1e-2)
# Find the optimizer at least distance 5 from other points
x_true = 11.14
x_next = expected_improvement_ga(
X=X, Xpend=None, dtol=5.0, ei_tol=0,
fX=fX, num_pts=1, opt_prob=ackley, surrogate=gp)
assert np.isclose(x_next, x_true, atol=1e-2)
x_next = expected_improvement_uniform(
X=X, Xpend=None, dtol=5.0, ei_tol=0,
fX=fX, num_pts=1, opt_prob=ackley, surrogate=gp,
num_cand=10000)
assert np.isclose(x_next, x_true, atol=1e-2)
def example_extra_vals():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_extra_vals.log"):
os.remove("./logfiles/example_extra_vals.log")
logging.basicConfig(filename="./logfiles/example_extra_vals.log",
level=logging.INFO)
num_threads = 4
max_evals = 500
ackley = Ackley(dim=10)
num_extra = 10
extra = np.random.uniform(ackley.lb, ackley.ub, (num_extra, ackley.dim))
extra_vals = np.nan * np.ones((num_extra, 1))
for i in range(num_extra): # Evaluate every second point
if i % 2 == 0:
extra_vals[i] = ackley.eval(extra[i, :])
rbf = RBFInterpolant(dim=ackley.dim, kernel=CubicKernel(),
tail=LinearTail(ackley.dim))
slhd = SymmetricLatinHypercube(dim=ackley.dim, num_pts=2*(ackley.dim+1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(
max_evals=max_evals, opt_prob=ackley, exp_design=slhd,
surrogate=rbf, asynchronous=True, batch_size=num_threads,
extra_points=extra, extra_vals=extra_vals)
print("Number of threads: {}".format(num_threads))
print("Maximum number of evaluations: {}".format(max_evals))
print("Strategy: {}".format(controller.strategy.__class__.__name__))
print("Experimental design: {}".format(slhd.__class__.__name__))
print("Surrogate: {}".format(rbf.__class__.__name__))
# Append the known function values to the POAP database since
# POAP won't evaluate these points
for i in range(len(extra_vals)):
if not np.isnan(extra_vals[i]):
record = EvalRecord(
params=(np.ravel(extra[i, :]),), status='completed')
record.value = extra_vals[i]
record.feasible = True
controller.fevals.append(record)
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
print('Best value found: {0}'.format(result.value))
print('Best solution found: {0}\n'.format(
np.array_str(result.params[0], max_line_width=np.inf,
precision=5, suppress_small=True)))
def example_sop():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_simple.log"):
os.remove("./logfiles/example_simple.log")
logging.basicConfig(filename="./logfiles/example_simple.log",
level=logging.INFO)
print("\nNumber of threads: 8")
print("Maximum number of evaluations: 500")
print("Sampling method: CandidateDYCORS")
print("Experimental design: Symmetric Latin Hypercube")
print("Surrogate: Cubic RBF")
num_threads = 8
max_evals = 500
ackley = Ackley(dim=10)
rbf = RBFInterpolant(dim=ackley.dim,
lb=ackley.lb,
ub=ackley.ub,
kernel=CubicKernel(),
tail=LinearTail(ackley.dim))
slhd = SymmetricLatinHypercube(dim=ackley.dim,
num_pts=2 * (ackley.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SOPStrategy(
max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=rbf,
asynchronous=False,
ncenters=num_threads,
batch_size=num_threads,
)
print("Number of threads: {}".format(num_threads))
print("Maximum number of evaluations: {}".format(max_evals))
print("Strategy: {}".format(controller.strategy.__class__.__name__))
print("Experimental design: {}".format(slhd.__class__.__name__))
print("Surrogate: {}".format(rbf.__class__.__name__))
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
print("Best value found: {0}".format(result.value))
print("Best solution found: {0}\n".format(
np.array_str(result.params[0],
max_line_width=np.inf,
precision=5,
suppress_small=True)))
def example_matlab_engine():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_matlab_engine.log"):
os.remove("./logfiles/example_matlab_engine.log")
logging.basicConfig(filename="./logfiles/example_matlab_engine.log",
level=logging.INFO)
num_threads = 4
max_evals = 500
ackley = Ackley(dim=10)
rbf = RBFInterpolant(dim=ackley.dim,
lb=ackley.lb,
ub=ackley.ub,
kernel=CubicKernel(),
tail=LinearTail(ackley.dim))
slhd = SymmetricLatinHypercube(dim=ackley.dim,
num_pts=2 * (ackley.dim + 1))
# Use the serial controller (uses only one thread)
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=rbf,
asynchronous=True,
batch_size=num_threads)
print("Number of threads: {}".format(num_threads))
print("Maximum number of evaluations: {}".format(max_evals))
print("Strategy: {}".format(controller.strategy.__class__.__name__))
print("Experimental design: {}".format(slhd.__class__.__name__))
print("Surrogate: {}".format(rbf.__class__.__name__))
# Launch the threads
for _ in range(num_threads):
try:
worker = MatlabWorker(controller)
worker.matlab = matlab.engine.start_matlab()
controller.launch_worker(worker)
except Exception as e:
print("\nERROR: Failed to initialize a MATLAB session.\n")
print(str(e))
return
# Run the optimization strategy
result = controller.run()
# Print the final result
print("Best value found: {0}".format(result.value))
print("Best solution found: {0}\n".format(
np.array_str(result.params[0],
max_line_width=np.inf,
precision=5,
suppress_small=True)))
def mpiexample_simple():
# Optimization problem
ackley = Ackley(dim=10)
# Extract the rank
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
nprocs = comm.Get_size()
if rank == 0:
main_master(ackley, nprocs)
else:
main_worker(ackley.eval)
def example_mars():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_mars.log"):
os.remove("./logfiles/example_mars.log")
logging.basicConfig(filename="./logfiles/example_mars.log",
level=logging.INFO)
num_threads = 4
max_evals = 200
ackley = Ackley(dim=5)
try:
mars = MARSInterpolant(dim=ackley.dim, lb=ackley.lb, ub=ackley.ub)
except Exception as e:
print(str(e))
return
slhd = SymmetricLatinHypercube(dim=ackley.dim,
num_pts=2 * (ackley.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=mars,
asynchronous=True,
batch_size=num_threads)
print("Number of threads: {}".format(num_threads))
print("Maximum number of evaluations: {}".format(max_evals))
print("Strategy: {}".format(controller.strategy.__class__.__name__))
print("Experimental design: {}".format(slhd.__class__.__name__))
print("Surrogate: {}".format(mars.__class__.__name__))
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
print("Best value found: {0}".format(result.value))
print("Best solution found: {0}\n".format(
np.array_str(result.params[0],
max_line_width=np.inf,
precision=5,
suppress_small=True)))
def test_example_simple():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_simple.log"):
os.remove("./logfiles/example_simple.log")
logging.basicConfig(filename="./logfiles/example_simple.log",
level=logging.INFO)
num_threads = 2
max_evals = 50
ackley = Ackley(dim=10)
rbf = RBFInterpolant(dim=ackley.dim,
lb=ackley.lb,
ub=ackley.ub,
kernel=CubicKernel(),
tail=LinearTail(ackley.dim))
slhd = SymmetricLatinHypercube(dim=ackley.dim,
num_pts=2 * (ackley.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=rbf,
asynchronous=True)
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
print("Best value found: {0}".format(result.value))
print("Best solution found: {0}\n".format(
np.array_str(result.params[0],
max_line_width=np.inf,
precision=5,
suppress_small=True)))
import numpy as np
from poap.controller import BasicWorkerThread, SerialController, ThreadController
from pySOT.experimental_design import SymmetricLatinHypercube
from pySOT.optimization_problems import Ackley
from pySOT.strategy import DYCORSStrategy, EIStrategy, LCBStrategy, RandomStrategy, SOPStrategy, SRBFStrategy
from pySOT.surrogate import CubicKernel, GPRegressor, LinearTail, RBFInterpolant
num_threads = 4
ackley = Ackley(dim=10)
def check_strategy(controller):
"""Make sure the strategy object is correct."""
# Check the strategy object
assert controller.strategy.num_evals == controller.strategy.max_evals
assert controller.strategy.init_pending == 0
assert controller.strategy.pending_evals == 0
assert controller.strategy.X.shape == (controller.strategy.num_evals,
ackley.dim)
assert controller.strategy.fX.shape == (controller.strategy.num_evals, 1)
assert controller.strategy.Xpend.shape == (0, ackley.dim)
assert len(controller.strategy.fevals) == controller.strategy.num_evals
# Check that the strategy and controller have the same information
for i in range(controller.strategy.num_evals):
idx = np.where(
(controller.strategy.X == controller.fevals[i].params[0]).all(
axis=1))[0]
assert np.all(
import os
import time
import numpy as np
import pytest
from poap.controller import SerialController
from pySOT.controller import CheckpointController
from pySOT.experimental_design import SymmetricLatinHypercube
from pySOT.optimization_problems import Ackley
from pySOT.strategy import DYCORSStrategy
from pySOT.surrogate import CubicKernel, LinearTail, RBFInterpolant
np.random.seed(0)
max_evals = 200
ackley = Ackley(dim=5)
fname = "checkpoint.pysot"
def check_strategy(controller):
"""Make sure the strategy object is correct."""
# Check the strategy object
assert controller.strategy.num_evals == controller.strategy.max_evals
assert controller.strategy.pending_evals == 0
assert controller.strategy.X.shape == (controller.strategy.num_evals,
ackley.dim)
assert controller.strategy.fX.shape == (controller.strategy.num_evals, 1)
assert controller.strategy.Xpend.shape == (0, ackley.dim)
assert len(controller.strategy.fevals) == controller.strategy.num_evals