def dakota(cost,lb,ub): from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import CandidateRelativeTolerance as CRT from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import getch, random_seed random_seed(123) #stepmon = VerboseMonitor(100) stepmon = Monitor() evalmon = Monitor() ndim = len(lb) # [(1 + RVend) - RVstart] + 1 solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) tol = convergence_tol solver.Solve(cost,termination=CRT(tol,tol),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change) print solver.bestSolution diameter = -solver.bestEnergy / scale func_evals = solver.evaluations return diameter, func_evals
def optimize(cost,lower,upper): from mystic.tools import random_seed from pyina.launchers import Mpi as Pool random_seed(123) # generate a set of random starting points initial_values = samplepts(lower,upper,npts) # run optimizer for each grid point lb = [lower for i in range(len(initial_values))] ub = [upper for i in range(len(initial_values))] cf = [cost for i in range(len(initial_values))] # map:: params, energy, func_evals = local_optimize(cost,x0,lb,ub) results = Pool(nnodes).map(local_optimize, cf, initial_values, lb, ub) #print "results = %s" % results # get the results with the lowest energy best = list(results[0][0]), results[0][1] func_evals = results[0][2] for result in results[1:]: func_evals += result[2] # add function evaluations if result[1] < best[1]: # compare energy best = list(result[0]), result[1] # return best print "solved: %s" % best[0] scale = 1.0 diameter_squared = -best[1] / scale #XXX: scale != 0 return diameter_squared, func_evals
def optimize(cost,lb,ub): from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import CandidateRelativeTolerance as CRT from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed random_seed(123) #stepmon = VerboseMonitor(100) stepmon = Monitor() evalmon = Monitor() ndim = len(lb) # [(1 + RVend) - RVstart] + 1 solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) tol = convergence_tol solver.Solve(cost,termination=CRT(tol,tol),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change) solved = solver.bestSolution #if DEBUG: print("solved: %s" % solved) diameter_squared = -solver.bestEnergy / scale #XXX: scale != 0 func_evals = solver.evaluations return solved, diameter_squared, func_evals
def optimize(cost,lb,ub): from pathos.pools import ProcessPool as Pool from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import CandidateRelativeTolerance as CRT from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed random_seed(123) #stepmon = VerboseMonitor(100) stepmon = Monitor() evalmon = Monitor() ndim = len(lb) # [(1 + RVend) - RVstart] + 1 solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.SetMapper(Pool().map) tol = convergence_tol solver.Solve(cost,termination=CRT(tol,tol),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change) print("solved: %s" % solver.bestSolution) scale = 1.0 diameter_squared = -solver.bestEnergy / scale #XXX: scale != 0 func_evals = solver.evaluations return diameter_squared, func_evals
def optimize(cost, bounds, tolerance, _constraints): (lb,ub) = bounds from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import VTR from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed if debug: random_seed(123) evalmon = Monitor(); stepmon = Monitor() if debug: stepmon = VerboseMonitor(10) ndim = len(lb) solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.Solve(cost,termination=VTR(tolerance),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change, \ constraints = _constraints) solved = solver.Solution() diameter_squared = solver.bestEnergy func_evals = len(evalmon) return solved, diameter_squared, func_evals
def main(self, *args, **kwds): # general solver # exception for DifferentialEvolutionSolver2 if self.inventory.solver == 'DifferentialEvolution2': solvername = DifferentialEvolutionSolver2 else: solvername = eval(self.inventory.solver + 'Solver') # create the solver try: NP = self.mod.NP solver = solvername(self.mod.ND, NP) except: solver = solvername(self.mod.ND) costfunction = self.mod.cost termination = self.mod.termination from mystic.tools import random_seed random_seed(123) # set initial points try: solver.SetInitialPoints(self.mod.x0) except: solver.SetRandomInitialPoints(self.mod.min, self.mod.max) # set maximum number of iterations try: maxiter = self.mod.maxiter solver.SetEvaluationLimits(generations=maxiter) except: pass # set bounds, if applicable try: min_bounds = self.mod.min_bounds max_bounds = self.mod.max_bounds solver.SetStrictRanges(min_bounds, max_bounds) except: pass # additional arguments/kwds to the Solve() call try: solverkwds = self.mod.solverkwds except: solverkwds = {} solver.Solve(costfunction, termination, **solverkwds) self.solution = solver.Solution() return
def mystic_optimize(point): from mystic.monitors import Monitor, VerboseMonitor from mystic.tools import getch, random_seed random_seed(123) from mystic.solvers import NelderMeadSimplexSolver as fmin from mystic.termination import CandidateRelativeTolerance as CRT simplex, esow = VerboseMonitor(50), Monitor() solver = fmin(len(point)) solver.SetInitialPoints(point) solver.SetEvaluationMonitor(esow) solver.SetGenerationMonitor(simplex) solver.Solve(cost_function, CRT()) solution = solver.Solution() return solution
def mystic_optimize2(point): from mystic.monitors import Monitor, VerboseMonitor from mystic.tools import getch, random_seed random_seed(123) from mystic.solvers import DifferentialEvolutionSolver as de from mystic.termination import ChangeOverGeneration as COG NPOP = 50 simplex, esow = VerboseMonitor(50), Monitor() solver = de(len(point),NPOP) solver.SetInitialPoints(point) solver.SetEvaluationMonitor(esow) solver.SetGenerationMonitor(simplex) solver.Solve(cost_function, COG(generations=100), \ CrossProbability=0.5, ScalingFactor=0.5) solution = solver.Solution() return solution
def __test2(): # From branches/UQ/math/cut.py from mystic.tools import random_seed random_seed(123) lower = [-60.0, -10.0, -50.0] upper = [105.0, 30.0, 75.0] def model(x): x1,x2,x3 = x if x1 > (x2 + x3): return x1*x2 - x3 return 0.0 failure,success = sample(model,lower,upper) pof = float(failure) / float(failure + success) print "PoF using method 1: %s" % pof random_seed(123) print "PoF using method 2: %s" % sampled_pof(model,lower,upper)
def __test2(): # From branches/UQ/math/cut.py from mystic.tools import random_seed random_seed(123) lower = [-60.0, -10.0, -50.0] upper = [105.0, 30.0, 75.0] def model(x): x1, x2, x3 = x if x1 > (x2 + x3): return x1 * x2 - x3 return 0.0 failure, success = sample(model, lower, upper) pof = float(failure) / float(failure + success) print "PoF using method 1: %s" % pof random_seed(123) print "PoF using method 2: %s" % sampled_pof(model, lower, upper)
def optimize(cost,_bounds,_constraints): from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import ChangeOverGeneration as COG from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed from mystic.termination import Or, CollapseWeight, CollapsePosition, state if debug: random_seed(123) # or 666 to force impose_unweighted reweighting stepmon = VerboseMonitor(1,1) else: stepmon = VerboseMonitor(10) if verbose else Monitor() stepmon._npts = npts evalmon = Monitor() lb,ub = _bounds ndim = len(lb) solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.SetConstraints(_constraints) tol = convergence_tol term = Or(COG(tol,ngen), CollapseWeight(), CollapsePosition()) solver.Solve(cost,termination=term,strategy=Best1Exp, disp=verbose, \ CrossProbability=crossover,ScalingFactor=percent_change) #while collapse and solver.Collapse(verbose): #XXX: total_evaluations? # if debug: print(state(solver._termination).keys()) # solver.Solve() #XXX: cost, term, strategy, cross, scale ? # if debug: solver.SaveSolver('debug.pkl') solved = solver.bestSolution #print("solved: %s" % solver.Solution()) func_max = MINMAX * solver.bestEnergy #NOTE: -solution assumes -Max #func_max = 1.0 + MINMAX*solver.bestEnergy #NOTE: 1-sol => 1-success = fail func_evals = solver.evaluations from mystic.munge import write_support_file write_support_file(stepmon, npts=npts) return solved, func_max, func_evals
def test2(monitor, diffenv=None): if diffenv == True: #from mystic.solvers import DifferentialEvolutionSolver as DE from mystic.solvers import DifferentialEvolutionSolver2 as DE elif diffenv == False: from mystic.solvers import NelderMeadSimplexSolver as noDE else: from mystic.solvers import PowellDirectionalSolver as noDE from mystic.termination import ChangeOverGeneration as COG from mystic.tools import getch, random_seed random_seed(123) lb = [-100, -100, -100] ub = [1000, 1000, 1000] ndim = len(lb) npop = 5 maxiter = 10 maxfun = 1e+6 convergence_tol = 1e-10 ngen = 100 crossover = 0.9 percent_change = 0.9 def cost(x): ax, bx, c = x return (ax)**2 - bx + c if diffenv == True: solver = DE(ndim, npop) else: solver = noDE(ndim) solver.SetRandomInitialPoints(min=lb, max=ub) solver.SetStrictRanges(min=lb, max=ub) solver.SetEvaluationLimits(maxiter, maxfun) solver.SetEvaluationMonitor(monitor) #solver.SetGenerationMonitor(monitor) tol = convergence_tol solver.Solve(cost, termination=COG(tol, ngen)) solved = solver.Solution() monitor.info("solved: %s" % solved) func_max = -solver.bestEnergy return solved, func_max
def test2(monitor, diffenv=None): if diffenv == True: #from mystic.solvers import DifferentialEvolutionSolver as DE from mystic.solvers import DifferentialEvolutionSolver2 as DE elif diffenv == False: from mystic.solvers import NelderMeadSimplexSolver as noDE else: from mystic.solvers import PowellDirectionalSolver as noDE from mystic.termination import ChangeOverGeneration as COG from mystic.tools import getch, random_seed random_seed(123) lb = [-100,-100,-100] ub = [1000,1000,1000] ndim = len(lb) npop = 5 maxiter = 10 maxfun = 1e+6 convergence_tol = 1e-10; ngen = 100 crossover = 0.9 percent_change = 0.9 def cost(x): ax,bx,c = x return (ax)**2 - bx + c if diffenv == True: solver = DE(ndim,npop) else: solver = noDE(ndim) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(monitor) #solver.SetGenerationMonitor(monitor) tol = convergence_tol solver.Solve(cost, termination=COG(tol,ngen)) solved = solver.Solution() monitor.info("solved: %s" % solved) func_max = -solver.bestEnergy return solved, func_max
def optimize(cost, lower, upper, nbins): from mystic.tools import random_seed from pyina.launchers import TorqueMpi as Pool random_seed(123) # generate arrays of points defining a grid in parameter space grid_dimensions = len(lower) bins = [] for i in range(grid_dimensions): step = abs(upper[i] - lower[i]) / nbins[i] bins.append([lower[i] + (j + 0.5) * step for j in range(nbins[i])]) # build a grid of starting points from mystic.math.grid import gridpts from pool_helper import local_optimize from pool_helper import nnodes, queue, timelimit initial_values = gridpts(bins) # run optimizer for each grid point lb = [lower for i in range(len(initial_values))] ub = [upper for i in range(len(initial_values))] cf = [cost for i in range(len(initial_values))] # map:: params, energy, func_evals = local_optimize(cost,x0,lb,ub) config = {'queue': queue, 'timelimit': timelimit} results = Pool(nnodes, **config).map(local_optimize, cf, initial_values, lb, ub) #print("results = %s" % results) # get the results with the lowest energy best = list(results[0][0]), results[0][1] func_evals = results[0][2] for result in results[1:]: func_evals += result[2] # add function evaluations if result[1] < best[1]: # compare energy best = list(result[0]), result[1] # return best print("solved: %s" % best[0]) scale = 1.0 diameter_squared = -best[1] / scale #XXX: scale != 0 return diameter_squared, func_evals
def optimize(cost,lower,upper,nbins): from mystic.tools import random_seed from pyina.launchers import TorqueMpi as Pool random_seed(123) # generate arrays of points defining a grid in parameter space grid_dimensions = len(lower) bins = [] for i in range(grid_dimensions): step = abs(upper[i] - lower[i])/nbins[i] bins.append( [lower[i] + (j+0.5)*step for j in range(nbins[i])] ) # build a grid of starting points from mystic.math.grid import gridpts from pool_helper import local_optimize from pool_helper import nnodes, queue, timelimit initial_values = gridpts(bins) # run optimizer for each grid point lb = [lower for i in range(len(initial_values))] ub = [upper for i in range(len(initial_values))] cf = [cost for i in range(len(initial_values))] # map:: params, energy, func_evals = local_optimize(cost,x0,lb,ub) config = {'queue':queue, 'timelimit':timelimit} results = Pool(nnodes, **config).map(local_optimize,cf,initial_values,lb,ub) #print "results = %s" % results # get the results with the lowest energy best = list(results[0][0]), results[0][1] func_evals = results[0][2] for result in results[1:]: func_evals += result[2] # add function evaluations if result[1] < best[1]: # compare energy best = list(result[0]), result[1] # return best print "solved: %s" % best[0] scale = 1.0 diameter_squared = -best[1] / scale #XXX: scale != 0 return diameter_squared, func_evals
c([1,],1) c([2,],2) c.prepend(b) assert len(b) == 1 assert len(c) == 3 c([3,],3) assert c.x == [[0], [1], [2], [3]] assert len(c) == 4 c.prepend(c) assert c.x == [[0], [1], [2], [3], [0], [1], [2], [3]] assert len(c) == 8 from mystic.solvers import NelderMeadSimplexSolver from mystic.tools import random_seed 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)
plt.legend(["Exact", "Fitted"]) plt.axis([-1.4, 1.4, -2, 8], 'k-') plt.draw() plt.pause(0.001) return if __name__ == '__main__': print("Differential Evolution") print("======================") # set range for random initial guess ndim = 9 x0 = [(-100, 100)] * ndim random_seed(321) # draw frame and exact coefficients plot_exact() # use DE to solve 8th-order Chebyshev coefficients npop = 10 * ndim solution = diffev(chebyshev8cost, x0, npop) # use pretty print for polynomials print(poly1d(solution)) # compare solution with actual 8th-order Chebyshev coefficients print("\nActual Coefficients:\n %s\n" % poly1d(chebyshev8coeffs)) # plot solution versus exact coefficients
NP = 40 MAX_GENERATIONS = NP*NP NNODES = NP/5 seed = 100 if __name__=='__main__': def print_solution(func): print poly1d(func) return psow = VerboseMonitor(10) ssow = VerboseMonitor(10) random_seed(seed) print "first sequential..." solver = DifferentialEvolutionSolver2(ND,NP) #XXX: sequential solver.SetRandomInitialPoints(min=[-100.0]*ND, max=[100.0]*ND) solver.SetEvaluationLimits(generations=MAX_GENERATIONS) solver.SetGenerationMonitor(ssow) solver.Solve(ChebyshevCost, VTR(0.01), strategy=Best1Exp, \ CrossProbability=1.0, ScalingFactor=0.9, disp=1) print "" print_solution( solver.bestSolution ) #''' random_seed(seed) print "\n and now parallel..." solver2 = DifferentialEvolutionSolver2(ND,NP) #XXX: parallel solver2.SetMapper(Pool(NNODES).map)
#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 1997-2016 California Institute of Technology. # Copyright (c) 2016-2022 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/mystic/blob/master/LICENSE from mystic.constraints import * from mystic.solvers import * from mystic.math import almostEqual from mystic.tools import random_seed random_seed(42) def test_one_liner(solver): from mystic.math.measures import mean, spread @with_spread(5.0) @with_mean(5.0) def constraints(x): return x def cost(x): return abs(sum(x) - 5.0) from numpy import array x = array([1,2,3,4,5]) y = solver(cost, x, constraints=constraints, disp=False) assert almostEqual(mean(y), 5.0, tol=1e-15) assert almostEqual(spread(y), 5.0, tol=1e-15)
def impose_expectation(param, f, npts, bounds=None, weights=None, **kwds): """impose a given expextation value (m +/- D) on a given function f. Optimiziation on f over the given bounds seeks a mean 'm' with deviation 'D'. (this function is not 'mean-, range-, or variance-preserving') Inputs: param -- a tuple of target parameters: param = (mean, deviation) f -- a function that takes a list and returns a number npts -- a tuple of dimensions of the target product measure bounds -- a tuple of sample bounds: bounds = (lower_bounds, upper_bounds) weights -- a list of sample weights Additional Inputs: constraints -- a function that takes a nested list of N x 1D discrete measure positions and weights x' = constraints(x, w) Outputs: samples -- a list of sample positions For example: >>> # provide the dimensions and bounds >>> nx = 3; ny = 2; nz = 1 >>> x_lb = [10.0]; y_lb = [0.0]; z_lb = [10.0] >>> x_ub = [50.0]; y_ub = [9.0]; z_ub = [90.0] >>> >>> # prepare the bounds >>> lb = (nx * x_lb) + (ny * y_lb) + (nz * z_lb) >>> ub = (nx * x_ub) + (ny * y_ub) + (nz * z_ub) >>> >>> # generate a list of samples with mean +/- dev imposed >>> mean = 2.0; dev = 0.01 >>> samples = impose_expectation((mean,dev), f, (nx,ny,nz), (lb,ub)) >>> >>> # test the results by calculating the expectation value for the samples >>> expectation(f, samples) >>> 2.00001001012246015 """ # param[0] is the target mean # param[1] is the acceptable deviation from the target mean # FIXME: the following is a HACK to recover from lost 'weights' information # we 'mimic' discrete measures using the product measure weights # plug in the 'constraints' function: samples' = constrain(samples, weights) constrain = None # default is no constraints if 'constraints' in kwds: constrain = kwds['constraints'] if not constrain: # if None (default), there are no constraints constraints = lambda x: x else: #XXX: better to use a standard "xk' = constrain(xk)" interface ? def constraints(rv): coords = _pack( _nested(rv,npts) ) coords = zip(*coords) # 'mimic' a nested list coords = constrain(coords, [weights for i in range(len(coords))]) coords = zip(*coords) # revert back to a packed list return _flat( _unpack(coords,npts) ) # construct cost function to reduce deviation from expectation value def cost(rv): """compute cost from a 1-d array of model parameters, where: cost = | E[model] - m |**2 """ # from mystic.math.measures import _pack, _nested, expectation samples = _pack( _nested(rv,npts) ) Ex = expectation(f, samples, weights) return (Ex - param[0])**2 # if bounds are not set, use the default optimizer bounds if not bounds: lower_bounds = []; upper_bounds = [] for n in npts: lower_bounds += [None]*n upper_bounds += [None]*n else: lower_bounds, upper_bounds = bounds # construct and configure optimizer debug = kwds['debug'] if 'debug' in kwds else False npop = 200 maxiter = 1000; maxfun = 1e+6 crossover = 0.9; percent_change = 0.9 def optimize(cost,(lb,ub),tolerance,_constraints): from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import VTR from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed if debug: random_seed(123) evalmon = Monitor(); stepmon = Monitor() if debug: stepmon = VerboseMonitor(10) ndim = len(lb) solver = DifferentialEvolutionSolver2(ndim,npop) solver.SetRandomInitialPoints(min=lb,max=ub) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.Solve(cost,termination=VTR(tolerance),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change, \ constraints = _constraints) solved = solver.Solution() diameter_squared = solver.bestEnergy func_evals = len(evalmon) return solved, diameter_squared, func_evals
#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 1997-2016 California Institute of Technology. # Copyright (c) 2016-2019 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/mystic/blob/master/LICENSE from mystic.constraints import * from mystic.penalty import quadratic_equality from mystic.coupler import inner from mystic.math import almostEqual from mystic.tools import random_seed random_seed(213) def test_penalize(): from mystic.math.measures import mean, spread def mean_constraint(x, target): return mean(x) - target def range_constraint(x, target): return spread(x) - target @quadratic_equality(condition=range_constraint, kwds={'target':5.0}) @quadratic_equality(condition=mean_constraint, kwds={'target':5.0}) def penalty(x): return 0.0 def cost(x): return abs(sum(x) - 5.0)
def _run_solver(self, early_terminate=False, **kwds): from mystic.monitors import Monitor import numpy from mystic.tools import random_seed seed = 111 if self.maxiter is None else 321 #XXX: good numbers... random_seed(seed) esow = Monitor() ssow = Monitor() solver = self.solver solver.SetRandomInitialPoints(min=self.min, max=self.max) if self.usebounds: solver.SetStrictRanges(self.min, self.max) if self.uselimits: solver.SetEvaluationLimits(self.maxiter, self.maxfun) if self.useevalmon: solver.SetEvaluationMonitor(esow) if self.usestepmon: solver.SetGenerationMonitor(ssow) #### run solver, but trap output _stdout = trap_stdout() solver.Solve(self.costfunction, self.term, **kwds) out = release_stdout(_stdout) ################################ sol = solver.Solution() iter = 1 #if self.uselimits and self.maxiter == 0: iter=0 # sanity check solver internals self.assertTrue(solver.generations == len(solver._stepmon._y) - iter) self.assertTrue(list( solver.bestSolution) == solver._stepmon.x[-1]) #XXX self.assertTrue(solver.bestEnergy == solver._stepmon.y[-1]) self.assertTrue(solver.solution_history == solver._stepmon.x) self.assertTrue(solver.energy_history == solver._stepmon.y) if self.usestepmon: self.assertTrue(ssow.x == solver._stepmon.x) self.assertTrue(ssow.y == solver._stepmon.y) self.assertTrue(ssow._y == solver._stepmon._y) if self.useevalmon: self.assertTrue(solver.evaluations == len(solver._evalmon._y)) self.assertTrue(esow.x == solver._evalmon.x) self.assertTrue(esow.y == solver._evalmon.y) self.assertTrue(esow._y == solver._evalmon._y) # Fail appropriately for solver/termination mismatch if early_terminate: self.assertTrue(solver.generations < 2) warn = "Warning: Invalid termination condition (nPop < 2)" self.assertTrue(warn in out) return g = solver.generations calls = [(g + 1) * self.NP, (2 * g) + 1] iters = [g] # Test early terminations if self.uselimits and self.maxfun == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxfun == 1: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 1: calls += [20] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter and 2 <= self.maxiter <= 5: calls += [52, 79, 107, 141] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return # Verify solution is close to exact #print(sol) for i in range(len(sol)): self.assertAlmostEqual(sol[i], self.exact[i], self.precision) return
# Copyright (c) 2010-2016 California Institute of Technology. # Copyright (c) 2016-2020 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # # coded by Alta Fang, 2010 """ A few basic symbolic constraints tests, but in no way a comprehensive suite. """ from numpy import asarray #from mystic.restarts import sumt from mystic.constraints import issolution, as_constraint, solve as _solve from mystic.coupler import inner from mystic.symbolic import * from mystic.tools import random_seed from mystic.math import almostEqual random_seed(24) 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.]
pylab.plot(x,y,style) pylab.legend(["Exact","Fitted"]) pylab.axis([-1.4,1.4,-2,8],'k-') pylab.draw() return if __name__ == '__main__': print "Differential Evolution" print "======================" # set range for random initial guess ndim = 9 x0 = [(-100,100)]*ndim random_seed(321) # draw frame and exact coefficients plot_exact() # use DE to solve 8th-order Chebyshev coefficients npop = 10*ndim solution = diffev(chebyshev8cost,x0,npop) # use pretty print for polynomials print poly1d(solution) # compare solution with actual 8th-order Chebyshev coefficients print "\nActual Coefficients:\n %s\n" % poly1d(chebyshev8coeffs) # plot solution versus exact coefficients
#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 1997-2016 California Institute of Technology. # Copyright (c) 2016-2022 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/mystic/blob/master/LICENSE from mystic.constraints import * from mystic.penalty import quadratic_equality from mystic.coupler import inner from mystic.math import almostEqual from mystic.tools import random_seed random_seed(669) def test_penalize(): from mystic.math.measures import mean, spread def mean_constraint(x, target): return mean(x) - target def range_constraint(x, target): return spread(x) - target @quadratic_equality(condition=range_constraint, kwds={'target': 5.0}) @quadratic_equality(condition=mean_constraint, kwds={'target': 5.0}) def penalty(x): return 0.0
def _run_solver(self, early_terminate=False, **kwds): from mystic.monitors import Monitor import numpy from mystic.tools import random_seed random_seed(321) esow = Monitor() ssow = Monitor() solver = self.solver solver.SetRandomInitialPoints(min = self.min, max = self.max) if self.usebounds: solver.SetStrictRanges(self.min, self.max) if self.uselimits: solver.SetEvaluationLimits(self.maxiter, self.maxfun) if self.useevalmon: solver.SetEvaluationMonitor(esow) if self.usestepmon: solver.SetGenerationMonitor(ssow) solver.Solve(self.costfunction, self.term, **kwds) sol = solver.Solution() iter=1 #if self.uselimits and self.maxiter == 0: iter=0 # sanity check solver internals self.assertTrue(solver.generations == len(solver._stepmon.y)-iter) self.assertTrue(list(solver.bestSolution) == solver._stepmon.x[-1]) #XXX self.assertTrue(solver.bestEnergy == solver._stepmon.y[-1]) self.assertTrue(solver.solution_history == solver._stepmon.x) self.assertTrue(solver.energy_history == solver._stepmon.y) if self.usestepmon: self.assertTrue(ssow.x == solver._stepmon.x) self.assertTrue(ssow.y == solver._stepmon.y) if self.useevalmon: self.assertTrue(solver.evaluations == len(solver._evalmon.y)) self.assertTrue(esow.x == solver._evalmon.x) self.assertTrue(esow.y == solver._evalmon.y) # Fail appropriately for solver/termination mismatch if early_terminate: self.assertTrue(solver.generations < 2) return g = solver.generations calls = [(g+1)*self.NP, (2*g)+1] iters = [g] # Test early terminations if self.uselimits and self.maxfun == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxfun == 1: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 1: calls += [20] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter >= 2 and self.maxiter <= 5: calls += [52, 79, 107, 141] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return # Verify solution is close to exact print sol for i in range(len(sol)): self.assertAlmostEqual(sol[i], self.exact[i], self.precision) return
def impose_expectation(param, f, npts, bounds=None, weights=None, **kwds): """impose a given expextation value (m +/- D) on a given function f. Optimization on f over the given bounds seeks a mean 'm' with deviation 'D'. (this function is not 'mean-, range-, or variance-preserving') Inputs: param -- a tuple of target parameters: param = (mean, deviation) f -- a function that takes a list and returns a number npts -- a tuple of dimensions of the target product measure bounds -- a tuple of sample bounds: bounds = (lower_bounds, upper_bounds) weights -- a list of sample weights Additional Inputs: constraints -- a function that takes a nested list of N x 1D discrete measure positions and weights x' = constraints(x, w) npop -- size of the trial solution population maxiter -- number - the maximum number of iterations to perform maxfun -- number - the maximum number of function evaluations Outputs: samples -- a list of sample positions For example: >>> # provide the dimensions and bounds >>> nx = 3; ny = 2; nz = 1 >>> x_lb = [10.0]; y_lb = [0.0]; z_lb = [10.0] >>> x_ub = [50.0]; y_ub = [9.0]; z_ub = [90.0] >>> >>> # prepare the bounds >>> lb = (nx * x_lb) + (ny * y_lb) + (nz * z_lb) >>> ub = (nx * x_ub) + (ny * y_ub) + (nz * z_ub) >>> >>> # generate a list of samples with mean +/- dev imposed >>> mean = 2.0; dev = 0.01 >>> samples = impose_expectation((mean,dev), f, (nx,ny,nz), (lb,ub)) >>> >>> # test the results by calculating the expectation value for the samples >>> expectation(f, samples) >>> 2.00001001012246015 """ # param[0] is the target mean # param[1] is the acceptable deviation from the target mean # FIXME: the following is a HACK to recover from lost 'weights' information # we 'mimic' discrete measures using the product measure weights # plug in the 'constraints' function: samples' = constrain(samples, weights) constrain = None # default is no constraints if 'constraints' in kwds: constrain = kwds['constraints'] if not constrain: # if None (default), there are no constraints constraints = lambda x: x else: #XXX: better to use a standard "xk' = constrain(xk)" interface ? def constraints(rv): coords = _pack(_nested(rv, npts)) coords = zip(*coords) # 'mimic' a nested list coords = constrain(coords, [weights for i in range(len(coords))]) coords = zip(*coords) # revert back to a packed list return _flat(_unpack(coords, npts)) # construct cost function to reduce deviation from expectation value def cost(rv): """compute cost from a 1-d array of model parameters, where: cost = | E[model] - m |**2 """ # from mystic.math.measures import _pack, _nested, expectation samples = _pack(_nested(rv, npts)) Ex = expectation(f, samples, weights) return (Ex - param[0])**2 # if bounds are not set, use the default optimizer bounds if not bounds: lower_bounds = [] upper_bounds = [] for n in npts: lower_bounds += [None] * n upper_bounds += [None] * n else: lower_bounds, upper_bounds = bounds # construct and configure optimizer debug = kwds['debug'] if 'debug' in kwds else False npop = kwds.pop('npop', 200) maxiter = kwds.pop('maxiter', 1000) maxfun = kwds.pop('maxfun', 1e+6) crossover = 0.9 percent_change = 0.9 def optimize(cost, (lb, ub), tolerance, _constraints): from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import VTR from mystic.strategy import Best1Exp from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed if debug: random_seed(123) evalmon = Monitor() stepmon = Monitor() if debug: stepmon = VerboseMonitor(10) ndim = len(lb) solver = DifferentialEvolutionSolver2(ndim, npop) solver.SetRandomInitialPoints(min=lb, max=ub) solver.SetStrictRanges(min=lb, max=ub) solver.SetEvaluationLimits(maxiter, maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.Solve(cost,termination=VTR(tolerance),strategy=Best1Exp, \ CrossProbability=crossover,ScalingFactor=percent_change, \ constraints = _constraints) solved = solver.Solution() diameter_squared = solver.bestEnergy func_evals = len(evalmon) return solved, diameter_squared, func_evals
cminconstr=cminconstr+"2" solv = generate_solvers(cminconstr,nvars=len(pointvec)) constraintfunc = generate_constraint(solv) #Run optimization if __name__ == '__main__': print("Powell's Method") print("===============") # dimensional information from mystic.tools import random_seed random_seed(12) ndim = len(pointvec) nbins = 1 #[2,1,2,1,2,1,2,1,1] # configure monitor stepmon = VerboseMonitor(1) # use lattice-Powell to solve 8th-order Chebyshev coefficients solver = LatticeSolver(ndim, nbins) solver.SetNestedSolver(PowellDirectionalSolver) solver.SetMapper(Pool().map) solver.SetGenerationMonitor(stepmon) solver.SetStrictRanges(min=[0]*ndim, max=[1]*ndim) solver.SetConstraints(constraintfunc) solver.Solve(test_obj, NCOG(1e+2), disp=1)
#!/usr/bin/env python # # Author: Mike McKerns (mmckerns @caltech and @uqfoundation) # Copyright (c) 1997-2016 California Institute of Technology. # Copyright (c) 2016-2018 The Uncertainty Quantification Foundation. # License: 3-clause BSD. The full license text is available at: # - https://github.com/uqfoundation/mystic/blob/master/LICENSE from mystic.models import rosen from mystic.solvers import * from mystic.termination import VTRChangeOverGeneration from mystic.monitors import VerboseMonitor, Monitor from mystic.tools import random_seed random_seed(123) lb, ub = [-100.] * 3, [100] * 3 interval = None if interval: _stepmon = VerboseMonitor(interval) else: _stepmon = Monitor() _term = VTRChangeOverGeneration(generations=200) _solver = DifferentialEvolutionSolver(3, 20) #40) _solver.SetRandomInitialPoints(lb, ub) _solver.SetStrictRanges(lb, ub) _solver.SetTermination(_term) _solver.SetGenerationMonitor(_stepmon) _solver.SetEvaluationLimits(100, 1000) _solver.Solve(rosen) _energy = _solver.bestEnergy
def test_griewangk(): """Test Griewangk's function, which has many local minima. Testing Griewangk: Expected: x=[0.]*10 and f=0 Using DifferentialEvolutionSolver: Solution: [ 8.87516194e-09 7.26058147e-09 1.02076001e-08 1.54219038e-08 -1.54328461e-08 2.34589663e-08 2.02809360e-08 -1.36385836e-08 1.38670373e-08 1.59668900e-08] f value: 0.0 Iterations: 4120 Function evaluations: 205669 Time elapsed: 34.4936850071 seconds Using DifferentialEvolutionSolver2: Solution: [ -2.02709316e-09 3.22017968e-09 1.55275472e-08 5.26739541e-09 -2.18490470e-08 3.73725584e-09 -1.02315312e-09 1.24680355e-08 -9.47898116e-09 2.22243557e-08] f value: 0.0 Iterations: 4011 Function evaluations: 200215 Time elapsed: 32.8412370682 seconds """ print "Testing Griewangk:" print "Expected: x=[0.]*10 and f=0" from mystic.models import griewangk as costfunc ndim = 10 lb = [-400.]*ndim ub = [400.]*ndim maxiter = 10000 seed = 123 # Re-seed for each solver to have them all start at same x0 # DifferentialEvolutionSolver print "\nUsing DifferentialEvolutionSolver:" npop = 50 random_seed(seed) from mystic.solvers import DifferentialEvolutionSolver from mystic.termination import ChangeOverGeneration as COG from mystic.termination import CandidateRelativeTolerance as CRT from mystic.termination import VTR from mystic.strategy import Rand1Bin, Best1Bin, Rand1Exp esow = Monitor() ssow = Monitor() solver = DifferentialEvolutionSolver(ndim, npop) solver.SetRandomInitialPoints(lb, ub) solver.SetStrictRanges(lb, ub) solver.SetEvaluationLimits(generations=maxiter) solver.SetEvaluationMonitor(esow) solver.SetGenerationMonitor(ssow) solver.enable_signal_handler() #term = COG(1e-10) #term = CRT() term = VTR(0.) time1 = time.time() # Is this an ok way of timing? solver.Solve(costfunc, term, strategy=Rand1Exp, \ CrossProbability=0.3, ScalingFactor=1.0) 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) # DifferentialEvolutionSolver2 print "\nUsing DifferentialEvolutionSolver2:" npop = 50 random_seed(seed) from mystic.solvers import DifferentialEvolutionSolver2 from mystic.termination import ChangeOverGeneration as COG from mystic.termination import CandidateRelativeTolerance as CRT from mystic.termination import VTR from mystic.strategy import Rand1Bin, Best1Bin, Rand1Exp esow = Monitor() ssow = Monitor() solver = DifferentialEvolutionSolver2(ndim, npop) solver.SetRandomInitialPoints(lb, ub) solver.SetStrictRanges(lb, ub) solver.SetEvaluationLimits(generations=maxiter) solver.SetEvaluationMonitor(esow) solver.SetGenerationMonitor(ssow) #term = COG(1e-10) #term = CRT() term = VTR(0.) time1 = time.time() # Is this an ok way of timing? solver.Solve(costfunc, term, strategy=Rand1Exp, \ CrossProbability=0.3, ScalingFactor=1.0) 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)
NNODES = NP // 5 seed = 321 if __name__ == '__main__': from pathos.helpers import freeze_support freeze_support() # help Windows use multiprocessing def print_solution(func): print(poly1d(func)) return psow = VerboseMonitor(10) ssow = VerboseMonitor(10) random_seed(seed) print("first sequential...") solver = DifferentialEvolutionSolver2(ND, NP) solver.SetRandomInitialPoints(min=[-100.0] * ND, max=[100.0] * ND) solver.SetEvaluationLimits(generations=MAX_GENERATIONS) solver.SetGenerationMonitor(ssow) solver.Solve(ChebyshevCost, VTR(0.01), strategy=Best1Exp, \ CrossProbability=1.0, ScalingFactor=0.9, disp=1) print("") print_solution(solver.bestSolution) random_seed(seed) print("\n and now parallel...") solver2 = DifferentialEvolutionSolver2(ND, NP) solver2.SetMapper(Pool(NNODES).map) # parallel solver2.SetRandomInitialPoints(min=[-100.0] * ND, max=[100.0] * ND)
def _run_solver(self, early_terminate=False, **kwds): from mystic.monitors import Monitor import numpy from mystic.tools import random_seed seed = 111 if self.maxiter is None else 321 #XXX: good numbers... random_seed(seed) esow = Monitor() ssow = Monitor() solver = self.solver solver.SetRandomInitialPoints(min = self.min, max = self.max) if self.usebounds: solver.SetStrictRanges(self.min, self.max) if self.uselimits: solver.SetEvaluationLimits(self.maxiter, self.maxfun) if self.useevalmon: solver.SetEvaluationMonitor(esow) if self.usestepmon: solver.SetGenerationMonitor(ssow) #### run solver, but trap output _stdout = trap_stdout() solver.Solve(self.costfunction, self.term, **kwds) out = release_stdout(_stdout) ################################ sol = solver.Solution() iter=1 #if self.uselimits and self.maxiter == 0: iter=0 # sanity check solver internals self.assertTrue(solver.generations == len(solver._stepmon._y)-iter) self.assertTrue(list(solver.bestSolution) == solver._stepmon.x[-1]) #XXX self.assertTrue(solver.bestEnergy == solver._stepmon.y[-1]) self.assertTrue(solver.solution_history == solver._stepmon.x) self.assertTrue(solver.energy_history == solver._stepmon.y) if self.usestepmon: self.assertTrue(ssow.x == solver._stepmon.x) self.assertTrue(ssow.y == solver._stepmon.y) self.assertTrue(ssow._y == solver._stepmon._y) if self.useevalmon: self.assertTrue(solver.evaluations == len(solver._evalmon._y)) self.assertTrue(esow.x == solver._evalmon.x) self.assertTrue(esow.y == solver._evalmon.y) self.assertTrue(esow._y == solver._evalmon._y) # Fail appropriately for solver/termination mismatch if early_terminate: self.assertTrue(solver.generations < 2) warn = "Warning: Invalid termination condition (nPop < 2)" self.assertTrue(warn in out) return g = solver.generations calls = [(g+1)*self.NP, (2*g)+1] iters = [g] # Test early terminations if self.uselimits and self.maxfun == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxfun == 1: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 0: calls += [1, 20] #XXX: scipy* iters += [1] #XXX: scipy* self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter == 1: calls += [20] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return if self.uselimits and self.maxiter and 2 <= self.maxiter <= 5: calls += [52, 79, 107, 141] #Powell's self.assertTrue(solver.evaluations in calls) self.assertTrue(solver.generations in iters) return # Verify solution is close to exact #print(sol) for i in range(len(sol)): self.assertAlmostEqual(sol[i], self.exact[i], self.precision) return