from mystic.termination import ChangeOverGeneration as COG # update termination condition with new masks ## termination should be Or(*conditions), where ## conditions are: COG(), Collapse*(), and possibly others. # takes termination condition (or solver?) and returns termination condition # also requires updated masks as input verbose = True #False #from mystic.models import rosen as model; target = 1.0 from mystic.models import sphere as model target = 0.0 n = 10 #term = Or((COG(generations=300), CollapseAt(None, generations=100), CollapseAs(generations=100))) term = Or((COG(generations=500), CollapseAt(target, generations=100))) #term = COG(generations=500) from mystic.solvers import DifferentialEvolutionSolver as TheSolver #from mystic.solvers import PowellDirectionalSolver as TheSolver from mystic.solvers import BuckshotSolver #solver = BuckshotSolver(n, 10) solver = TheSolver(n) solver.SetRandomInitialPoints() solver.SetStrictRanges(min=[0] * n, max=[5] * n) solver.SetEvaluationLimits(evaluations=320000, generations=1000) solver.SetTermination(term) #from mystic.termination import state #print state(solver._termination).keys() solver.Solve(model, disp=verbose)
@suppressed(1e-2)
def conserve(x):
return constrain(x)
from mystic.monitors import VerboseMonitor
mon = VerboseMonitor(10)
# solve the dual for alpha
from mystic.solvers import DifferentialEvolutionSolver as DESolver
from mystic.termination import Or, ChangeOverGeneration, CollapseAt
ndim = len(lb)
npop = nx * 3
stop = Or(ChangeOverGeneration(1e-8, 200), CollapseAt(0.0))
solver = DESolver(ndim, npop)
solver.SetRandomInitialPoints(min=lb, max=_b)
solver.SetStrictRanges(min=lb, max=ub)
solver.SetGenerationMonitor(mon)
solver.SetConstraints(conserve)
solver.SetTermination(stop)
solver.Solve(objective, ExtraArgs=(Q, b), disp=1)
alpha = solver.bestSolution
print 'solved x: ', alpha
print "constraint A*x == 0: ", inner(Aeq, alpha)
print "minimum 0.5*x'Qx + b'*x: ", solver.bestEnergy
# calculate weight vectors, support vectors, and bias
wv = WeightVector(alpha, X, y)
def solve(samp, xyz_of_samp, _cost, method, cx_is_positive=False):
"""Find reasonable positions and anchors given a set of samples.
"""
u = np.shape(samp)[0]
ux = np.shape(xyz_of_samp)[0]
number_of_params_pos = 3*(u - ux)
def costx(posvec, anchvec):
"""Identical to cost, except the shape of inputs and capture of samp, xyz_of_samp, ux, and u
Parameters
----------
x : [A_ay A_az A_bx A_by A_bz A_cx A_cy A_cz A_dz
x1 y1 z1 x2 y2 z2 ... xu yu zu
"""
anchors = anchorsvec2matrix(anchvec)
pos = np.zeros((u, 3))
if(np.size(xyz_of_samp) != 0):
pos[0:ux] = xyz_of_samp
pos[ux:] = np.reshape(posvec, (u-ux,3))
return _cost(anchors, pos, samp)
l_long = 5000.0
l_short = 1700.0
data_z_min = -20.0
# Limits of anchor positions:
# |ANCHOR_XY| < 4000
# ANCHOR_B_X > 0
# ANCHOR_C_X < 0
# |ANCHOR_ABC_Z| < 1700
# 0 < ANCHOR_D_Z < 4000
# Limits of data collection volume:
# |x| < 1700
# |y| < 1700
# -20.0 < z < 3400.0
# Define bounds
lb = [ -l_long, # A_ay > -4000.0
-l_short, # A_az > -1700.0
0.0, # A_bx > 0
0.0, # A_by > 0
-l_short, # A_bz > -1700.0
-l_long, # A_cx > -4000
0.0, # A_cy > 0
-l_short, # A_cz > -1700.0
0.0, # A_dz > 0
] + [-l_short, -l_short, data_z_min]*(u-ux)
ub = [ 0.0, # A_ay < 0
l_short, # A_az < 1700
l_long, # A_bx < 4000
l_long, # A_by < 4000
l_short, # A_bz < 1700
0.0, # A_cx < 0
l_long, # A_cy < 4000.0
l_short, # A_cz < 1700
l_long, # A_dz < 4000.0
] + [l_short, l_short, 2*l_short]*(u-ux)
# If the user has input xyz data, then signs should be ok anyways
if(ux > 2):
lb[A_bx] = -l_long
# It would work to just swap the signs of bx and cx after the optimization
# But there are fewer assumptions involved in setting correct bounds from the start instead
if(cx_is_positive):
tmp = lb[A_bx]
lb[A_bx] = lb[A_cx]
lb[A_cx] = tmp
tmp = ub[A_bx]
ub[A_bx] = ub[A_cx]
ub[A_cx] = tmp
pos_est0 = np.zeros((u-ux,3)) # The positions we need to estimate
anchors_est = np.array([[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0],
[0.0, 0.0, 0.0]])
x_guess0 = list(anchorsmatrix2vec(anchors_est)) + list(posmatrix2vec(pos_est0))
if(method == 'PowellDirectionalSolver'):
from mystic.termination import ChangeOverGeneration, NormalizedChangeOverGeneration, VTR
from mystic.solvers import PowellDirectionalSolver
from mystic.termination import Or, CollapseAt, CollapseAs
from mystic.termination import ChangeOverGeneration as COG
target = 1.0
term = Or((COG(generations=100), CollapseAt(target, generations=100)))
# Solver 0
solver0 = PowellDirectionalSolver(number_of_params_pos+params_anch)
solver0.SetEvaluationLimits(evaluations=3200000, generations=10000)
solver0.SetTermination(term)
solver0.SetInitialPoints(x_guess0)
solver0.SetStrictRanges(lb, ub)
solver0.Solve(lambda x: costx(x[params_anch:], x[0:params_anch]))
x_guess0 = solver0.bestSolution
# PowellDirectional sometimes finds new ways if kickstarted anew
for i in range(1,20):
solver0 = PowellDirectionalSolver(number_of_params_pos+params_anch)
solver0.SetInitialPoints(x_guess0)
solver0.SetStrictRanges(lb, ub)
solver0.Solve(lambda x: costx(x[params_anch:], x[0:params_anch]))
x_guess0 = solver0.bestSolution
return x_guess0
elif(method == 'SLSQP'):
# 'SLSQP' is crazy fast and lands on 0.0000 error
x_guess0 = scipy.optimize.minimize(lambda x: costx(x[params_anch:], x[0:params_anch]), x_guess0, method=method, bounds=list(zip(lb,ub)),
options={'disp':True,'ftol':1e-20, 'maxiter':150000})
return x_guess0.x
elif(method == 'L-BFGS-B'):
## 'L-BFGS-B' Is crazy fast but doesn't quite land at 0.0000 error
x_guess0 = scipy.optimize.minimize(lambda x: costx(x[params_anch:], x[0:params_anch]), x_guess0, method=method, bounds=list(zip(lb,ub)),
options={'ftol':1e-12, 'maxiter':150000})
return x_guess0.x
else:
print("Method %s is not supported!" % method)
sys.exit(1)
