def run(self):
print('Start local optimization...')
maxf = self.request_data['optimization']['parameters']['maxf']
xtol = self.request_data['optimization']['parameters']['xtol']
ftol = self.request_data['optimization']['parameters']['ftol']
solver = NelderMeadSimplexSolver(len(self.initial_values))
solver.SetInitialPoints(self.initial_values)
solver.SetStrictRanges([i[0] for i in self.bounds], [i[1] for i in self.bounds])
solver.SetEvaluationLimits(evaluations=maxf)
solver.SetTermination(CRT(xtol=ftol, ftol=ftol))
# Inverting weights (*-1) to convert problem to minimizing
solver.Solve(
self.evaluate_single_solution,
ExtraArgs=([weight * -1 for weight in self.weights]),
callback=self.callback
)
solver.enable_signal_handler()
#Finally
self.callback(
individual=solver.Solution(),
final=True
)
return
def test_sumt1():
def costfunc(x):
x1 = x[0]
x2 = x[1]
return x1**4 - 2.*x1**2*x2 + x1**2 + x1*x2**2 - 2.*x1 + 4.
constraints_string = """
x1**2 + x2**2 - 2. = 0.
0.25*x1**2 + 0.75*x2**2 - 1. <= 0.
"""
ndim = 2
x0 = [3., 2.]
npop = 25
# print("constraints equations:%s" % (constraints_string.rstrip(),))
from mystic.solvers import DifferentialEvolutionSolver
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import VTR
#solver = DifferentialEvolutionSolver(ndim, npop)
solver = NelderMeadSimplexSolver(ndim)
solver.SetInitialPoints(x0)
term = VTR()
#FIXME: sumt, issolution no longer take constraints strings
end_solver = sumt(constraints_string, ndim, costfunc, solver,\
term, disp=True)
soln = end_solver.Solution()
assert issolution(constraints_string, soln)
def test_sumt2():
def costfunc(x):
return (x[0] - 1.)**2 + (x[1] - 2.)**2 + (x[2] - 3.)**4
x0 = [0., 0., 0.]
ndim = 3
constraints_string = """
x2 > 5.
4.*x1-5.*x3 < -1.
(x1-10.)**2 + (x2+1.)**2 < 50.
"""
print "constraints equations:%s" % (constraints_string.rstrip(), )
from mystic.solvers import DifferentialEvolutionSolver
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import VTR
#solver = DifferentialEvolutionSolver(ndim, npop)
solver = NelderMeadSimplexSolver(ndim)
solver.SetInitialPoints(x0)
term = VTR()
#FIXME: sumt, issolution no longer take constraints strings
end_solver = sumt(constraints_string, ndim, costfunc, solver,\
term, disp=True)
soln = end_solver.Solution()
print "final answer:", soln
print "constraints satisfied:", issolution(constraints_string, soln)
print "expected: [ 6.25827968 4.999961 5.20662288]", "\n"
def test06(terminate, func=lambda x: x[0], info=False, debug=False):
from mystic.solvers import NelderMeadSimplexSolver as NM
solver = NM(1)
solver.SetRandomInitialPoints()
solver.SetEvaluationLimits(8)
solver.Solve(func, VTR())
if debug: verbosity(solver)
return terminate(solver, info)
def run(self):
self.logger.info('Start local optimization...')
maxf = self.request_data['optimization']['parameters']['maxf']
xtol = self.request_data['optimization']['parameters']['xtol']
ftol = self.request_data['optimization']['parameters']['ftol']
solver = NelderMeadSimplexSolver(len(self.initial_values))
solver.SetInitialPoints(self.initial_values)
solver.SetStrictRanges([i[0] for i in self.bounds], [i[1] for i in self.bounds])
solver.SetEvaluationLimits(evaluations=maxf)
solver.SetTermination(CRT(xtol=ftol, ftol=ftol))
solver.Solve(
self.evaluate_single_solution,
callback=self.callback
)
solver.enable_signal_handler()
self.callback(
individual=solver.Solution(),
final=True
)
return
def runme():
# instantiate the solver
_solver = NelderMeadSimplexSolver(3)
lb, ub = [0., 0., 0.], [10., 10., 10.]
_solver.SetRandomInitialPoints(lb, ub)
_solver.SetEvaluationLimits(1000)
# add a monitor stream
stepmon = VerboseMonitor(1)
_solver.SetGenerationMonitor(stepmon)
# configure the bounds
_solver.SetStrictRanges(lb, ub)
# configure stop conditions
term = Or(VTR(), ChangeOverGeneration())
_solver.SetTermination(term)
# add a periodic dump to an archive
tmpfile = 'mysolver.pkl'
_solver.SetSaveFrequency(10, tmpfile)
# run the optimizer
_solver.Solve(rosen)
# get results
x = _solver.bestSolution
y = _solver.bestEnergy
# load the saved solver
solver = LoadSolver(tmpfile)
#os.remove(tmpfile)
# obligatory check that state is the same
assert all(x == solver.bestSolution)
assert y == solver.bestEnergy
# modify the termination condition
term = VTR(0.0001)
solver.SetTermination(term)
# run the optimizer
solver.Solve(rosen)
os.remove(tmpfile)
# check the solver serializes
_s = dill.dumps(solver)
return dill.loads(_s)
def optimize_linear(self, initial_values: List[float],
function) -> List[float]:
""" Function to optimize one solution linear by using the mystic library
Args:
initial_values: the initial solution that the solver starts with
function: the callback function that sends out the task to the database, awaits the result and takes it
back in
Returns:
solution: a linear optimized solution
"""
solver = NelderMeadSimplexSolver(dim=len(initial_values))
solver.SetInitialPoints(x0=initial_values)
solver.SetStrictRanges(self.low, self.up)
solver.SetEvaluationLimits(generations=self.maxf)
solver.SetTermination(CRT(self.xtol, self.ftol))
solver.Solve(function)
return list(solver.Solution())
def test_NelderMeadSimplexSolver_NCOG(self):
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import NormalizedChangeOverGeneration as NCOG
self.solver = NelderMeadSimplexSolver(self.ND)
self.term = NCOG()
self._run_solver()
def test_NelderMeadSimplexSolver_VTR(self):
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import VTR
self.solver = NelderMeadSimplexSolver(self.ND)
self.term = VTR()
self._run_solver()
def test_NelderMeadSimplexSolver_CRT(self): # Default for this solver
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import CandidateRelativeTolerance as CRT
self.solver = NelderMeadSimplexSolver(self.ND)
self.term = CRT()
self._run_solver()
def test_rosenbrock():
"""Test the 2-dimensional Rosenbrock function.
Testing 2-D Rosenbrock:
Expected: x=[1., 1.] and f=0
Using DifferentialEvolutionSolver:
Solution: [ 1.00000037 1.0000007 ]
f value: 2.29478683682e-13
Iterations: 99
Function evaluations: 3996
Time elapsed: 0.582273006439 seconds
Using DifferentialEvolutionSolver2:
Solution: [ 0.99999999 0.99999999]
f value: 3.84824937598e-15
Iterations: 100
Function evaluations: 4040
Time elapsed: 0.577210903168 seconds
Using NelderMeadSimplexSolver:
Solution: [ 0.99999921 1.00000171]
f value: 1.08732211477e-09
Iterations: 70
Function evaluations: 130
Time elapsed: 0.0190329551697 seconds
Using PowellDirectionalSolver:
Solution: [ 1. 1.]
f value: 0.0
Iterations: 28
Function evaluations: 859
Time elapsed: 0.113857030869 seconds
"""
print "Testing 2-D Rosenbrock:"
print "Expected: x=[1., 1.] and f=0"
from mystic.models import rosen as costfunc
ndim = 2
lb = [-5.]*ndim
ub = [5.]*ndim
x0 = [2., 3.]
maxiter = 10000
# DifferentialEvolutionSolver
print "\nUsing DifferentialEvolutionSolver:"
npop = 40
from mystic.solvers import DifferentialEvolutionSolver
from mystic.termination import ChangeOverGeneration as COG
from mystic.strategy import Rand1Bin
esow = Monitor()
ssow = Monitor()
solver = DifferentialEvolutionSolver(ndim, npop)
solver.SetInitialPoints(x0)
solver.SetStrictRanges(lb, ub)
solver.SetEvaluationLimits(generations=maxiter)
solver.SetEvaluationMonitor(esow)
solver.SetGenerationMonitor(ssow)
term = COG(1e-10)
time1 = time.time() # Is this an ok way of timing?
solver.Solve(costfunc, term, strategy=Rand1Bin)
sol = solver.Solution()
time_elapsed = time.time() - time1
fx = solver.bestEnergy
print "Solution: ", sol
print "f value: ", fx
print "Iterations: ", solver.generations
print "Function evaluations: ", len(esow.x)
print "Time elapsed: ", time_elapsed, " seconds"
assert almostEqual(fx, 2.29478683682e-13, tol=3e-3)
# DifferentialEvolutionSolver2
print "\nUsing DifferentialEvolutionSolver2:"
npop = 40
from mystic.solvers import DifferentialEvolutionSolver2
from mystic.termination import ChangeOverGeneration as COG
from mystic.strategy import Rand1Bin
esow = Monitor()
ssow = Monitor()
solver = DifferentialEvolutionSolver2(ndim, npop)
solver.SetInitialPoints(x0)
solver.SetStrictRanges(lb, ub)
solver.SetEvaluationLimits(generations=maxiter)
solver.SetEvaluationMonitor(esow)
solver.SetGenerationMonitor(ssow)
term = COG(1e-10)
time1 = time.time() # Is this an ok way of timing?
solver.Solve(costfunc, term, strategy=Rand1Bin)
sol = solver.Solution()
time_elapsed = time.time() - time1
fx = solver.bestEnergy
print "Solution: ", sol
print "f value: ", fx
print "Iterations: ", solver.generations
print "Function evaluations: ", len(esow.x)
print "Time elapsed: ", time_elapsed, " seconds"
assert almostEqual(fx, 3.84824937598e-15, tol=3e-3)
# NelderMeadSimplexSolver
print "\nUsing NelderMeadSimplexSolver:"
from mystic.solvers import NelderMeadSimplexSolver
from mystic.termination import CandidateRelativeTolerance as CRT
esow = Monitor()
ssow = Monitor()
solver = NelderMeadSimplexSolver(ndim)
solver.SetInitialPoints(x0)
solver.SetStrictRanges(lb, ub)
solver.SetEvaluationLimits(generations=maxiter)
solver.SetEvaluationMonitor(esow)
solver.SetGenerationMonitor(ssow)
term = CRT()
time1 = time.time() # Is this an ok way of timing?
solver.Solve(costfunc, term)
sol = solver.Solution()
time_elapsed = time.time() - time1
fx = solver.bestEnergy
print "Solution: ", sol
print "f value: ", fx
print "Iterations: ", solver.generations
print "Function evaluations: ", len(esow.x)
print "Time elapsed: ", time_elapsed, " seconds"
assert almostEqual(fx, 1.08732211477e-09, tol=3e-3)
# PowellDirectionalSolver
print "\nUsing PowellDirectionalSolver:"
from mystic.solvers import PowellDirectionalSolver
from mystic.termination import NormalizedChangeOverGeneration as NCOG
esow = Monitor()
ssow = Monitor()
solver = PowellDirectionalSolver(ndim)
solver.SetInitialPoints(x0)
solver.SetStrictRanges(lb, ub)
solver.SetEvaluationLimits(generations=maxiter)
solver.SetEvaluationMonitor(esow)
solver.SetGenerationMonitor(ssow)
term = NCOG(1e-10)
time1 = time.time() # Is this an ok way of timing?
solver.Solve(costfunc, term)
sol = solver.Solution()
time_elapsed = time.time() - time1
fx = solver.bestEnergy
print "Solution: ", sol
print "f value: ", fx
print "Iterations: ", solver.generations
print "Function evaluations: ", len(esow.x)
print "Time elapsed: ", time_elapsed, " seconds"
assert almostEqual(fx, 0.0, tol=3e-3)
assert LoadSolver(solver._state) == None solver = PowellDirectionalSolver(3) solver.SetRandomInitialPoints([0., 0., 0.], [10., 10., 10.]) term = VTR() tmpfile = 'mysolver.pkl' solver.SetSaveFrequency(10, tmpfile) solver.Solve(rosen, term) x = solver.bestSolution y = solver.bestEnergy _solver = LoadSolver(tmpfile) os.remove(tmpfile) assert all(x == _solver.bestSolution) assert y == _solver.bestEnergy solver = NelderMeadSimplexSolver(3) solver.SetRandomInitialPoints([0., 0., 0.], [10., 10., 10.]) term = VTR() solver.Solve(rosen, term) x = solver.bestSolution y = solver.bestEnergy assert solver._state == None assert LoadSolver(solver._state) == None solver = NelderMeadSimplexSolver(3) solver.SetRandomInitialPoints([0., 0., 0.], [10., 10., 10.]) term = VTR() solver.SetSaveFrequency(10, tmpfile) solver.Solve(rosen, term) x = solver.bestSolution y = solver.bestEnergy
random_seed(123)
lb = [-100, -100, -100]
ub = [1000, 1000, 1000]
ndim = len(lb)
maxiter = 10
maxfun = 1e+6
def cost(x):
ax, bx, c = x
return (ax)**2 - bx + c
monitor = Monitor()
solver = NelderMeadSimplexSolver(ndim)
solver.SetRandomInitialPoints(min=lb, max=ub)
solver.SetStrictRanges(min=lb, max=ub)
solver.SetEvaluationLimits(maxiter, maxfun)
solver.SetGenerationMonitor(monitor)
solver.Solve(cost)
solved = solver.bestSolution
monitor.info("solved: %s" % solved)
lmon = len(monitor)
assert solver.bestEnergy == monitor.y[-1]
for xs, x in zip(solved, monitor.x[-1]):
assert xs == x
solver.SetEvaluationLimits(maxiter * 2, maxfun)
getch()
# draw frame and exact coefficients
plot_exact()
# select parameter bounds constraints
from numpy import inf
min_bounds = [0, -1, -300, -1, 0, -1, -100, -inf, -inf]
max_bounds = [200, 1, 0, 1, 200, 1, 0, inf, inf]
# configure monitors
stepmon = VerboseMonitor(100)
evalmon = Monitor()
# use Nelder-Mead to solve 8th-order Chebyshev coefficients
solver = NelderMeadSimplexSolver(ndim)
solver.SetInitialPoints(x0)
solver.SetEvaluationLimits(generations=999)
solver.SetEvaluationMonitor(evalmon)
solver.SetGenerationMonitor(stepmon)
solver.SetStrictRanges(min_bounds, max_bounds)
solver.enable_signal_handler()
solver.Solve(chebyshev8cost, termination=CRT(1e-4,1e-4), \
sigint_callback=plot_solution)
solution = solver.bestSolution
# get solved coefficients and Chi-Squared (from solver members)
iterations = solver.generations
cost = solver.bestEnergy
print "Generation %d has best Chi-Squared: %f" % (iterations, cost)
print "Solved Coefficients:\n %s\n" % poly1d(solver.bestSolution)
# min = [-0.999, -0.999, -0.999]
# max = [200.001, 100.001, numpy.inf]
# min = [-0.999, -0.999, 0.999]
# max = [2.001, 1.001, 1.001]
print("Nelder-Mead Simplex")
print("===================")
start = time.time()
from mystic.monitors import Monitor, VerboseMonitor
#stepmon = VerboseMonitor(1)
stepmon = Monitor() #VerboseMonitor(10)
from mystic.termination import CandidateRelativeTolerance as CRT
#from mystic._scipyoptimize import fmin
from mystic.solvers import fmin, NelderMeadSimplexSolver
#print(fmin(rosen,x0,retall=0,full_output=0,maxiter=121))
solver = NelderMeadSimplexSolver(len(x0))
solver.SetInitialPoints(x0)
solver.SetStrictRanges(min,max)
solver.SetEvaluationLimits(generations=146)
solver.SetGenerationMonitor(stepmon)
solver.enable_signal_handler()
solver.Solve(rosen, CRT(xtol=4e-5), disp=1)
print(solver.bestSolution)
#print("Current function value: %s" % solver.bestEnergy)
#print("Iterations: %s" % solver.generations)
#print("Function evaluations: %s" % solver.evaluations)
times.append(time.time() - start)
algor.append('Nelder-Mead Simplex\t')
for k,t in zip(algor,times):
# min = [-0.999, -0.999, 0.999]
# max = [2.001, 1.001, 1.001]
print "Nelder-Mead Simplex"
print "==================="
start = time.time()
from mystic.monitors import Monitor, VerboseMonitor
# stepmon = VerboseMonitor(1)
stepmon = Monitor() # VerboseMonitor(10)
from mystic.termination import CandidateRelativeTolerance as CRT
# from mystic._scipyoptimize import fmin
from mystic.solvers import fmin, NelderMeadSimplexSolver
# print fmin(rosen,x0,retall=0,full_output=0,maxiter=121)
solver = NelderMeadSimplexSolver(len(x0))
solver.SetInitialPoints(x0)
solver.SetStrictRanges(min, max)
solver.SetEvaluationLimits(generations=146)
solver.SetGenerationMonitor(stepmon)
solver.enable_signal_handler()
solver.Solve(rosen, CRT(xtol=4e-5), disp=1)
print solver.bestSolution
# print "Current function value: %s" % solver.bestEnergy
# print "Iterations: %s" % solver.generations
# print "Function evaluations: %s" % solver.evaluations
times.append(time.time() - start)
algor.append("Nelder-Mead Simplex\t")
for k in range(len(algor)):
