def init():
print("\nInitializing run...")
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)
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)
# Wrap controller in checkpoint object
controller = CheckpointController(controller, fname=fname)
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 start(self, max_evals):
"""Starts a new pySOT run."""
self.history = []
self.proposals = []
# Symmetric Latin hypercube design
des_pts = max([self.batch_size, 2 * (self.opt.dim + 1)])
slhd = SymmetricLatinHypercube(dim=self.opt.dim, num_pts=des_pts)
# Warped RBF interpolant
rbf = RBFInterpolant(
dim=self.opt.dim,
lb=self.opt.lb,
ub=self.opt.ub,
kernel=CubicKernel(),
tail=LinearTail(self.opt.dim),
eta=1e-4,
)
# Optimization strategy
self.strategy = SRBFStrategy(
max_evals=self.max_evals,
opt_prob=self.opt,
exp_design=slhd,
surrogate=rbf,
asynchronous=True,
batch_size=1,
use_restarts=True,
)
def test_srbf_async():
max_evals = 200
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,
batch_size=None)
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
controller.run()
check_strategy(controller)
def init():
print("\nInitializing run...")
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 = SerialController(ackley.eval)
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=rbf,
asynchronous=True)
print("Number of workers: 1")
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__))
# Wrap controller in checkpoint object
controller = CheckpointController(controller, fname=fname)
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 __init__(self, worker_id, data, response_surface, maxeval, nsamples,
exp_design=None, sampling_method=None, extra=None, extra_vals=None):
# Check stopping criterion
self.start_time = time.time()
if maxeval < 0: # Time budget
self.maxeval = np.inf
self.time_budget = np.abs(maxeval)
else:
self.maxeval = maxeval
self.time_budget = np.inf
# Import problem information
self.worker_id = worker_id
self.data = data
self.fhat = response_surface
if self.fhat is None:
self.fhat = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)
self.fhat.reset() # Just to be sure!
self.nsamples = nsamples
self.extra = extra
self.extra_vals = extra_vals
# Default to generate sampling points using Symmetric Latin Hypercube
self.design = exp_design
if self.design is None:
if self.data.dim > 50:
self.design = LatinHypercube(data.dim, data.dim+1)
else:
self.design = SymmetricLatinHypercube(data.dim, 2*(data.dim+1))
self.xrange = np.asarray(data.xup - data.xlow)
# algorithm parameters
self.sigma_min = 0.005
self.sigma_max = 0.2
self.sigma_init = 0.2
self.failtol = max(5, data.dim)
self.succtol = 3
self.numeval = 0
self.status = 0
self.sigma = 0
self.resubmitter = RetryStrategy()
self.xbest = None
self.fbest = np.inf
self.fbest_old = None
# Set up search procedures and initialize
self.sampling = sampling_method
if self.sampling is None:
self.sampling = CandidateDYCORS(data)
self.check_input()
# Start with first experimental design
self.sample_initial()
def test_slhd():
for i in range(10, 12): # To test even and odd
slhd = SymmetricLatinHypercube(dim=3, num_pts=i)
X = slhd.generate_points()
assert isinstance(slhd, ExperimentalDesign)
assert np.all(X.shape == (i, 3))
assert slhd.num_pts == i
assert slhd.dim == 3
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 example_subprocess_files():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_subprocess_files.log"):
os.remove("./logfiles/example_subprocess_files.log")
logging.basicConfig(filename="./logfiles/example_subprocess_files.log",
level=logging.INFO)
print("\nNumber of threads: 4")
print("Maximum number of evaluations: 200")
print("Sampling method: Candidate DYCORS")
print("Experimental design: Symmetric Latin Hypercube")
print("Surrogate: Cubic RBF")
assert os.path.isfile(path), "You need to build sphere_ext_files"
num_threads = 4
max_evals = 200
sphere = Sphere(dim=10)
rbf = RBFInterpolant(dim=sphere.dim,
kernel=TPSKernel(),
tail=LinearTail(sphere.dim))
slhd = SymmetricLatinHypercube(dim=sphere.dim,
num_pts=2 * (sphere.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=sphere,
exp_design=slhd,
surrogate=rbf,
asynchronous=False,
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 i in range(num_threads):
worker = CppSim(controller)
worker.my_filename = str(i) + ".txt"
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_slhd_round():
num_pts = 10
dim = 3
lb = np.array([1, 2, 3])
ub = np.array([3, 4, 5])
int_var = np.array([1])
np.random.seed(0)
slhd = SymmetricLatinHypercube(dim=dim, num_pts=num_pts)
X = slhd.generate_points(lb=lb, ub=ub, int_var=int_var)
assert np.all(np.round(X[:, 1] == X[:, 1])) # Should be integers
assert np.all(np.max(X, axis=0) == ub)
assert np.all(np.min(X, axis=0) == lb)
def example_subprocess_partial_info():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_subprocess_partial_info.log"):
os.remove("./logfiles/example_subprocess_partial_info.log")
logging.basicConfig(
filename="./logfiles/example_subprocess_partial_info.log",
level=logging.INFO)
assert os.path.isfile(path), "You need to build sumfun_ext"
num_threads = 4
max_evals = 200
sumfun = SumfunExt(dim=10)
rbf = RBFInterpolant(dim=sumfun.dim,
lb=sumfun.lb,
ub=sumfun.ub,
kernel=CubicKernel(),
tail=LinearTail(sumfun.dim))
slhd = SymmetricLatinHypercube(dim=sumfun.dim,
num_pts=2 * (sumfun.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=sumfun,
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 and give them access to the objective function
for _ in range(num_threads):
controller.launch_worker(CppSim(controller))
# 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_lcb_serial():
max_evals = 50
gp = GPRegressor(dim=ackley.dim)
slhd = SymmetricLatinHypercube(
dim=ackley.dim, num_pts=2*(ackley.dim+1))
# Create a strategy and a controller
controller = SerialController(ackley.eval)
controller.strategy = LCBStrategy(
max_evals=max_evals, opt_prob=ackley, exp_design=slhd,
surrogate=gp, asynchronous=True)
controller.run()
check_strategy(controller)
def main_master(num_workers):
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/test_subprocess_mpi.log"):
os.remove("./logfiles/test_subprocess_mpi.log")
logging.basicConfig(filename="./logfiles/test_subprocess_mpi.log",
level=logging.INFO)
print("\nTesting the POAP MPI controller with {0} workers".format(
num_workers))
print("Maximum number of evaluations: 200")
print("Search strategy: Candidate DYCORS")
print("Experimental design: Symmetric Latin Hypercube")
print("Surrogate: Cubic RBF")
assert os.path.isfile(path), "You need to build sphere_ext"
max_evals = 200
sphere = Sphere(dim=10)
rbf = RBFInterpolant(dim=sphere.dim,
kernel=CubicKernel(),
tail=LinearTail(sphere.dim))
slhd = SymmetricLatinHypercube(dim=sphere.dim,
num_pts=2 * (sphere.dim + 1))
# Create a strategy and a controller
strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=sphere,
exp_design=slhd,
surrogate=rbf,
asynchronous=True,
batch_size=num_workers)
controller = MPIController(strategy)
print("Number of threads: {}".format(num_workers))
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__))
# 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_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_srbf_serial():
max_evals = 200
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 = SerialController(ackley.eval)
controller.strategy = SRBFStrategy(
max_evals=max_evals, opt_prob=ackley, exp_design=slhd,
surrogate=rbf, asynchronous=True)
controller.run()
check_strategy(controller)
def init_serial():
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 = SerialController(ackley.eval)
controller.strategy = DYCORSStrategy(max_evals=max_evals,
opt_prob=ackley,
exp_design=slhd,
surrogate=rbf,
asynchronous=True)
# Wrap controller in checkpoint object
controller = CheckpointController(controller, fname=fname)
controller.run()
def test_lcb_async():
max_evals = 50
gp = GPRegressor(dim=ackley.dim)
slhd = SymmetricLatinHypercube(
dim=ackley.dim, num_pts=2*(ackley.dim+1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = LCBStrategy(
max_evals=max_evals, opt_prob=ackley, exp_design=slhd,
surrogate=gp, asynchronous=True, batch_size=None)
for _ in range(num_threads):
worker = BasicWorkerThread(controller, ackley.eval)
controller.launch_worker(worker)
controller.run()
check_strategy(controller)
def example_lower_confidence_bounds():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/example_lower_confidence_bounds.log"):
os.remove("./logfiles/example_lower_confidence_bounds.log")
logging.basicConfig(
filename="./logfiles/example_lower_confidence_bounds.log",
level=logging.INFO)
num_threads = 4
max_evals = 100
hart6 = Hartman6()
gp = GPRegressor(dim=hart6.dim)
slhd = SymmetricLatinHypercube(dim=hart6.dim, num_pts=2 * (hart6.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = LCBStrategy(max_evals=max_evals,
opt_prob=hart6,
exp_design=slhd,
surrogate=gp,
asynchronous=True)
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(gp.__class__.__name__))
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, hart6.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)))
def main_master(opt_prob, num_workers):
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/mpiexample_mpi.log"):
os.remove("./logfiles/mpiexample_mpi.log")
logging.basicConfig(filename="./logfiles/mpiexample_mpi.log",
level=logging.INFO)
max_evals = 500
rbf = RBFInterpolant(dim=opt_prob.dim,
lb=opt_prob.lb,
ub=opt_prob.ub,
kernel=CubicKernel(),
tail=LinearTail(opt_prob.dim))
slhd = SymmetricLatinHypercube(dim=opt_prob.dim,
num_pts=2 * (opt_prob.dim + 1))
# Create a strategy and a controller
strategy = SRBFStrategy(
max_evals=max_evals,
opt_prob=opt_prob,
exp_design=slhd,
surrogate=rbf,
asynchronous=True,
batch_size=num_workers,
)
controller = MPIController(strategy)
print("Number of workers: {}".format(num_workers))
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__))
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 pysot_cube(objective, scale, n_trials, n_dim, with_count=False):
if False:
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 = n_trials
gp = GenericProblem(dim=n_dim, objective=objective, scale=scale)
rbf = RBFInterpolant(dim=n_dim,
lb=np.array([-scale] * n_dim),
ub=np.array([scale] * n_dim),
kernel=CubicKernel(),
tail=LinearTail(n_dim))
slhd = SymmetricLatinHypercube(dim=n_dim, num_pts=2 * (n_dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=gp,
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, gp.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
return (result.value, gp.feval_count) if with_count else result.value
def fit(self, X, y=None, **kwargs):
"""Run training with cross validation.
:param X: training data
:param **: parameters to be passed to GridSearchCV
"""
# wrap for pySOT
class Target(OptimizationProblem):
def __init__(self, outer):
self.outer = outer
param_def = outer.param_def
self.lb = np.array([param['lb'] for param in param_def])
self.ub = np.array([param['ub'] for param in param_def])
self.dim = len(param_def)
self.int_var = np.array([
idx for idx, param in enumerate(param_def)
if param['integer']
])
self.cont_var = np.array([
idx for idx, param in enumerate(param_def)
if idx not in self.int_var
])
def eval_(self, x):
print('Eval {0} ...'.format(x))
param_def = self.outer.param_def
outer = self.outer
# prepare parameters grid for gridsearchcv
param_grid = ({
param['name']:
[int(x[idx]) if param['integer'] else x[idx]]
for idx, param in enumerate(param_def)
})
# create gridsearchcv to evaluate the cv
gs = GridSearchCV(outer.estimator,
param_grid,
refit=False,
**outer.kwargs)
# never refit during iteration, refit at the end
gs.fit(X, y=y, **kwargs)
gs_score = gs.best_score_
# gridsearchcv score is better when greater
if not outer.best_score_ or gs_score > outer.best_score_:
outer.best_score_ = gs_score
outer.best_params_ = gs.best_params_
# also record history
outer.params_history_.append(x)
outer.score_history_.append(gs_score)
print('Eval {0} => {1}'.format(x, gs_score))
# pySOT score is the lower the better, so return the negated
return -gs_score
# pySOT routine
# TODO: make this configurable
target = Target(self)
rbf = SurrogateUnitBox(RBFInterpolant(dim=target.dim,
kernel=CubicKernel(),
tail=LinearTail(target.dim)),
lb=target.lb,
ub=target.ub)
slhd = SymmetricLatinHypercube(dim=target.dim,
num_pts=2 * (target.dim + 1))
# Create a strategy and a controller
controller = SerialController(objective=target.eval_)
controller.strategy = SRBFStrategy(max_evals=self.n_iter,
batch_size=1,
opt_prob=target,
exp_design=slhd,
surrogate=rbf,
asynchronous=False)
print('Maximum number of evaluations: {0}'.format(self.n_iter))
print('Strategy: {0}'.format(controller.strategy.__class__.__name__))
print('Experimental design: {0}'.format(slhd.__class__.__name__))
print('Surrogate: {0}'.format(rbf.__class__.__name__))
# 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 setup_backend(
self,
params,
strategy="SRBF",
surrogate="RBF",
design=None,
):
self.opt_problem = BBoptOptimizationProblem(params)
design_kwargs = dict(dim=self.opt_problem.dim)
_coconut_case_match_to_1 = design
_coconut_case_match_check_1 = False
if _coconut_case_match_to_1 is None:
_coconut_case_match_check_1 = True
if _coconut_case_match_check_1:
self.exp_design = EmptyExperimentalDesign(**design_kwargs)
if not _coconut_case_match_check_1:
if _coconut_case_match_to_1 == "latin_hypercube":
_coconut_case_match_check_1 = True
if _coconut_case_match_check_1:
self.exp_design = LatinHypercube(num_pts=2 *
(self.opt_problem.dim + 1),
**design_kwargs)
if not _coconut_case_match_check_1:
if _coconut_case_match_to_1 == "symmetric_latin_hypercube":
_coconut_case_match_check_1 = True
if _coconut_case_match_check_1:
self.exp_design = SymmetricLatinHypercube(
num_pts=2 * (self.opt_problem.dim + 1), **design_kwargs)
if not _coconut_case_match_check_1:
if _coconut_case_match_to_1 == "two_factorial":
_coconut_case_match_check_1 = True
if _coconut_case_match_check_1:
self.exp_design = TwoFactorial(**design_kwargs)
if not _coconut_case_match_check_1:
_coconut_match_set_name_design_cls = _coconut_sentinel
_coconut_match_set_name_design_cls = _coconut_case_match_to_1
_coconut_case_match_check_1 = True
if _coconut_case_match_check_1:
if _coconut_match_set_name_design_cls is not _coconut_sentinel:
design_cls = _coconut_case_match_to_1
if _coconut_case_match_check_1 and not (callable(design_cls)):
_coconut_case_match_check_1 = False
if _coconut_case_match_check_1:
self.exp_design = design_cls(**design_kwargs)
if not _coconut_case_match_check_1:
raise TypeError(
"unknown experimental design {_coconut_format_0!r}".format(
_coconut_format_0=(design)))
surrogate_kwargs = dict(dim=self.opt_problem.dim,
lb=self.opt_problem.lb,
ub=self.opt_problem.ub)
_coconut_case_match_to_2 = surrogate
_coconut_case_match_check_2 = False
if _coconut_case_match_to_2 == "RBF":
_coconut_case_match_check_2 = True
if _coconut_case_match_check_2:
self.surrogate = RBFInterpolant(
kernel=LinearKernel() if design is None else CubicKernel(),
tail=ConstantTail(self.opt_problem.dim)
if design is None else LinearTail(self.opt_problem.dim),
**surrogate_kwargs)
if not _coconut_case_match_check_2:
if _coconut_case_match_to_2 == "GP":
_coconut_case_match_check_2 = True
if _coconut_case_match_check_2:
self.surrogate = GPRegressor(**surrogate_kwargs)
if not _coconut_case_match_check_2:
_coconut_match_set_name_surrogate_cls = _coconut_sentinel
_coconut_match_set_name_surrogate_cls = _coconut_case_match_to_2
_coconut_case_match_check_2 = True
if _coconut_case_match_check_2:
if _coconut_match_set_name_surrogate_cls is not _coconut_sentinel:
surrogate_cls = _coconut_case_match_to_2
if _coconut_case_match_check_2 and not (callable(surrogate_cls)):
_coconut_case_match_check_2 = False
if _coconut_case_match_check_2:
self.surrogate = surrogate_cls(**surrogate_kwargs)
if not _coconut_case_match_check_2:
raise TypeError("unknown surrogate {_coconut_format_0!r}".format(
_coconut_format_0=(surrogate)))
strategy_kwargs = dict(max_evals=sys.maxsize,
opt_prob=self.opt_problem,
exp_design=self.exp_design,
surrogate=self.surrogate,
asynchronous=True,
batch_size=1)
_coconut_case_match_to_3 = strategy
_coconut_case_match_check_3 = False
if _coconut_case_match_to_3 == "SRBF":
_coconut_case_match_check_3 = True
if _coconut_case_match_check_3:
self.strategy = SRBFStrategy(**strategy_kwargs)
if not _coconut_case_match_check_3:
if _coconut_case_match_to_3 == "EI":
_coconut_case_match_check_3 = True
if _coconut_case_match_check_3:
self.strategy = EIStrategy(**strategy_kwargs)
if not _coconut_case_match_check_3:
if _coconut_case_match_to_3 == "DYCORS":
_coconut_case_match_check_3 = True
if _coconut_case_match_check_3:
self.strategy = DYCORSStrategy(**strategy_kwargs)
if not _coconut_case_match_check_3:
if _coconut_case_match_to_3 == "LCB":
_coconut_case_match_check_3 = True
if _coconut_case_match_check_3:
self.strategy = LCBStrategy(**strategy_kwargs)
if not _coconut_case_match_check_3:
_coconut_match_set_name_strategy_cls = _coconut_sentinel
_coconut_match_set_name_strategy_cls = _coconut_case_match_to_3
_coconut_case_match_check_3 = True
if _coconut_case_match_check_3:
if _coconut_match_set_name_strategy_cls is not _coconut_sentinel:
strategy_cls = _coconut_case_match_to_3
if _coconut_case_match_check_3 and not (callable(strategy_cls)):
_coconut_case_match_check_3 = False
if _coconut_case_match_check_3:
self.strategy = strategy_cls(**strategy_kwargs)
if not _coconut_case_match_check_3:
raise TypeError("unknown strategy {_coconut_format_0!r}".format(
_coconut_format_0=(strategy)))
def run(self):
"""
Run the optimization
@return: Nothing
"""
self.problem = VoltageOptimizationProblem(
self.circuit,
self.options,
self.max_iter,
callback=self.progress_signal.emit)
# # (1) Optimization problem
# # print(data.info)
#
# # (2) Experimental design
# # Use a symmetric Latin hypercube with 2d + 1 samples
# exp_des = SymmetricLatinHypercube(dim=self.problem.dim, npts=2 * self.problem.dim + 1)
#
# # (3) Surrogate model
# # Use a cubic RBF interpolant with a linear tail
# surrogate = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=self.max_eval)
#
# # (4) Adaptive sampling
# # Use DYCORS with 100d candidate points
# adapt_samp = CandidateDYCORS(data=self, numcand=100 * self.dim)
#
# # Use the serial controller (uses only one thread)
# controller = SerialController(self.objfunction)
#
# # (5) Use the sychronous strategy without non-bound constraints
# strategy = SyncStrategyNoConstraints(worker_id=0,
# data=self,
# maxeval=self.max_eval,
# nsamples=1,
# exp_design=exp_des,
# response_surface=surrogate,
# sampling_method=adapt_samp)
#
# controller.strategy = strategy
#
# # Run the optimization strategy
# result = controller.run()
#
# # Print the final result
# print('Best value found: {0}'.format(result.value))
# print('Best solution found: {0}'.format(np.array_str(result.params[0], max_line_width=np.inf, precision=5,
# suppress_small=True)))
num_threads = 4
surrogate_model = GPRegressor(dim=self.problem.dim)
sampler = SymmetricLatinHypercube(dim=self.problem.dim,
num_pts=2 * (self.problem.dim + 1))
# Create a strategy and a controller
controller = ThreadController()
controller.strategy = SRBFStrategy(max_evals=self.max_iter,
opt_prob=self.problem,
exp_design=sampler,
surrogate=surrogate_model,
asynchronous=True,
batch_size=num_threads)
print("Number of threads: {}".format(num_threads))
print("Maximum number of evaluations: {}".format(self.max_iter))
print("Strategy: {}".format(controller.strategy.__class__.__name__))
print("Experimental design: {}".format(sampler.__class__.__name__))
print("Surrogate: {}".format(surrogate_model.__class__.__name__))
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, self.problem.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=4,
suppress_small=True)))
self.solution = result.params[0]
# Extract function values from the controller
self.optimization_values = np.array(
[o.value for o in controller.fevals])
# send the finnish signal
self.progress_signal.emit(0.0)
self.progress_text.emit('Done!')
self.done_signal.emit()
def optimize(self):
"""Method used to run the Genetic algorithm
:return: Returns the best individual and its function value
:rtype: numpy.array, float
"""
# Initialize population
if isinstance(self.start, np.ndarray):
if self.start.shape[0] != self.nindividuals or \
self.start.shape[1] != self.nvariables:
raise ValueError("Initial population has incorrect size")
if any(np.min(self.start, axis=0) >= self.lower_boundary) or \
any(np.max(self.start, axis=0) <= self.upper_boundary):
raise ValueError("Initial population is outside the domain")
population = self.start
elif self.start == "SLHD":
exp_des = SymmetricLatinHypercube(
self.nvariables, self.nindividuals)
population = self.lower_boundary + exp_des.generate_points() * \
(self.upper_boundary - self.lower_boundary)
elif self.start == "LHD":
exp_des = LatinHypercube(self.nvariables, self.nindividuals)
population = self.lower_boundary + exp_des.generate_points() * \
(self.upper_boundary - self.lower_boundary)
elif self.start == "Random":
population = self.lower_boundary + np.random.rand(
self.nindividuals, self.nvariables) *\
(self.upper_boundary - self.lower_boundary)
else:
raise ValueError("Unknown argument for initial population")
new_population = []
# Round positions
if len(self.integer_variables) > 0:
new_population = np.copy(population)
population[:, self.integer_variables] = np.round(
population[:, self.integer_variables])
for i in self.integer_variables:
ind = np.where(population[:, i] < self.lower_boundary[i])
population[ind, i] += 1
ind = np.where(population[:, i] > self.upper_boundary[i])
population[ind, i] -= 1
# Evaluate all individuals
function_values = self.function(population)
if len(function_values.shape) == 2:
function_values = np.squeeze(np.asarray(function_values))
# Save the best individual
ind = np.argmin(function_values)
best_individual = np.copy(population[ind, :])
best_value = function_values[ind]
if len(self.integer_variables) > 0:
population = new_population
# Main loop
for _ in range(self.ngenerations):
# Do tournament selection to select the parents
competitors = np.random.randint(
0, self.nindividuals,
(self.nindividuals, self.tournament_size))
ind = np.argmin(function_values[competitors], axis=1)
winner_indices = np.zeros(self.nindividuals, dtype=int)
for i in range(self.tournament_size): # This loop is short
winner_indices[np.where(ind == i)] = \
competitors[np.where(ind == i), i]
parent1 = population[
winner_indices[0:self.nindividuals//2], :]
parent2 = population[
winner_indices[self.nindividuals//2:self.nindividuals], :]
# Averaging Crossover
cross = np.where(np.random.rand(
self.nindividuals//2) < self.p_cross)[0]
nn = len(cross) # Number of crossovers
alpha = np.random.rand(nn, 1)
# Create the new chromosomes
parent1_new = np.multiply(alpha, parent1[cross, :]) + \
np.multiply(1 - alpha, parent2[cross, :])
parent2_new = np.multiply(alpha, parent2[cross, :]) + \
np.multiply(1 - alpha, parent1[cross, :])
parent1[cross, :] = parent1_new
parent2[cross, :] = parent2_new
population = np.concatenate((parent1, parent2))
# Apply mutation
scale_factors = self.sigma * (
self.upper_boundary - self.lower_boundary) # Scale
perturbation = np.random.randn(
self.nindividuals, self.nvariables) # Generate perturbations
perturbation = np.multiply(
perturbation, scale_factors) # Scale accordingly
perturbation = np.multiply(perturbation, (
np.random.rand(self.nindividuals,
self.nvariables) < self.p_mutation))
population += perturbation # Add perturbation
population = np.maximum(np.reshape(
self.lower_boundary, (1, self.nvariables)), population)
population = np.minimum(np.reshape(
self.upper_boundary, (1, self.nvariables)), population)
# Round chromosomes
new_population = []
if len(self.integer_variables) > 0:
new_population = np.copy(population)
population = round_vars(population, self.integer_variables,
self.lower_boundary,
self.upper_boundary)
# Keep the best individual
population[0, :] = best_individual
# Evaluate all individuals
function_values = self.function(population)
if len(function_values.shape) == 2:
function_values = np.squeeze(np.asarray(function_values))
# Save the best individual
ind = np.argmin(function_values)
best_individual = np.copy(population[ind, :])
best_value = function_values[ind]
# Use the positions that are not rounded
if len(self.integer_variables) > 0:
population = new_population
return best_individual, best_value
def pysot_cube(objective,
n_trials,
n_dim,
with_count=False,
method=None,
design=None):
""" Minimize
:param objective:
:param n_trials:
:param n_dim:
:param with_count:
:return:
"""
logging.getLogger('pySOT').setLevel(logging.ERROR)
num_threads = 1
asynchronous = True
max_evals = n_trials
gp = GenericProblem(dim=n_dim, objective=objective)
if design == 'latin':
exp_design = LatinHypercube(dim=n_dim, num_pts=2 * (n_dim + 1))
elif design == 'symmetric':
exp_design = SymmetricLatinHypercube(dim=n_dim,
num_pts=2 * (n_dim + 1))
elif design == 'factorial':
exp_design = TwoFactorial(dim=n_dim)
else:
raise ValueError('design should be latin, symmetric or factorial')
# Create a strategy and a controller
# SRBFStrategy, EIStrategy, DYCORSStrategy,RandomStrategy, LCBStrategy
controller = ThreadController()
if method.lower() == 'srbf':
surrogate = RBFInterpolant(dim=n_dim,
lb=np.array([0.0] * n_dim),
ub=np.array([1.0] * n_dim),
kernel=CubicKernel(),
tail=LinearTail(n_dim))
controller.strategy = SRBFStrategy(max_evals=max_evals,
opt_prob=gp,
exp_design=exp_design,
surrogate=surrogate,
asynchronous=asynchronous)
elif method.lower() == 'ei':
surrogate = GPRegressor(dim=n_dim,
lb=np.array([0.0] * n_dim),
ub=np.array([1.0] * n_dim))
controller.strategy = EIStrategy(max_evals=max_evals,
opt_prob=gp,
exp_design=exp_design,
surrogate=surrogate,
asynchronous=asynchronous)
elif method.lower() == 'dycors':
surrogate = RBFInterpolant(dim=n_dim,
lb=np.array([0.0] * n_dim),
ub=np.array([1.0] * n_dim),
kernel=CubicKernel(),
tail=LinearTail(n_dim))
controller.strategy = DYCORSStrategy(max_evals=max_evals,
opt_prob=gp,
exp_design=exp_design,
surrogate=surrogate,
asynchronous=asynchronous)
elif method.lower() == 'lcb':
surrogate = GPRegressor(dim=n_dim,
lb=np.array([0.0] * n_dim),
ub=np.array([1.0] * n_dim))
controller.strategy = LCBStrategy(max_evals=max_evals,
opt_prob=gp,
exp_design=exp_design,
surrogate=surrogate,
asynchronous=asynchronous)
elif method.lower() == 'random':
controller.strategy = RandomStrategy(max_evals=max_evals,
opt_prob=gp)
else:
raise ValueError("Didn't recognize method passed to pysot")
# Launch the threads and give them access to the objective function
for _ in range(num_threads):
worker = BasicWorkerThread(controller, gp.eval)
controller.launch_worker(worker)
# Run the optimization strategy
result = controller.run()
best_x = result.params[0].tolist()
return (result.value, best_x,
gp.feval_count) if with_count else (result.value, best_x)
def __init__(self,
worker_id,
data,
response_surface,
maxeval,
nsamples,
exp_design=None,
sampling_method=None,
archiving_method=None,
extra=None,
extra_vals=None,
store_sim=False):
# Check stopping criterion
self.start_time = time.time()
if maxeval < 0: # Time budget
self.maxeval = np.inf
self.time_budget = np.abs(maxeval)
else:
self.maxeval = maxeval
self.time_budget = np.inf
# Import problem information
self.worker_id = worker_id
self.data = data
self.fhat = []
if response_surface is None:
for i in range(self.data.nobj):
self.fhat.append(
RBFInterpolant(kernel=CubicKernel,
tail=LinearTail,
maxp=maxeval)) #MOPLS ONLY
else:
for i in range(self.data.nobj):
response_surface.reset() # Just to be sure!
self.fhat.append(deepcopy(response_surface)) #MOPLS ONLY
self.ncenters = nsamples
self.nsamples = 1
self.numinit = None
self.extra = extra
self.extra_vals = extra_vals
self.store_sim = store_sim
# Default to generate sampling points using Symmetric Latin Hypercube
self.design = exp_design
if self.design is None:
if self.data.dim > 50:
self.design = LatinHypercube(data.dim, data.dim + 1)
else:
self.design = SymmetricLatinHypercube(data.dim,
2 * (data.dim + 1))
self.xrange = np.asarray(data.xup - data.xlow)
# algorithm parameters
self.sigma_min = 0.005
self.sigma_max = 0.2
self.sigma_init = 0.2
self.failtol = max(5, data.dim)
self.failcount = 0
self.contol = 5
self.numeval = 0
self.status = 0
self.sigma = 0
self.resubmitter = RetryStrategy()
self.xbest = None
self.fbest = None
self.fbest_old = None
self.improvement_prev = 1
# population of centers and long-term archive
self.nd_archives = []
self.new_pop = []
self.sim_res = []
if archiving_method is None:
self.memory_archive = NonDominatedArchive(200)
else:
self.memory_archive = archiving_method
self.evals = []
self.maxfit = min(200, 20 * self.data.dim)
self.d_thresh = 1.0
# Set up search procedures and initialize
self.sampling = sampling_method
if self.sampling is None:
self.sampling = EvolutionaryAlgorithm(data)
self.check_input()
# Start with first experimental design
self.sample_initial()
