def local_optimize(cost, x0, lb, ub):
from mystic.solvers import PowellDirectionalSolver
from mystic.termination import NormalizedChangeOverGeneration as NCOG
from mystic.monitors import VerboseMonitor, Monitor
maxiter = 1000
maxfun = 1e+6
convergence_tol = 1e-4
#stepmon = VerboseMonitor(100)
stepmon = Monitor()
evalmon = Monitor()
ndim = len(lb)
solver = PowellDirectionalSolver(ndim)
solver.SetInitialPoints(x0)
solver.SetStrictRanges(min=lb, max=ub)
solver.SetEvaluationLimits(maxiter, maxfun)
solver.SetEvaluationMonitor(evalmon)
solver.SetGenerationMonitor(stepmon)
tol = convergence_tol
solver.Solve(cost, termination=NCOG(tol))
solved_params = solver.bestSolution
solved_energy = solver.bestEnergy
func_evals = solver.evaluations
return solved_params, solved_energy, func_evals
def local_optimize(cost,x0,lb,ub): from mystic.solvers import PowellDirectionalSolver from mystic.termination import NormalizedChangeOverGeneration as NCOG from mystic.monitors import VerboseMonitor, Monitor maxiter = 1000 maxfun = 1e+6 convergence_tol = 1e-4 #def func_unpickle(filename): # """ standard pickle.load of function from a File """ # import dill as pickle # return pickle.load(open(filename,'r')) #stepmon = VerboseMonitor(100) stepmon = Monitor() evalmon = Monitor() ndim = len(lb) solver = PowellDirectionalSolver(ndim) solver.SetInitialPoints(x0) solver.SetStrictRanges(min=lb,max=ub) solver.SetEvaluationLimits(maxiter,maxfun) solver.SetEvaluationMonitor(evalmon) solver.SetGenerationMonitor(stepmon) tol = convergence_tol #cost = func_unpickle(cost) #XXX: regenerate cost function from file solver.Solve(cost, termination=NCOG(tol)) solved_params = solver.bestSolution solved_energy = solver.bestEnergy func_evals = solver.evaluations return solved_params, solved_energy, func_evals
print "Powell Direction Set Method"
print "==========================="
start = time.time()
from mystic.monitors import Monitor, VerboseMonitor
stepmon = VerboseMonitor(1, 1)
#stepmon = Monitor() #VerboseMonitor(10)
from mystic.termination import NormalizedChangeOverGeneration as NCOG
#from mystic._scipyoptimize import fmin_powell
from mystic.solvers import fmin_powell, PowellDirectionalSolver
#print fmin_powell(rosen,x0,retall=0,full_output=0)#,maxiter=14)
solver = PowellDirectionalSolver(len(x0))
solver.SetInitialPoints(x0)
solver.SetStrictRanges(min, max)
#solver.SetEvaluationLimits(generations=13)
solver.SetGenerationMonitor(stepmon)
solver.SetConstraints(constrain)
solver.enable_signal_handler()
solver.Solve(rosen, NCOG(tolerance=1e-4), disp=1)
print solver.bestSolution
#print "Current function value: %s" % solver.bestEnergy
#print "Iterations: %s" % solver.generations
#print "Function evaluations: %s" % solver.evaluations
times.append(time.time() - start)
algor.append("Powell's Method\t")
for k in range(len(algor)):
print algor[k], "\t -- took", times[k]
# end of file
def solve(measurements, method):
"""Find reasonable marker positions based on a set of measurements."""
print(method)
marker_measurements = measurements
if np.size(measurements) == 21:
marker_measurements = measurements[(21 - 15) :]
# m0 has known positions (0, 0, 0)
# m1 has unknown x-position
# All others have unknown xy-positions
num_params = 0 + 1 + 2 + 2 + 2 + 2
bound = 400.0
lower_bound = [
0.0,
0.0,
0.0,
0.0,
0.0,
-bound,
0.0,
-bound,
0.0,
]
upper_bound = [
bound,
bound,
bound,
bound,
bound,
bound,
bound,
bound,
bound,
]
def costx_no_nozzle(posvec):
"""Identical to cost_no_nozzle, except the shape of inputs"""
positions = posvec2matrix_no_nozzle(posvec)
return cost_no_nozzle(positions, marker_measurements)
guess_0 = [0.0] * num_params
intermediate_cost = 0.0
intermediate_solution = []
if method == "SLSQP":
sol = scipy.optimize.minimize(
costx_no_nozzle,
guess_0,
method="SLSQP",
bounds=list(zip(lower_bound, upper_bound)),
tol=1e-20,
options={"disp": True, "ftol": 1e-40, "eps": 1e-10, "maxiter": 500},
)
intermediate_cost = sol.fun
intermediate_solution = sol.x
elif method == "L-BFGS-B":
sol = scipy.optimize.minimize(
costx_no_nozzle,
guess_0,
method="L-BFGS-B",
bounds=list(zip(lower_bound, upper_bound)),
options={"disp": True, "ftol": 1e-12, "gtol": 1e-12, "maxiter": 50000, "maxfun": 1000000},
)
intermediate_cost = sol.fun
intermediate_solution = sol.x
elif method == "PowellDirectionalSolver":
from mystic.solvers import PowellDirectionalSolver
from mystic.termination import Or, CollapseAt, CollapseAs
from mystic.termination import ChangeOverGeneration as COG
from mystic.monitors import VerboseMonitor
from mystic.termination import VTR, And, Or
solver = PowellDirectionalSolver(num_params)
solver.SetRandomInitialPoints(lower_bound, upper_bound)
solver.SetEvaluationLimits(evaluations=3200000, generations=100000)
solver.SetTermination(Or(VTR(1e-25), COG(1e-10, 20)))
solver.SetStrictRanges(lower_bound, upper_bound)
solver.SetGenerationMonitor(VerboseMonitor(5))
solver.Solve(costx_no_nozzle)
intermediate_cost = solver.bestEnergy
intermediate_solution = solver.bestSolution
elif method == "differentialEvolutionSolver":
from mystic.solvers import DifferentialEvolutionSolver2
from mystic.monitors import VerboseMonitor
from mystic.termination import VTR, ChangeOverGeneration, And, Or
from mystic.strategy import Best1Exp, Best1Bin
stop = Or(VTR(1e-18), ChangeOverGeneration(1e-9, 500))
npop = 3
stepmon = VerboseMonitor(100)
solver = DifferentialEvolutionSolver2(num_params, npop)
solver.SetEvaluationLimits(evaluations=3200000, generations=100000)
solver.SetRandomInitialPoints(lower_bound, upper_bound)
solver.SetStrictRanges(lower_bound, upper_bound)
solver.SetGenerationMonitor(stepmon)
solver.Solve(
costx_no_nozzle,
termination=stop,
strategy=Best1Bin,
)
intermediate_cost = solver.bestEnergy
intermediate_solution = solver.bestSolution
else:
print("Method %s is not supported!" % method)
sys.exit(1)
print("Best intermediate cost: ", intermediate_cost)
print("Best intermediate positions: \n%s" % posvec2matrix_no_nozzle(intermediate_solution))
if np.size(measurements) == 15:
print("Got only 15 samples, so will not try to find nozzle position\n")
return
nozzle_measurements = measurements[: (21 - 15)]
# Look for nozzle's xyz-offset relative to marker 0
num_params = 3
lower_bound = [
0.0,
0.0,
-bound,
]
upper_bound = [bound, bound, 0.0]
def costx_nozzle(posvec):
"""Identical to cost_nozzle, except the shape of inputs"""
positions = posvec2matrix_nozzle(posvec, intermediate_solution)
return cost_nozzle(positions, measurements)
guess_0 = [0.0, 0.0, 0.0]
final_cost = 0.0
final_solution = []
if method == "SLSQP":
sol = scipy.optimize.minimize(
costx_nozzle,
guess_0,
method="SLSQP",
bounds=list(zip(lower_bound, upper_bound)),
tol=1e-20,
options={"disp": True, "ftol": 1e-40, "eps": 1e-10, "maxiter": 500},
)
final_cost = sol.fun
final_solution = sol.x
elif method == "L-BFGS-B":
sol = scipy.optimize.minimize(
costx_nozzle,
guess_0,
method="L-BFGS-B",
bounds=list(zip(lower_bound, upper_bound)),
options={"disp": True, "ftol": 1e-12, "gtol": 1e-12, "maxiter": 50000, "maxfun": 1000000},
)
final_cost = sol.fun
final_solution = sol.x
elif method == "PowellDirectionalSolver":
from mystic.solvers import PowellDirectionalSolver
from mystic.termination import Or, CollapseAt, CollapseAs
from mystic.termination import ChangeOverGeneration as COG
from mystic.monitors import VerboseMonitor
from mystic.termination import VTR, And, Or
solver = PowellDirectionalSolver(num_params)
solver.SetRandomInitialPoints(lower_bound, upper_bound)
solver.SetEvaluationLimits(evaluations=3200000, generations=100000)
solver.SetTermination(Or(VTR(1e-25), COG(1e-10, 20)))
solver.SetStrictRanges(lower_bound, upper_bound)
solver.SetGenerationMonitor(VerboseMonitor(5))
solver.Solve(costx_nozzle)
final_cost = solver.bestEnergy
final_solution = solver.bestSolution
elif method == "differentialEvolutionSolver":
from mystic.solvers import DifferentialEvolutionSolver2
from mystic.monitors import VerboseMonitor
from mystic.termination import VTR, ChangeOverGeneration, And, Or
from mystic.strategy import Best1Exp, Best1Bin
stop = Or(VTR(1e-18), ChangeOverGeneration(1e-9, 500))
npop = 3
stepmon = VerboseMonitor(100)
solver = DifferentialEvolutionSolver2(num_params, npop)
solver.SetEvaluationLimits(evaluations=3200000, generations=100000)
solver.SetRandomInitialPoints(lower_bound, upper_bound)
solver.SetStrictRanges(lower_bound, upper_bound)
solver.SetGenerationMonitor(stepmon)
solver.Solve(
costx_nozzle,
termination=stop,
strategy=Best1Bin,
)
final_cost = solver.bestEnergy
final_solution = solver.bestSolution
print("Best final cost: ", final_cost)
print("Best final positions:")
final = posvec2matrix_nozzle(final_solution, intermediate_solution)[1:]
for num in range(0, 6):
print(
"{0: 8.3f} {1: 8.3f} {2: 8.3f} <!-- Marker {3} -->".format(final[num][0], final[num][1], final[num][2], num)
)
