def test_inner_solver(nested, solver): from mystic.monitors import Monitor evalmon = Monitor() stepmon = Monitor() 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 solver = solver(5) lb,ub = [0,0,0,0,0],[100,100,100,100,100] solver.SetRandomInitialPoints(lb, ub) solver.SetConstraints(constraints) solver.SetStrictRanges(lb, ub) nested = nested(5, 4) nested.SetEvaluationMonitor(evalmon) nested.SetGenerationMonitor(stepmon) nested.SetNestedSolver(solver) nested.Solve(cost, disp=False) y = nested.Solution() assert almostEqual(mean(y), 5.0, tol=1e-15) assert almostEqual(spread(y), 5.0, tol=1e-15) assert almostEqual(cost(y), 4*(5.0), tol=1e-6)
def test_compare(solvername, x0, **kwds): exec "my = solvers.%s" % solvername exec "sp = %s" % solvername maxiter = kwds.get('maxiter', None) maxfun = kwds.get('maxfun', None) my_x = my(rosen, x0, disp=0, full_output=True, **kwds) # itermon = kwds.pop('itermon',None) sp_x = sp(rosen, x0, disp=0, full_output=True, **kwds) # similar bestSolution and bestEnergy # print 'my:', my_x[0:2] # print 'sp:', sp_x[0:2] if my_x[3] == sp_x[-2]: # mystic can stop at iter=0, scipy can't assert almostEqual(my_x[0], sp_x[0]) assert almostEqual(my_x[1], sp_x[1]) # print (iters, fcalls) and [maxiter, maxfun] # print my_x[2:4], (sp_x[-3],sp_x[-2]), [maxiter, maxfun] # test same number of iters and fcalls if maxiter and maxfun is not None: assert my_x[2] == sp_x[-3] assert my_x[3] == sp_x[-2] # # test fcalls <= maxfun # assert my_x[3] <= maxfun if maxiter is not None: # test iters <= maxiter assert my_x[2] <= maxiter return
def test_nested_solver(nested, solver): from mystic.monitors import Monitor evalmon = Monitor() stepmon = Monitor() 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 nested = nested(5, 4) nested.SetEvaluationMonitor(evalmon) nested.SetGenerationMonitor(stepmon) nested.SetConstraints(constraints) nested.SetNestedSolver(solver) nested.Solve(cost, disp=False) y = nested.Solution() assert almostEqual(mean(y), 5.0, tol=1e-15) assert almostEqual(spread(y), 5.0, tol=1e-15) assert almostEqual(cost(y), 4*(5.0), tol=1e-6)
def test_multi_liner(solver): from mystic.monitors import Monitor evalmon = Monitor() stepmon = Monitor() 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]) solver = solver(len(x)) solver.SetInitialPoints(x) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) solver.SetConstraints(constraints) solver.Solve(cost, disp=False) y = solver.Solution() assert almostEqual(mean(y), 5.0, tol=1e-15) assert almostEqual(spread(y), 5.0, tol=1e-15) assert almostEqual(cost(y), 4*(5.0), tol=1e-6)
def test_impose_reweighted_variance(): x0 = [1,2,3,4,5] w0 = [3,1,1,1,1] v = 1.0 w = impose_reweighted_variance(v, x0, w0) assert almostEqual(variance(x0,w), v) assert almostEqual(mean(x0,w0), mean(x0,w))
def test_generate_constraint(): constraints = """ spread([x0, x1, x2]) = 10.0 mean([x0, x1, x2]) = 5.0""" from mystic.math.measures import mean, spread solv = generate_solvers(constraints) assert almostEqual(mean(solv[0]([1,2,3])), 5.0) assert almostEqual(spread(solv[1]([1,2,3])), 10.0) constraint = generate_constraint(solv) assert almostEqual(constraint([1,2,3]), [0.0,5.0,10.0], 1e-10)
def test_with_mean_spread(): from mystic.math.measures import mean, spread, impose_mean, impose_spread @with_spread(50.0) @with_mean(5.0) def constrained_squared(x): return [i**2 for i in x] from numpy import array x = array([1,2,3,4,5]) y = impose_spread(50.0, impose_mean(5.0,[i**2 for i in x])) assert almostEqual(mean(y), 5.0, tol=1e-15) assert almostEqual(spread(y), 50.0, tol=1e-15) assert constrained_squared(x) == y
def test_constrain(): from mystic.math.measures import mean, spread from mystic.math.measures import impose_mean, impose_spread def mean_constraint(x, mean=0.0): return impose_mean(mean, x) def range_constraint(x, spread=1.0): return impose_spread(spread, x) @inner(inner=range_constraint, kwds={'spread':5.0}) @inner(inner=mean_constraint, kwds={'mean':5.0}) def constraints(x): return x def cost(x): return abs(sum(x) - 5.0) from mystic.solvers import fmin_powell from numpy import array x = array([1,2,3,4,5]) y = fmin_powell(cost, x, constraints=constraints, disp=False) assert mean(y) == 5.0 assert spread(y) == 5.0 assert almostEqual(cost(y), 4*(5.0))
def factory(x, *args, **kwds): # apply decorated constraints function x = constraints(x, *args, **kwds) # constrain x such that sum(x) == mass if not almostEqual(sum(x), mass): x = normalize(x, mass=mass) return x
def factory(x, *args, **kwds): # apply decorated constraints function x = constraints(x, *args, **kwds) # constrain x such that mean(x) == target if not almostEqual(mean(x), target): x = impose_mean(target, x)#, weights=weights) return x
def constraints(x): # constrain the last x_i to be the same value as the first x_i x[-1] = x[0] # constrain x such that mean(x) == target if not almostEqual(mean(x), target): x = impose_mean(target, x) return x
def test_impose_reweighted_mean(): x0 = [1,2,3,4,5] w0 = [3,1,1,1,1] m = 3.5 w = impose_reweighted_mean(m, x0, w0) assert almostEqual(mean(x0,w), m)
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) assert almostEqual(cost(y), 4*(5.0), tol=1e-6)
def test_solve_constraint(): from mystic.math.measures import mean @with_mean(1.0) def constraint(x): x[-1] = x[0] return x x = solve(constraint, guess=[2,3,1]) assert almostEqual(mean(x), 1.0, tol=1e-15) assert x[-1] == x[0] assert issolution(constraint, x)
def test_numpy_penalty(): constraints = """ mean([x0, x1, x2]) = 5.0 x0 = x1 + x2""" ineq,eq = generate_conditions(constraints) assert eq[0]([7,5,3]) == 0.0 assert eq[1]([7,4,3]) == 0.0 penalty = generate_penalty((ineq,eq)) assert penalty([9.0,5,4.0]) == 100.0 assert penalty([7.5,4,3.5]) == 0.0 constraint = as_constraint(penalty, solver='fmin') assert almostEqual(penalty(constraint([3,4,5])), 0.0, 1e-10)
def constraints(rv): c = product_measure().load(rv, npts) # NOTE: bounds wi in [0,1] enforced by filtering # impose norm on each discrete measure for measure in c: if not almostEqual(float(measure.mass), 1.0, tol=atol, rel=rtol): measure.normalize() # impose expectation on product measure ##################### begin function-specific ##################### E = float(c.expect(model)) if not (E <= float(target[0] + error[0])) \ or not (float(target[0] - error[0]) <= E): c.set_expect(target[0], model, (x_lb,x_ub), tol=error[0]) ###################### end function-specific ###################### # extract weights and positions return c.flatten()
def test_varnamelist(): # Demonstrates usage of varnamelist varnamelist = ['length', 'width', 'height'] string = "length = height**2 - 3.5*width" # print "symbolic string:\n", string.rstrip() string = replace_variables(string, varnamelist, 'x') cf = generate_constraint(generate_solvers(string)) @inner(cf) def wrappedfunc(x): return x[0] #XXX: implement: wrap_constraint( cf, lambda x: x[0], ctype='inner') ? # print "c = constraints wrapped around x[0]" x0 = [2., 2., 3.] # print "c(%s): %s\n" % (x0, wrappedfunc(x0)) # Expected: 2.0 assert almostEqual(wrappedfunc(x0), 2.0, tol=1e-15)
def test_generate_penalty(): constraints = """ x0**2 = 2.5*x3 - a exp(x2/x0) >= b""" ineq,eq = generate_conditions(constraints, nvars=4, locals={'a':5.0, 'b':7.0}) assert ineq[0]([4,0,0,1,0]) == 6.0 assert eq[0]([4,0,0,1,0]) == 18.5 penalty = generate_penalty((ineq,eq)) assert penalty([1,0,2,2.4]) == 0.0 assert penalty([1,0,0,2.4]) == 7200.0 assert penalty([1,0,2,2.8]) == 100.0 constraint = as_constraint(penalty, nvars=4, solver='fmin') assert almostEqual(penalty(constraint([1,0,0,2.4])), 0.0, 1e-10)
def impose_reweighted_variance(v, samples, weights=None, solver=None): """impose a variance on a list of points by reweighting weights""" ndim = len(samples) if weights is None: weights = [1.0/ndim] * ndim if solver is None or solver == 'fmin': from mystic.solvers import fmin as solver elif solver == 'fmin_powell': from mystic.solvers import fmin_powell as solver elif solver == 'diffev': from mystic.solvers import diffev as solver elif solver == 'diffev2': from mystic.solvers import diffev2 as solver norm = sum(weights) m = mean(samples, weights) inequality = "" equality = ""; equality2 = ""; equality3 = "" for i in range(ndim): inequality += "x%s >= 0.0\n" % (i) # positive equality += "x%s + " % (i) # normalized equality2 += "%s * x%s + " % (float(samples[i]),(i)) # mean equality3 += "x%s*(%s-%s)**2 + " % ((i),float(samples[i]),m) # var equality += "0.0 = %s\n" % float(norm) equality += equality2 + "0.0 = %s*%s\n" % (float(norm),m) equality += equality3 + "0.0 = %s*%s\n" % (float(norm),v) penalties = generate_penalty(generate_conditions(inequality)) constrain = generate_constraint(generate_solvers(solve(equality))) def cost(x): return sum(x) results = solver(cost, weights, constraints=constrain, \ penalty=penalties, disp=False, full_output=True) wts = list(results[0]) _norm = results[1] # should have _norm == norm warn = results[4] # nonzero if didn't converge #XXX: better to fail immediately if xlo < m < xhi... or the below? if warn or not almostEqual(_norm, norm): print "Warning: could not impose mean through reweighting" return None #impose_variance(v, samples, weights), weights return wts #samples, wts # "mean-preserving"
def cone_mesh(length): """ construct a conical mesh for a given length of cone """ L1,L2,L3 = slope radius = length / L3 #XXX: * 0.5 r0 = ZERO if almostEqual(radius, r0, tol=r0): radius = r0 r = np.linspace(radius,radius,6) r[0]= np.zeros(r[0].shape) r[1] *= r0/radius r[5] *= r0/radius r[3]= np.zeros(r[3].shape) p = np.linspace(0,2*np.pi,50) R,P = np.meshgrid(r,p) X,Y = L1 * R*np.cos(P), L2 * R*np.sin(P) tmp=list() for i in range(np.size(p)): tmp.append([0,0,length,length,length,0]) # len = size(r) Z = np.array(tmp) return X,Z,Y
def test_matrix_interface(): # Demonstrates linear_symbolic() A = asarray([[3., 4., 5.], [1., 6., -9.]]) b = asarray([0., 0.]) G = [1., 0., 0.] h = [5.] # print "equality constraints" # print "G: %s" % G # print "h: %s" % h # print "inequality constraints" # print "A:\n%s" % A # print "b: %s" % b constraints_string = linear_symbolic(A=A, b=b, G=G, h=h) cs = constraints_string.split('\n') assert cs[0] == "1.0*x0 + 0.0*x1 + 0.0*x2 <= 5.0" assert cs[1] == "3.0*x0 + 4.0*x1 + 5.0*x2 = 0.0" assert cs[2] == "1.0*x0 + 6.0*x1 + -9.0*x2 = 0.0" # print "symbolic string:\n", constraints_string.rstrip() pf = generate_penalty(generate_conditions(constraints_string)) cn = as_constraint(pf) x0 = [1., 1., 1.] assert almostEqual(pf(cn(x0)), 0.0, tol=1e-2)
def test_setexpectmeanvar(m, expect=5.0, tol=0.001): m.set_expect_mean_and_var((expect,expect), f, tol=tol) assert almostEqual(m.expect(f), expect, tol=tol) assert almostEqual(m.expect_var(f), expect, tol=tol)
def test_expectvar(m, f): pos = m.positions if not (len(pos) and isinstance(pos[0], tuple)): # then m is a measure pos = [[i] for i in pos] expect = expected_variance(f, pos, m.weights) assert almostEqual(m.expect_var(f), expect)
if __name__ == '__main__': from mystic.solvers import diffev2, fmin_powell from mystic.math import almostEqual result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraint=cf, npop=40, disp=False, full_output=True, ftol=1e-10, gtol=100) assert almostEqual(result[0], xs, rel=1e-2) assert almostEqual(result[1], ys, rel=1e-2) result = fmin_powell(objective, x0=[0.0, 0.0], bounds=bounds, penalty=pf, constraint=cf, disp=False, full_output=True, gtol=3) assert almostEqual(result[0], xs, rel=1e-2) assert almostEqual(result[1], ys, rel=1e-2) # EOF
def cost(x): kx = constrain(x) y = objective(kx) mon(kx, y) return y if __name__ == '__main__': from mystic.math import almostEqual result = so.fmin(cost, [1, 1, 1], xtol=1e-6, ftol=1e-6, full_output=True, disp=False) # check results are consistent with monitor assert almostEqual(result[1], min(mon.y), rel=1e-2) # check results satisfy constraints A, B, C = result[0] print(dict(A=A, B=B, C=C)) eps = 0.2 #XXX: give it some small wiggle room for small violations assert A * B + C >= 1 - eps assert B <= A + eps assert (5 + eps) >= A >= -(5 + eps) assert (5 + eps) >= B >= -(5 + eps) assert (5 + eps) >= C >= -(5 + eps)
from scipy.optimize import curve_fit xs, pcov = curve_fit(lambda x, *coeffs: y0(coeffs, x), x, y, p0=[1, 1, 1]) except ImportError: xs = x0 ys = objective(xs, x, y) if __name__ == '__main__': from mystic.solvers import diffev2 from mystic.math import almostEqual # from mystic.monitors import VerboseMonitor # mon = VerboseMonitor(10) result = diffev2(objective, args=args, x0=bounds, bounds=bounds, npop=40, ftol=1e-8, gtol=100, disp=False, full_output=True) #, itermon=mon) # print("%s %s" % (result[0], xs)) assert almostEqual(result[0], xs, rel=2e-1) assert almostEqual(result[1], ys, rel=2e-1) #XXX: how approximate the covariance matrix of estimates (pcov) w/ mystic? #XXX: mystic should have leastsq # EOF
pens = ms.generate_penalty(ms.generate_conditions(eqns), k=1e3) bounds = [(0., None), (0., 4.)] # get the objective def objective(x): x = np.asarray(x) return x[0]**2 + 4*x[1]**2 - 32*x[1] + 64 x0 = np.random.rand(2) # compare against the exact minimum xs = np.array([2., 3.]) ys = objective(xs) sol = my.fmin_powell(objective, x0, constraint=cons, penalty=pens, disp=False, bounds=bounds, gtol=3, ftol=1e-6, full_output=True) assert mm.almostEqual(sol[0], xs, tol=1e-2) assert mm.almostEqual(sol[1], ys, tol=1e-2) sol = my.diffev(objective, bounds, constraint=cons, penalty=pens, disp=False, bounds=bounds, npop=10, gtol=100, ftol=1e-6, full_output=True) assert mm.almostEqual(sol[0], xs, tol=1e-2) assert mm.almostEqual(sol[1], ys, tol=1e-2) # EOF
from mystic.constraints import unique from numpy import round, hstack, clip def constraint(x): x = round(x).astype(int) # force round and convert type to int x = clip(x, 1,n) #XXX: impose bounds x = unique(x, range(1,n+1)) return x if __name__ == '__main__': from mystic.solvers import diffev2 from mystic.math import almostEqual from mystic.monitors import Monitor, VerboseMonitor mon = VerboseMonitor(10)#,10) result = diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=constraint, npop=50, ftol=1e-8, gtol=200, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) print result[0] assert almostEqual(result[0], xs[0], tol=1e-8) \ or almostEqual(result[0], xs[1], tol=1e-8) \ or almostEqual(result[0], xs[2], tol=1e-8) \ or almostEqual(result[0], xs[3], tol=1e-8) \ or almostEqual(result[0], xs[4], tol=1e-8) \ or almostEqual(result[0], xs[-1], tol=1e-8) assert almostEqual(result[1], ys, tol=1e-4) # EOF
def equations(len=3): eqn = "\nsum([" for i in range(len): eqn += 'x%s**2, ' % str(i) return eqn[:-2]+"]) - 1.0 = 0.0\n" def cf(len=3): return generate_constraint(generate_solvers(solve(equations(len)))) def pf(len=3): return generate_penalty(generate_conditions(equations(len))) if __name__ == '__main__': x = xs(10) y = ys(len(x)) bounds = bounds(len(x)) cf = cf(len(x)) from mystic.solvers import diffev2 from mystic.math import almostEqual result = diffev2(objective, x0=bounds, bounds=bounds, constraints=cf, npop=40, gtol=500, disp=False, full_output=True) assert almostEqual(result[0], x, tol=1e-2) assert almostEqual(result[1], y, tol=1e-2) # EOF
from mystic.solvers import diffev2 from mystic.math import almostEqual from mystic.monitors import Monitor, VerboseMonitor mon = VerboseMonitor(10) #,10) result = diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=constraint, npop=50, ftol=1e-8, gtol=200, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) print(result[0]) assert almostEqual(result[0], xs[0], tol=1e-8) \ or almostEqual(result[0], xs[1], tol=1e-8) \ or almostEqual(result[0], xs[2], tol=1e-8) \ or almostEqual(result[0], xs[3], tol=1e-8) \ or almostEqual(result[0], xs[4], tol=1e-8) \ or almostEqual(result[0], xs[-1], tol=1e-8) assert almostEqual(result[1], ys, tol=1e-4) # EOF
from mystic.symbolic import generate_conditions, generate_penalty pf = generate_penalty(generate_conditions(equations)) from mystic.symbolic import generate_constraint, generate_solvers, simplify cf = generate_constraint(generate_solvers(simplify(equations))) # inverted objective, used in solving for the maximum _objective = lambda x: -objective(x) if __name__ == '__main__': from mystic.solvers import diffev2, fmin_powell from mystic.math import almostEqual result = diffev2(objective, x0=bounds, bounds=bounds, constraint=cf, penalty=pf, npop=40, disp=False, full_output=True) assert almostEqual(result[0], xs, rel=1e-2) assert almostEqual(result[1], ys, rel=1e-2) result = fmin_powell(objective, x0=[0.0,0.0], bounds=bounds, constraint=cf, penalty=pf, disp=False, full_output=True) assert almostEqual(result[0], xs, rel=1e-2) assert almostEqual(result[1], ys, rel=1e-2) # alternately, solving for the maximum result = diffev2(_objective, x0=bounds, bounds=bounds, constraint=cf, penalty=pf, npop=40, disp=False, full_output=True) assert almostEqual( result[0], _xs, rel=1e-2) assert almostEqual(-result[1], _ys, rel=1e-2) result = fmin_powell(_objective, x0=[0,0], bounds=bounds, constraint=cf, penalty=pf, npop=40, disp=False, full_output=True) assert almostEqual( result[0], _xs, rel=1e-2) assert almostEqual(-result[1], _ys, rel=1e-2)
def test_griewangk(verbose=False): """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 """ if verbose: 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 if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 0.0, tol=3e-3) # DifferentialEvolutionSolver2 if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 0.0, tol=3e-3)
# compare against the exact minimum xs = np.array([.5, 1.224744871]) ys = objective(xs) sol = my.fmin_powell(objective, x0, constraint=cons, penalty=pens, disp=False, bounds=bounds, gtol=3, ftol=1e-6, full_output=True) assert mm.almostEqual(sol[0], xs, tol=1e-2) assert mm.almostEqual(sol[1], ys, tol=1e-2) sol = my.diffev(objective, bounds, constraint=cons, penalty=pens, disp=False, bounds=bounds, npop=10, gtol=100, ftol=1e-6, full_output=True) assert mm.almostEqual(sol[0], xs, tol=1e-2) assert mm.almostEqual(sol[1], ys, tol=1e-2)
@quadratic_equality(penalty1) @quadratic_equality(penalty2) @quadratic_equality(penalty3) def penalty(x): return 0.0 solver = as_constraint(penalty) if __name__ == '__main__': from mystic.solvers import lattice from mystic.math import almostEqual result = lattice(objective, 5, [2] * 5, bounds=bounds, penalty=penalty, ftol=1e-8, xtol=1e-8, disp=False, full_output=True) assert almostEqual(result[0], xs, tol=2e-2) \ or almostEqual(result[0], _xs, tol=2e-2) \ or almostEqual(result[0], x_s, tol=2e-2) \ or almostEqual(result[0], xs_, tol=2e-2) assert almostEqual(result[1], ys, rel=2e-2) # EOF
def test_calculate_methods(npts=2): upper_bounds = [1.0] lower_bounds = [0.0] # ------------------------------------- # generate initial coordinates, weights # ------------------------------------- # get a random distribution of points if disp: print("generate random points and weights") coordinates = samplepts(lower_bounds, upper_bounds, npts) D0 = D = [i[0] for i in coordinates] if disp: print("positions: %s" % D) # calculate sample range R0 = R = spread(D) if disp: print("range: %s" % R) # select weights randomly in [0,1], then normalize so sum(weights) = 1 wts = random_samples([0], [1], npts)[0] weights = normalize(wts, 0.0, zsum=True) if disp: print("weights (when normalized to 0.0): %s" % weights) assert almostEqual(sum(weights), 0.0, tol=1e-15) weights = normalize(wts, 1.0) assert almostEqual(sum(weights), 1.0, tol=1e-15) if disp: print("weights (when normalized to 1.0): %s" % weights) w = norm(weights) if disp: print("norm: %s" % w) assert almostEqual(w, sum(weights) / npts) # calculate sample mean m0 = m = mean(D, weights) if disp: print("mean: %s" % m) if disp: print("") # ------------------------------------- # modify coordinates, maintaining mean & range # ------------------------------------- # get new random distribution if disp: print("modify positions, maintaining mean and range") coordinates = samplepts(lower_bounds, upper_bounds, npts) D = [i[0] for i in coordinates] # impose a range and mean on the points D = impose_spread(R, D, weights) D = impose_mean(m, D, weights) # print results if disp: print("positions: %s" % D) R = spread(D) if disp: print("range: %s" % R) assert almostEqual(R, R0) m = mean(D, weights) if disp: print("mean: %s" % m) assert almostEqual(m, m0) if disp: print("") # ------------------------------------- # modify weights, maintaining mean & norm # ------------------------------------- # select weights randomly in [0,1] if disp: print("modify weights, maintaining mean and range") wts = random_samples([0], [1], npts)[0] # print intermediate results #print("weights: %s" % wts) #sm = mean(D, wts) #print("tmp mean: %s" % sm) #print("") # impose mean and weight norm on the points D = impose_mean(m, D, wts) DD, weights = impose_weight_norm(D, wts) # print results if disp: print("weights: %s" % weights) w = norm(weights) if disp: print("norm: %s" % w) assert almostEqual(w, sum(weights) / npts) if disp: print("positions: %s" % DD) R = spread(DD) if disp: print("range: %s" % R) assert almostEqual(R, R0) sm = mean(DD, weights) if disp: print("mean: %s" % sm) assert almostEqual(sm, m0) sv = variance(DD, weights) if disp: print("var: %s" % sv) assert not almostEqual(sv, R) assert almostEqual(sv, 0.0, tol=.3) # ------------------------------------- # modify variance, maintaining mean # ------------------------------------- if disp: print("\nmodify variance, maintaining mean") DD = impose_variance(R, DD, weights) sm = mean(DD, weights) if disp: print("mean: %s" % sm) assert almostEqual(sm, m0) sv = variance(DD, weights) if disp: print("var: %s" % sv) assert almostEqual(sv, R)
def test_collection_behavior(): from mystic.math import almostEqual from numpy import inf def f(x): return sum(x) # a test function for expectation value # build three sets (x,y,z) sx = set([point(1.0, 1.0), point(2.0, 1.0), point(3.0, 2.0)]) sy = set([point(0.0, 1.0), point(3.0, 2.0)]) sz = set([point(1.0, 1.0), point(2.0, 3.0)]) #NOTE: for marc_surr(x,y,z), we must have x > 0.0 sx.normalize() sy.normalize() sz.normalize() assert sx.mass == sy.mass == sz.mass == 1.0 # build a collection c = collection([sx, sy, sz]) xpos = c[0].positions ypos = c[1].positions zpos = c[2].positions xwts = c[0].weights ywts = c[1].weights zwts = c[2].weights if disp: print("x_positions: %s" % xpos) print("y_positions: %s" % ypos) print("z_positions: %s" % zpos) print("x_weights: %s" % xwts) print("y_weights: %s" % ywts) print("z_weights: %s" % zwts) assert xpos == sx.positions assert ypos == sy.positions assert zpos == sz.positions assert xwts == sx.weights assert ywts == sy.weights assert zwts == sz.weights tol = .2 supp = c.support(tol) positions = c.positions weights = c.weights assert supp == [p for (p, w) in zip(positions, weights) if w > tol] if disp: print("support points:\n %s" % supp) print("npts: %s (i.e. %s)" % (c.npts, c.pts)) print("weights: %s" % weights) print("positions: %s" % positions) assert c.npts == sx.npts * sy.npts * sz.npts assert len(weights) == len(positions) == c.npts assert sx.positions in c.pos assert sy.positions in c.pos assert sz.positions in c.pos assert sx.weights in c.wts assert sy.weights in c.wts assert sz.weights in c.wts c_exp = c.expect(f) if disp: print("mass: %s" % c.mass) print("expect: %s" % c_exp) assert c.mass == [sx.mass, sy.mass, sz.mass] assert c_exp == expectation(f, c.positions, c.weights) #print("center: %s" % c.center) #print("delta: %s" % c.delta) # change the positions in the collection points = [list(i) for i in positions[::3]] for i in range(len(points)): points[i][0] = 0.5 positions[::3] = points c.positions = positions _xpos = c[0].positions _ypos = c[1].positions _zpos = c[2].positions _cexp = c.expect(f) if disp: print("x_positions: %s" % _xpos) print("y_positions: %s" % _ypos) print("z_positions: %s" % _zpos) print("expect: %s" % _cexp) assert _xpos == [0.5] + xpos[1:] assert _ypos == ypos assert _zpos == zpos assert _cexp < c_exp # due to _xpos[0] is 0.5 and less than 1.0 _mean = 85.0 _range = 0.25 c.set_expect(_mean, f, npop=40, maxiter=200, tol=_range) _exp = c.expect(f) if disp: print("mean: %s" % _mean) print("range: %s" % _range) print("expect: %s" % _exp) assert almostEqual(_mean, _exp, tol=_mean * 0.01) # a test function for probability of failure def g(x): if f(x) <= 0.0: return False return True pof = c.pof(g) spof = c.sampled_pof(g, npts=10000) if disp: print("pof: %s" % pof) print("sampled_pof: %s" % spof) assert almostEqual(pof, spof, tol=0.02) return
from mystic.symbolic import generate_constraint, generate_solvers, simplify from mystic.symbolic import generate_penalty, generate_conditions equations = """ x0**2 + x1**2 + x2**2 + x3**2 + x4**2 - 10.0 = 0.0 x1*x2 - 5.0*x3*x4 = 0.0 x0**3 + x1**3 + 1.0 = 0.0 """ cf = generate_constraint(generate_solvers(simplify(equations))) # slow solve pf = generate_penalty(generate_conditions(equations)) if __name__ == '__main__': from mystic.solvers import lattice from mystic.math import almostEqual result = lattice(objective, 5, [3]*5, bounds=bounds, penalty=pf, ftol=1e-8, xtol=1e-8, disp=False, full_output=True) assert almostEqual(result[0], xs, tol=1e-2) \ or almostEqual(result[0], _xs, tol=1e-2) \ or almostEqual(result[0], x_s, tol=1e-2) \ or almostEqual(result[0], xs_, tol=1e-2) assert almostEqual(result[1], ys, rel=1e-2) # EOF
def test_setexpectvar(m, expect=5.0, tol=0.001): m.set_expect_var(expect, f, tol=tol) assert almostEqual(m.expect_var(f), expect, tol=tol)
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)
def test_setexpect(m, expect=5.0, tol=0.001): #e_lo = expect - expect #e_hi = expect + expect m.set_expect(expect, f, tol=tol)#, bounds=([e_lo]*m.npts, [e_hi]*m.npts)) assert almostEqual(m.expect(f), expect, tol=tol)
def test_expect(constrain=False): G = marc_surr #XXX: uses the above-provided test function function_name = G.__name__ _mean = 06.0 #NOTE: SET THE mean HERE! _range = 00.5 #NOTE: SET THE range HERE! nx = 3 #NOTE: SET THE NUMBER OF 'h' POINTS HERE! ny = 3 #NOTE: SET THE NUMBER OF 'a' POINTS HERE! nz = 3 #NOTE: SET THE NUMBER OF 'v' POINTS HERE! h_lower = [60.0] a_lower = [0.0] v_lower = [2.1] h_upper = [105.0] a_upper = [30.0] v_upper = [2.8] lower_bounds = (nx * h_lower) + (ny * a_lower) + (nz * v_lower) upper_bounds = (nx * h_upper) + (ny * a_upper) + (nz * v_upper) bounds = (lower_bounds, upper_bounds) if debug: print " model: f(x) = %s(x)" % function_name print " mean: %s" % _mean print " range: %s" % _range print "..............\n" if debug: param_string = "[" for i in range(nx): param_string += "'x%s', " % str(i + 1) for i in range(ny): param_string += "'y%s', " % str(i + 1) for i in range(nz): param_string += "'z%s', " % str(i + 1) param_string = param_string[:-2] + "]" print " parameters: %s" % param_string print " lower bounds: %s" % lower_bounds print " upper bounds: %s" % upper_bounds # print " ..." wx = [1.0 / float(nx)] * nx wy = [1.0 / float(ny)] * ny wz = [1.0 / float(nz)] * nz from mystic.math.measures import _pack, _unpack wts = _pack([wx, wy, wz]) weights = [i[0] * i[1] * i[2] for i in wts] if not constrain: constraints = None else: # impose a mean constraint on 'thickness' h_mean = (h_upper[0] + h_lower[0]) / 2.0 h_error = 1.0 v_mean = (v_upper[0] + v_lower[0]) / 2.0 v_error = 0.05 if debug: print "impose: mean[x] = %s +/- %s" % (str(h_mean), str(h_error)) print "impose: mean[z] = %s +/- %s" % (str(v_mean), str(v_error)) def constraints(x, w): from mystic.math.discrete import compose, decompose c = compose(x, w) E = float(c[0].mean) if not (E <= float(h_mean + h_error)) or not ( float(h_mean - h_error) <= E): c[0].mean = h_mean E = float(c[2].mean) if not (E <= float(v_mean + v_error)) or not ( float(v_mean - v_error) <= E): c[2].mean = v_mean return decompose(c)[0] from mystic.math.measures import mean, expectation, impose_expectation samples = impose_expectation((_mean,_range), G, (nx,ny,nz), bounds, \ weights, constraints=constraints) smp = _unpack(samples, (nx, ny, nz)) if debug: from numpy import array # rv = [xi]*nx + [yi]*ny + [zi]*nz print "\nsolved [x]: %s" % array(smp[0]) print "solved [y]: %s" % array(smp[1]) print "solved [z]: %s" % array(smp[2]) #print "solved: %s" % smp mx = mean(smp[0]) my = mean(smp[1]) mz = mean(smp[2]) if debug: print "\nmean[x]: %s" % mx # weights are all equal print "mean[y]: %s" % my # weights are all equal print "mean[z]: %s\n" % mz # weights are all equal if constrain: assert almostEqual(mx, h_mean, tol=h_error) assert almostEqual(mz, v_mean, tol=v_error) Ex = expectation(G, samples, weights) cost = (Ex - _mean)**2 if debug: print "expect: %s" % Ex print "cost = (E[G] - m)^2: %s" % cost assert almostEqual(cost, 0.0, 0.01)
def test_set_behavior(): from mystic.math import almostEqual from numpy import inf # check basic behavior for set of two points s = set([point(1.0, 1.0), point(3.0, 2.0)]) #XXX: s + [pt, pt] => broken assert almostEqual(s.mean, 2.33333333) assert almostEqual(s.range, 2.0) assert almostEqual(s.mass, 3.0) # basic behavior for an admissable set s.normalize() s.mean = 1.0 s.range = 1.0 assert almostEqual(s.mean, 1.0) assert almostEqual(s.range, 1.0) assert almostEqual(s.mass, 1.0) # add and remove points # test special cases: SUM(weights)=0, RANGE(samples)=0, SUM(samples)=0 s.append(point(1.0, -1.0)) assert s.mean == -inf assert almostEqual(s.range, 1.0) assert almostEqual(s.mass, 0.0) ''' _ave = s.mean s.mean = 1.0 assert str(s.mean) == 'nan' assert str(s.range) == 'nan' assert almostEqual(s.mass, 0.0) s.normalize() assert str(s.mass) == 'nan' s.mean = _ave ''' s.pop() s[0] = point(1.0, 1.0) s[1] = point(-1.0, 1.0) assert almostEqual(s.mean, 0.0) assert almostEqual(s.range, 2.0) assert almostEqual(s.mass, 2.0) s.normalize() s.mean = 1.0 assert almostEqual(s.mean, 1.0) assert almostEqual(s.range, 2.0) assert almostEqual(s.mass, 1.0) s[0] = point(1.0, 1.0) s[1] = point(1.0, 1.0) assert almostEqual(s.mean, 1.0) assert almostEqual(s.range, 0.0) assert almostEqual(s.mass, 2.0) s.range = 1.0 assert str(s.mean) == 'nan' assert str(s.range) == 'nan' assert almostEqual(s.mass, 2.0) return
from mystic.solvers import diffev2, fmin_powell from mystic.math import almostEqual # from mystic.monitors import VerboseMonitor # mon = VerboseMonitor(10) result = diffev2(objective, args=args, x0=bounds, bounds=bounds, npop=40, ftol=1e-8, disp=False, full_output=True) #, itermon=mon) # print(result[0]) assert almostEqual(result[0], xs, tol=1e-8) \ or almostEqual(result[0], xs_,tol=1e-8) assert almostEqual(result[1], ys, tol=1e-5) result = fmin_powell(objective, args=args, x0=[0.0, 0.0, 0.0], bounds=bounds, disp=False, full_output=True) assert almostEqual(result[0], xs, tol=1e-8) \ or almostEqual(result[0], xs_,tol=1e-8) assert almostEqual(result[1], ys, tol=1e-5) # EOF
from mystic.solvers import diffev2, fmin_powell from mystic.math import almostEqual # from mystic.monitors import VerboseMonitor # mon = VerboseMonitor(10) result = diffev2(objective, args=args, x0=bounds, bounds=bounds, npop=40, ftol=1e-8, gtol=100, disp=False, full_output=True) #, itermon=mon) # print("%s %s" % (result[0], xs)) assert almostEqual(result[0], xs, rel=1e-1) assert almostEqual(result[1], ys, rel=1e-1) result = fmin_powell(objective, args=args, x0=[0.0, 0.0], bounds=bounds, disp=False, full_output=True) # print("%s %s" % (result[0], xs)) assert almostEqual(result[0], xs, rel=1e-1) assert almostEqual(result[1], ys, rel=1e-1) # mon = VerboseMonitor(10) result = diffev2(objective, args=args,
def test_rosenbrock(verbose=False): """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 """ if verbose: 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 if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 2.29478683682e-13, tol=3e-3) # DifferentialEvolutionSolver2 if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 3.84824937598e-15, tol=3e-3) # NelderMeadSimplexSolver if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 1.08732211477e-09, tol=3e-3) # PowellDirectionalSolver if verbose: 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 if verbose: print("Solution: %s" % sol) print("f value: %s" % fx) print("Iterations: %s" % solver.generations) print("Function evaluations: %s" % len(esow.x)) print("Time elapsed: %s seconds" % time_elapsed) assert almostEqual(fx, 0.0, tol=3e-3)
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)
if __name__ == '__main__': from mystic.solvers import diffev2, lattice from mystic.math import almostEqual from mystic.monitors import Monitor, VerboseMonitor mon = VerboseMonitor(10) #,10) #result = lattice(objective, 12, 960, bounds=bounds, penalty=penalty, constraints=constraint, ftol=1e-6, xtol=1e-6, disp=True, full_output=True, itermon=mon, maxiter=25) #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=80, gtol=100, disp=True, full_output=True) #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=constraint, npop=1000, ftol=1e-8, gtol=50, disp=True, full_output=True, cross=0.9, scale=0.9, itermon=mon) #FIXME: SOLVES at about 20%?... but w/ last 2 fixed 90%? result = diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=constraint, npop=360, ftol=1e-8, gtol=200, disp=True, full_output=True, cross=0.2, scale=0.9, itermon=mon) print result[0] assert almostEqual(result[0], xs, tol=1e-8) #XXX: fails b/c rel & zero? assert almostEqual(result[1], ys, tol=1e-4) # EOF
solver = as_constraint(penalty) #solver = discrete(range(11))(solver) #XXX: MOD = range(11) instead of LARGE #FIXME: constrain to 'int' with discrete is very fragile! required #MODs def constraint(x): from numpy import round return round(solver(x)) # better is to constrain to integers, penalize otherwise from mystic.constraints import integers @integers() def round(x): return x if __name__ == '__main__': from mystic.solvers import diffev2 from mystic.math import almostEqual result = diffev2(objective, x0=bounds, bounds=bounds, penalty=penalty, constraints=round, npop=30, gtol=50, disp=True, full_output=True) print(result[0]) assert almostEqual(result[0], xs, tol=1e-8) #XXX: fails b/c rel & zero? assert almostEqual(result[1], ys, tol=1e-4) # EOF
# # test fcalls <= maxfun # assert my_x[3] <= maxfun if maxiter is not None: # test iters <= maxiter assert my_x[2] <= maxiter return if __name__ == '__main__': x0 = [0, 0, 0] # check solutions versus results based on the random_seed # print("comparing against known results") sol = solvers.diffev(rosen, x0, npop=40, disp=0, full_output=True) assert almostEqual(sol[1], 0.0020640145337293249, tol=3e-3) sol = solvers.diffev2(rosen, x0, npop=40, disp=0, full_output=True) assert (almostEqual(sol[1], 0.0017516784703663288, tol=3e-3) or almostEqual(sol[1], 0.00496876027278, tol=3e-3)) # python3.x sol = solvers.fmin_powell(rosen, x0, disp=0, full_output=True) assert almostEqual(sol[1], 8.3173488898295291e-23) sol = solvers.fmin(rosen, x0, disp=0, full_output=True) assert almostEqual(sol[1], 1.1605792769954724e-09) solver2 = 'diffev2' for solver in ['diffev']: # print("comparing %s and %s from mystic" % (solver, solver2)) test_solvers(solver, solver2, x0, npop=40) test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=0) test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=1) test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=2)
xs = polyfit(x, y, 1) xs_ = polyfit(x, y, 2) ys = objective(xs, x, y) ys_ = objective(xs_, x, y) if __name__ == '__main__': from mystic.solvers import diffev2, fmin_powell from mystic.math import almostEqual # from mystic.monitors import VerboseMonitor # mon = VerboseMonitor(10) result = diffev2(objective, args=args, x0=bounds, bounds=bounds, npop=40, ftol=1e-8, gtol=100, disp=False, full_output=True)#, itermon=mon) # print result[0], xs assert almostEqual(result[0], xs, rel=1e-1) assert almostEqual(result[1], ys, rel=1e-1) result = fmin_powell(objective, args=args, x0=[0.0,0.0], bounds=bounds, disp=False, full_output=True) # print result[0], xs assert almostEqual(result[0], xs, rel=1e-1) assert almostEqual(result[1], ys, rel=1e-1) # mon = VerboseMonitor(10) result = diffev2(objective, args=args, x0=bounds_, bounds=bounds_, npop=40, ftol=1e-8, gtol=100, disp=False, full_output=True)#, itermon=mon) # print result[0], xs_ assert almostEqual(result[0], xs_, tol=1e-1) assert almostEqual(result[1], ys_, rel=1e-1) result = fmin_powell(objective, args=args, x0=[0.0,0.0,0.0], bounds=bounds_, disp=False, full_output=True) # print result[0], xs_
from mystic.solvers import diffev2 from mystic.math import almostEqual from mystic.monitors import Monitor, VerboseMonitor mon = VerboseMonitor(10) #,10) result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=52, ftol=1e-8, gtol=1000, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) # FIXME: solves at 0%... but w/ vowels fixed 80%? #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=52, ftol=1e-8, gtol=2000, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=130, ftol=1e-8, gtol=1000, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=260, ftol=1e-8, gtol=500, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) #result = diffev2(objective, x0=bounds, bounds=bounds, penalty=pf, constraints=constraint, npop=520, ftol=1e-8, gtol=100, disp=True, full_output=True, cross=0.1, scale=0.9, itermon=mon) print(result[0]) assert almostEqual(result[0], xs, tol=1e-8) assert almostEqual(result[1], ys, tol=1e-4) # EOF
from mystic.symbolic import generate_constraint, generate_solvers, solve from mystic.symbolic import generate_penalty, generate_conditions equations = """ x0**2 - x1 + 1.0 <= 0.0 1.0 - x0 + (x1 - 4)**2 <= 0.0 """ #cf = generate_constraint(generate_solvers(solve(equations))) #XXX: inequalities pf = generate_penalty(generate_conditions(equations), k=1e12) from mystic.constraints import as_constraint cf = as_constraint(pf) if __name__ == '__main__': from mystic.solvers import buckshot from mystic.math import almostEqual result = buckshot(objective, 2, 40, bounds=bounds, penalty=pf, disp=False, full_output=True) assert almostEqual(result[0], xs, tol=1e-2) assert almostEqual(result[1], ys, rel=1e-2) # EOF
# # test fcalls <= maxfun # assert my_x[3] <= maxfun if maxiter is not None: # test iters <= maxiter assert my_x[2] <= maxiter return if __name__ == '__main__': x0 = [0, 0, 0] # check solutions versus results based on the random_seed print "comparing against known results" sol = solvers.diffev(rosen, x0, npop=40, disp=0, full_output=True) assert almostEqual(sol[1], 0.0020640145337293249, tol=3e-3) sol = solvers.diffev2(rosen, x0, npop=40, disp=0, full_output=True) assert almostEqual(sol[1], 0.0017516784703663288, tol=3e-3) sol = solvers.fmin_powell(rosen, x0, disp=0, full_output=True) assert almostEqual(sol[1], 8.3173488898295291e-23) sol = solvers.fmin(rosen, x0, disp=0, full_output=True) assert almostEqual(sol[1], 1.1605792769954724e-09) solver2 = 'diffev2' for solver in ['diffev']: print "comparing %s and %s from mystic" % (solver, solver2) test_solvers(solver, solver2, x0, npop=40) # test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=0) # test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=1) # test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=2) # test_solvers(solver, solver2, x0, npop=40, maxiter=None, maxfun=9)