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():
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 = 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 run(self):
print("\n[%s] Running %s pySOTOptimizer algorithm" %
(datetime.now().strftime('%H:%M:%S'), self.alg_name))
for i in range(self.n_runs):
print("\t[%s] Starting Run %s" %
(datetime.now().strftime('%H:%M:%S'), i + 1))
self.reset_run_counters(i)
controller = SerialController(self.data.obj_function)
strategy = SyncStrategyNoConstraints(
worker_id=0,
data=self.data,
maxeval=self.eval_limit,
nsamples=1,
exp_design=self.initial_sampling_alg,
response_surface=self.surrogate,
sampling_method=self.candidate_sampling_alg)
controller.strategy = strategy
self.start_time = time.time()
# Run the optimization strategy
result = controller.run()
self.final_time = time.time() - self.start_time
self.update_results()
self.print_run_results()
self.avg_best_result /= self.n_runs
self.avg_eval_count /= self.n_runs
self.avg_time /= self.n_runs
self.print_final_results()
def main():
"Testing routine."
samples = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]
controller = SerialController(lambda x: (x-0.123)*(x-0.123))
controller.strategy = FixedSampleStrategy(samples)
result = controller.run()
print("Final: {0:.3e} @ {1}".format(result.value, result.params))
def main():
"Testing routine."
samples = [0.0, 0.1, 0.2, 0.3, 0.4, 0.5]
controller = SerialController(lambda x: (x - 0.123) * (x - 0.123))
controller.strategy = FixedSampleStrategy(samples)
result = controller.run()
print(("Final: {0:.3e} @ {1}".format(result.value, result.params)))
def main():
"Testing routine."
controller = SerialController(lambda x: (x-0.123)*(x-0.123))
strategies = [MaxEvalStrategy(controller, 100),
FixedSampleStrategy(random_generator())]
controller.strategy = SimpleMergedStrategy(controller, strategies)
result = controller.run()
print(("Final: {0:.3e} @ {1}".format(result.value, result.params)))
def main():
"Testing routine."
controller = SerialController(lambda x: (x-0.123)*(x-0.123))
strategies = [MaxEvalStrategy(controller, 100),
FixedSampleStrategy(random_generator())]
controller.strategy = SimpleMergedStrategy(controller, strategies)
result = controller.run()
print("Final: {0:.3e} @ {1}".format(result.value, result.params))
def main():
"Testing routine."
controller = SerialController(lambda x: (x-0.123)*(x-0.123), skip=True)
strategy = ThreadStrategy(controller,
lambda f: golden_section(f.blocking_eval,
0.0, 1.0, 20))
controller.strategy = strategy
result = controller.run()
print("Final: {0:.3e} @ {1}".format(result.value, result.params))
def resume():
print("Resuming run...\n")
controller = SerialController(ackley.eval)
# Wrap controller in checkpoint object
controller = CheckpointController(controller, fname=fname)
result = controller.resume()
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 resume():
print("Resuming run...\n")
controller = SerialController(ackley.eval)
# Wrap controller in checkpoint object
controller = CheckpointController(controller, fname=fname)
result = controller.resume()
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 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 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_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 main():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/test_multisearch.log"):
os.remove("./logfiles/test_multisearch.log")
logging.basicConfig(filename="./logfiles/test_multisearch.log",
level=logging.INFO)
print("\nNumber of threads: 1")
print("Maximum number of evaluations: 500")
print(
"Search strategy: CandidateDYCORS, Genetic Algorithm, Multi-Start Gradient"
)
print("Experimental design: Latin Hypercube")
print("Surrogate: Cubic RBF")
nthreads = 1
maxeval = 500
nsamples = nthreads
data = Ackley(dim=10)
print(data.info)
# Create a strategy and a controller
sampling_method = [
CandidateDYCORS(data=data, numcand=100 * data.dim),
GeneticAlgorithm(data=data),
MultiStartGradient(data=data)
]
controller = SerialController(data.objfunction)
controller.strategy = \
SyncStrategyNoConstraints(
worker_id=0, data=data,
maxeval=maxeval, nsamples=nsamples,
response_surface=RBFInterpolant(surftype=CubicRBFSurface, maxp=maxeval),
exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim + 1)),
sampling_method=MultiSampling(sampling_method, [0, 1, 2]))
result = controller.run()
best, xbest = result.value, result.params[0]
print('Best value: {0}'.format(best))
print('Best solution: {0}\n'.format(
np.array_str(xbest,
max_line_width=np.inf,
precision=5,
suppress_small=True)))
def main():
if not os.path.exists("./logfiles"):
os.makedirs("logfiles")
if os.path.exists("./logfiles/test_multisearch.log"):
os.remove("./logfiles/test_multisearch.log")
logging.basicConfig(filename="./logfiles/test_multisearch.log",
level=logging.INFO)
print("\nNumber of threads: 1")
print("Maximum number of evaluations: 500")
print("Search strategy: CandidateDYCORS, Genetic Algorithm, Multi-Start Gradient")
print("Experimental design: Latin Hypercube")
print("Surrogate: Cubic RBF")
nthreads = 1
maxeval = 500
nsamples = nthreads
data = Ackley(dim=10)
print(data.info)
# Create a strategy and a controller
sampling_method = [CandidateDYCORS(data=data, numcand=100*data.dim),
GeneticAlgorithm(data=data), MultiStartGradient(data=data)]
controller = SerialController(data.objfunction)
controller.strategy = \
SyncStrategyNoConstraints(
worker_id=0, data=data,
maxeval=maxeval, nsamples=nsamples,
response_surface=RBFInterpolant(surftype=CubicRBFSurface, maxp=maxeval),
exp_design=SymmetricLatinHypercube(dim=data.dim, npts=2*(data.dim + 1)),
sampling_method=MultiSampling(sampling_method, [0, 1, 2]))
result = controller.run()
best, xbest = result.value, result.params[0]
print('Best value: {0}'.format(best))
print('Best solution: {0}\n'.format(
np.array_str(xbest, max_line_width=np.inf,
precision=5, suppress_small=True)))
def test_checkpoint_serial():
if os.path.isfile(fname):
os.remove(fname)
# Run for 1 seconds and kill the controller
p = multiprocessing.Process(target=init_serial, args=())
p.start()
time.sleep(3)
p.terminate()
p.join()
# Resume the run
controller = SerialController(ackley.eval)
resume(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 run(self):
"""
Run the optimization
@return: Nothing
"""
self.it = 0
n = len(self.circuit.buses)
m = len(self.circuit.branches)
self.xlow = zeros(n) # lower bounds
self.xup = ones(n) # upper bounds
self.progress_signal.emit(0.0)
self.progress_text.emit('Running stochastic voltage collapse...')
self.results = MonteCarloResults(n, m, self.max_eval)
# (1) Optimization problem
# print(data.info)
# (2) Experimental design
# Use a symmetric Latin hypercube with 2d + 1 samples
exp_des = SymmetricLatinHypercube(dim=self.dim, npts=2 * self.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)))
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()
#Keep note of tests done a
data1 = Ackley(dim=2)
data2 = Hartman3()
data3 = Hartman6()
data4 = Sphere(dim=2)
data5 = Quartic()
#1-----------------------------------------
exp_des = SymmetricLatinHypercube(dim=data1.dim, npts=2 * data1.dim + 1)
surrogate = GPRegression(20)
#surrogate = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)
adapt_samp = MultiStartGradient(data=data1)
controller = SerialController(data1.objfunction)
# (5) Use the sychronous strategy without non-bound constraints
strategy = SyncStrategyNoConstraints(worker_id=0,
data=data1,
maxeval=maxeval,
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
def run(self):
"""
Function that optimizes a MicroGrid Object
Args:
Returns:
"""
self.iteration = 0
self.raw_results = list()
self.progress_signal.emit(0)
self.progress_text_signal.emit(
'Optimizing facility sizes by surrogate optimization...')
# (1) Optimization problem
# print(data.info)
# (2) Experimental design
# Use a symmetric Latin hypercube with 2d + 1 samples
exp_des = SymmetricLatinHypercube(dim=self.dim, npts=2 * self.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 synchronous 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)))
self.solution = result.params[0]
# Extract function values from the controller
self.optimization_values = np.array(
[o.value for o in controller.fevals])
# turn the results into a DataFrame
data = np.array(self.raw_results)
self.x_fx = pd.DataFrame(data=data[:, 1:],
index=data[:, 0],
columns=[
'Solar', 'Wind', 'Battery', 'LCOE',
'Grid energy', 'Investment'
])
self.x_fx.sort_index(inplace=True)
self.progress_text_signal.emit('Done!')
self.done_signal.emit()
def main():
"Testing routine."
controller = SerialController(lambda x: (x - 0.123) * (x - 0.123))
controller.strategy = CoroutineStrategy(golden_coroutine(0.0, 1.0, 20))
result = controller.run()
print(("Final: {0:.3e} @ {1}".format(result.value, result.params)))
def main():
"Testing routine."
controller = SerialController(lambda x: (x-0.123)*(x-0.123))
controller.strategy = CoroutineStrategy(golden_coroutine(0.0, 1.0, 20))
result = controller.run()
print("Final: {0:.3e} @ {1}".format(result.value, result.params))
print data.info
# (2) Experimental design
# Use a symmetric Latin hypercube with 2d + 1 samples
exp_des = SymmetricLatinHypercube(dim=data.dim, npts=2 * data.dim + 1)
# (3) Surrogate model
# Use a cubic RBF interpolant with a linear tail
surrogate = RBFInterpolant(kernel=CubicKernel, tail=LinearTail, maxp=maxeval)
# (4) Adaptive sampling
# Use DYCORS with 100d candidate points
adapt_samp = CandidateDYCORS(data=data, numcand=100 * data.dim)
# Use the serial controller (uses only one thread)
controller = SerialController(data.objfunction)
# (5) Use the sychronous strategy without non-bound constraints
strategy = SyncStrategyNoConstraints(worker_id=0,
data=data,
maxeval=maxeval,
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
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)))