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)):