def lbfgs_run(target_evaluator, use_bounds, lower_bound, upper_bound):
minimizer = lbfgsb.minimizer(
n=target_evaluator.n,
#factr=1.e+1, XXX Affects speed significantly
l=lower_bound, # lower bound
u=upper_bound, # upper bound
nbd=flex.int(target_evaluator.n,
use_bounds)) # flag to apply both bounds
minimizer.error = None
try:
icall = 0
while 1:
icall += 1
x, f, g = target_evaluator()
#print "x,f:", ",".join(["%6.3f"%x_ for x_ in x]), f, icall
have_request = minimizer.process(x, f, g)
if (have_request):
requests_f_and_g = minimizer.requests_f_and_g()
continue
assert not minimizer.requests_f_and_g()
if (minimizer.is_terminated()): break
except RuntimeError as e:
minimizer.error = str(e)
minimizer.n_calls = icall
return minimizer
def run_lbfgsb(O, iprint=-1):
n = O.x.size()
minimizer = lbfgsb.minimizer(
n=n,
m=5,
l=O.l,
u=O.u,
nbd=O.nbd,
enable_stp_init=True,
factr=1.0e+7,
pgtol=1.0e-5,
iprint=iprint)
f,g = O.compute_functional_and_gradients()
while True:
if (minimizer.process(O.x, f, g)):
f, g = O.compute_functional_and_gradients()
elif (minimizer.requests_stp_init()):
new_stp = O.adjust_stp(
stp=minimizer.relative_step_length_line_search(),
csd=minimizer.current_search_direction())
minimizer.set_relative_step_length_line_search(value=new_stp)
elif (minimizer.is_terminated()):
O.callback_after_step_no_counting(suffix=" FINAL")
break
else:
O.callback_after_step(minimizer=None)
return minimizer
def __init__(self, calculator, max_iterations=None):
M = lbfgsb_core.minimizer(n=calculator.n,
l=calculator.lower_bound,
u=calculator.upper_bound,
nbd=calculator.bound_flags)
M.error = None
try:
icall = 0
while 1:
icall += 1
x, f, g = calculator() # x will be changed in place
if (icall == 1): f_start = f
have_request = M.process(x, f, g)
if (have_request):
requests_f_and_g = M.requests_f_and_g()
continue
assert not M.requests_f_and_g()
if (M.is_terminated()): break
if (max_iterations is not None and icall > max_iterations):
break
except RuntimeError as e:
M.error = str(e)
M.n_calls = icall
# items to store
self.M = M
self.f_start = f_start
self.f = f
self.nfev = self.M.n_calls
self.calculator = calculator
def __init__(self, current_x=None, parameterization=None, refinery=None,
ISIGI = None, indices = None, bins = None, out=None,
min_iterations=0, max_calls=1000, max_drop_eps=1.e-10,
show_finite_differences = False):
adopt_init_args(self, locals())
self.n = current_x.size()
self.x = current_x
from scitbx import lbfgsb
l = flex.double(self.n, 1e-8)
if len(l) > 3:
l[7] = 0 # eta
l[8] = 1e-15 # g*0
l[9] = 1e-15 # g*1
self.minimizer = lbfgsb.minimizer(
n = self.n,
l = l,
u = flex.double(self.n, 0),
nbd = flex.int(self.n, 1),
)
while True:
self.compute_functional_and_gradients()
if self.minimizer.process(self.x, self.f, self.g):
pass
elif self.minimizer.is_terminated():
break
def lbfgs_run(target_evaluator,
use_bounds,
lower_bound,
upper_bound,
max_iterations=None):
minimizer = lbfgsb.minimizer(
n=target_evaluator.n,
#factr=1.e+1, XXX Affects speed significantly
l=lower_bound, # lower bound
u=upper_bound, # upper bound
nbd=flex.int(target_evaluator.n,
use_bounds)) # flag to apply both bounds
minimizer.error = None
try:
icall = 0
while 1:
icall += 1
x, f, g = target_evaluator()
#print "x,f:", ",".join(["%6.3f"%x_ for x_ in x]), f, icall
have_request = minimizer.process(x, f, g)
if (have_request):
requests_f_and_g = minimizer.requests_f_and_g()
continue
assert not minimizer.requests_f_and_g()
if (minimizer.is_terminated()): break
# XXX temp fix for python3 failure (run_lbfgs in tncs)
# Failure is that max_iterations is None
# temp fix is to break if max_iterations is None or icall>max_iterations
#if(icall>max_iterations): break
if ((max_iterations is None) or (icall > max_iterations)): break
except RuntimeError as e:
minimizer.error = str(e)
minimizer.n_calls = icall
return minimizer
def run_lbfgsb(O, iprint=-1):
n = O.x.size()
minimizer = lbfgsb.minimizer(
n=n,
m=5,
l=O.l,
u=O.u,
nbd=O.nbd,
enable_stp_init=True,
factr=1.0e+7,
pgtol=1.0e-5,
iprint=iprint)
f,g = O.compute_functional_and_gradients()
while True:
if (minimizer.process(O.x, f, g)):
f, g = O.compute_functional_and_gradients()
elif (minimizer.requests_stp_init()):
new_stp = O.adjust_stp(
stp=minimizer.relative_step_length_line_search(),
csd=minimizer.current_search_direction())
minimizer.set_relative_step_length_line_search(value=new_stp)
elif (minimizer.is_terminated()):
O.callback_after_step_no_counting(suffix=" FINAL")
break
else:
O.callback_after_step(minimizer=None)
return minimizer
def __init__(self,
current_x=None,
parameterization=None,
refinery=None,
ISIGI=None,
indices=None,
bins=None,
out=None,
min_iterations=0,
max_calls=1000,
max_drop_eps=1.e-10,
show_finite_differences=False):
adopt_init_args(self, locals())
self.n = current_x.size()
self.x = current_x
if False:
self.diag_mode = "always"
from scitbx import lbfgs
self.minimizer = lbfgs.run(
target_evaluator=self,
termination_params=lbfgs.termination_parameters(
traditional_convergence_test=False,
drop_convergence_test_max_drop_eps=max_drop_eps,
min_iterations=min_iterations,
max_iterations=None,
max_calls=max_calls),
exception_handling_params=lbfgs.exception_handling_parameters(
ignore_line_search_failed_rounding_errors=True,
ignore_line_search_failed_step_at_lower_bound=
True, #the only change from default
ignore_line_search_failed_step_at_upper_bound=False,
ignore_line_search_failed_maxfev=False,
ignore_line_search_failed_xtol=False,
ignore_search_direction_not_descent=False))
else:
from scitbx import lbfgsb
l = flex.double(self.n, 1e-8)
if len(l) > 3:
for p in xrange(7, len(l)):
l[p] = 1e-15 # g*
self.minimizer = lbfgsb.minimizer(
n=self.n,
l=l,
u=flex.double(self.n, 0),
nbd=flex.int(self.n, 1),
)
while True:
self.compute_functional_and_gradients()
if self.minimizer.process(self.x, self.f, self.g):
pass
elif self.minimizer.is_terminated():
break
def run_minimizer(self):
comm = self.mpi_helper.comm
MPI = self.mpi_helper.MPI
size = self.mpi_helper.size
self.n = 3
self.x = flex.double([self.sfac, self.sb, self.sadd])
self.logger.main_log(
'Initial Parameter Estimates = sdfac: %.2f sdb: %.2f sdadd: %.2f'
% (self.sfac, self.sb, self.sadd))
if True:
from scitbx import lbfgsb
l = flex.double(self.n, 1e-8)
if len(l) > 3:
for p in range(7, len(l)):
l[p] = 1e-15 # g*
if self.mpi_helper.rank == 0:
self.minimizer = lbfgsb.minimizer(
n=self.n,
l=l,
u=flex.double(self.n, 0),
nbd=flex.int(self.n, 1),
)
while True:
self.compute_functional_and_gradients()
status = -1
if self.mpi_helper.rank == 0:
if self.minimizer.process(self.x, self.f, self.g):
self.logger.main_log(
'intermediate minimization results = functional: %.2f sdfac: %.2f sdb: %.2f sdadd: %.2f'
% (self.f, self.x[0], self.x[1], self.x[2]))
status = 1
self.sfac = self.x[0]
self.sb = self.x[1]
self.sadd = self.x[2]
elif self.minimizer.is_terminated():
status = 0
comm.barrier()
status = comm.bcast(status, root=0)
if status == 1:
self.sfac = comm.bcast(self.sfac, root=0)
self.sb = comm.bcast(self.sb, root=0)
self.sadd = comm.bcast(self.sadd, root=0)
pass
if status == 0:
break
if self.mpi_helper.rank == 0:
self.logger.main_log(
'FINAL SDFAC VALUES = functional: %.2f sdfac: %.2f sdb: %.2f sdadd: %.2f'
% (self.f, self.x[0], self.x[1], self.x[2]))
def run(self):
l = flex.double(self.n, 0)
u = flex.double(self.n, 0)
nbd = flex.int(self.n, 0)
if (self.apply_lower_bounds_on_b):
bound_flags = self.gaussian_fit.bound_flags(False, True)
nbd.set_selected(bound_flags, 1)
self.minimizer = lbfgsb.minimizer(n=self.n,
m=self.lbfgsb_m,
l=l,
u=u,
nbd=nbd,
iprint=self.iprint)
self.x = flex.double(self.n, 0)
self.f = 0
self.g = flex.double(self.n, 0)
while True:
if (self.minimizer.process(self.x, self.f, self.g,
self.use_fortran_library)):
self.compute_fg()
elif (self.minimizer.is_terminated()):
break
def lbfgs_run(target_evaluator, use_bounds, lower_bound, upper_bound):
minimizer = lbfgsb.minimizer(
n = target_evaluator.n,
#factr=1.e+1, XXX Affects speed significantly
l = lower_bound, # lower bound
u = upper_bound, # upper bound
nbd = flex.int(target_evaluator.n, use_bounds)) # flag to apply both bounds
minimizer.error = None
try:
icall = 0
while 1:
icall += 1
x, f, g = target_evaluator()
#print "x,f:", ",".join(["%6.3f"%x_ for x_ in x]), f, icall
have_request = minimizer.process(x, f, g)
if(have_request):
requests_f_and_g = minimizer.requests_f_and_g()
continue
assert not minimizer.requests_f_and_g()
if(minimizer.is_terminated()): break
except RuntimeError, e:
minimizer.error = str(e)
def run(self):
l = flex.double(self.n, 0)
u = flex.double(self.n, 0)
nbd = flex.int(self.n, 0)
if (self.apply_lower_bounds_on_b):
bound_flags = self.gaussian_fit.bound_flags(False, True)
nbd.set_selected(bound_flags, 1)
self.minimizer = lbfgsb.minimizer(
n=self.n,
m=self.lbfgsb_m,
l=l,
u=u,
nbd=nbd,
iprint=self.iprint)
self.x = flex.double(self.n, 0)
self.f = 0
self.g = flex.double(self.n, 0)
while True:
if (self.minimizer.process(self.x, self.f, self.g,
self.use_fortran_library)):
self.compute_fg()
elif (self.minimizer.is_terminated()):
break
def __init__(self,f,s,c,x,fls):
self.f = f
self.s = s
self.xx = x
self.x = set_negative_to_zero(c.deep_copy())
self.n = len(c)
self.fls = fls
self.max_d = None
self.dx = 1.0e-6
self.tdx = 2.0*self.dx
assert (len(self.f) == len(self.s))
l = flex.double(self.n, 0)
u = flex.double(self.n, 0)
nbd = flex.int(self.n, 1)
self.minimizer = lbfgsb.minimizer(n=self.n, m=20, l=l, u=u, nbd=nbd)
self.fc, self.g = self.compute_functional_and_gradients()
while True:
if (self.minimizer.process(self.x, self.fc, self.g)):
self.fc, self.g = self.compute_functional_and_gradients()
elif (self.minimizer.is_terminated()):
break
def exercise_minimizer_interface():
n = 25
m = 5
l = flex.double(n, -1)
u = flex.double(n, 1)
nbd = flex.int(n)
factr = 1.0e7
pgtol = 1.0e-5
iprint = -1
for enable_stp_init in [False, True]:
minimizer = lbfgsb.ext.minimizer(n, m, l, u, nbd, enable_stp_init, factr, pgtol, iprint)
assert minimizer.n() == n
assert minimizer.m() == m
assert minimizer.l().id() == l.id()
assert minimizer.u().id() == u.id()
assert minimizer.nbd().id() == nbd.id()
assert minimizer.enable_stp_init() == enable_stp_init
assert eps_eq(minimizer.factr(), factr)
assert eps_eq(minimizer.pgtol(), pgtol)
assert eps_eq(minimizer.iprint(), iprint)
assert not minimizer.requests_f_and_g()
assert not minimizer.is_terminated()
assert minimizer.task() == "START"
x = flex.double(n, 0)
f = 1
g = flex.double(n, -1)
assert minimizer.process(x, f, g, False)
assert minimizer.task() == "FG_START"
assert minimizer.f() == 0
if not enable_stp_init:
try:
minimizer.requests_stp_init()
except RuntimeError, e:
assert str(e).endswith(": SCITBX_ASSERT(enable_stp_init()) failure.")
else:
raise Exception_expected
else:
assert not minimizer.process(x, f, g)
assert minimizer.requests_stp_init()
assert approx_equal(minimizer.relative_step_length_line_search(), 0.2)
assert approx_equal(minimizer.current_search_direction(), [1] * n)
minimizer.set_relative_step_length_line_search(value=0.3)
assert approx_equal(minimizer.relative_step_length_line_search(), 0.3)
assert minimizer.process(x, f, g)
assert minimizer.f() == 1
assert minimizer.task() == "FG_LNSRCH"
assert not minimizer.is_terminated()
if not enable_stp_init:
assert approx_equal(x, [0.2] * n)
else:
assert approx_equal(x, [0.3] * n)
minimizer.request_stop()
assert not minimizer.process(x, f, g)
assert minimizer.task() == "STOP: NO RESTORE"
minimizer.request_stop_with_restore()
assert minimizer.task() == "STOP: CPU"
minimizer.request_restart()
assert not minimizer.requests_f_and_g()
assert not minimizer.is_terminated()
assert minimizer.task() == "START"
minimizer = lbfgsb.minimizer(n=n)
assert minimizer.l().size() == n
assert minimizer.u().size() == n
assert minimizer.nbd().size() == n
assert minimizer.nbd().all_eq(0)
def driver1(use_fortran_library=False):
n = 25
nbd = flex.int(n)
x = flex.double(n)
l = flex.double(n)
u = flex.double(n)
g = flex.double(n)
if "--Verbose" in sys.argv[1:]:
iprint = 1000
else:
iprint = -1
for i in xrange(0, n, 2):
nbd[i] = 2
l[i] = 1.0e0
u[i] = 1.0e2
for i in xrange(1, n, 2):
nbd[i] = 2
l[i] = -1.0e2
u[i] = 1.0e2
for i in xrange(n):
x[i] = 3.0e0
minimizer = lbfgsb.minimizer(n=n, m=5, l=l, u=u, nbd=nbd, factr=1.0e7, pgtol=1.0e-5, iprint=iprint)
f = 0
while True:
if minimizer.process(x, f, g, use_fortran_library):
f = 0.25e0 * (x[0] - 1.0e0) ** 2
for i in xrange(1, n):
f = f + (x[i] - x[i - 1] ** 2) ** 2
f = 4.0e0 * f
t1 = x[1] - x[0] ** 2
g[0] = 2.0e0 * (x[0] - 1.0e0) - 1.6e1 * x[0] * t1
for i in xrange(1, n - 1):
t2 = t1
t1 = x[i + 1] - x[i] ** 2
g[i] = 8.0e0 * t2 - 1.6e1 * x[i] * t1
g[n - 1] = 8.0e0 * t1
elif minimizer.is_terminated():
break
assert minimizer.task() == "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH"
assert minimizer.f_list().size() == minimizer.n_iteration() + 1
assert minimizer.f_list()[-1] == minimizer.f()
assert minimizer.f_list()[-2] == minimizer.f_previous_iteration()
assert not minimizer.initial_x_replaced_by_projection()
assert minimizer.is_constrained()
assert minimizer.is_fully_constrained()
if "--soft" not in sys.argv[1:]:
assert minimizer.n_fg_evaluations_total() == 27
assert minimizer.n_fg_evaluations_iter() == 1
assert minimizer.n_intervals_explored_cauchy_search_total() == 48
assert minimizer.n_intervals_explored_cauchy_search_iter() == 1
assert minimizer.n_skipped_bfgs_updates_total() == 0
assert minimizer.n_bfgs_updates_total() == 22
assert minimizer.subspace_argmin_is_within_box() == 1
assert minimizer.n_free_variables() == 25
assert minimizer.n_active_constraints() == 0
assert minimizer.n_variables_leaving_active_set() == 0
assert minimizer.n_variables_entering_active_set() == 0
assert eps_eq(minimizer.theta_bfgs_matrix_current(), 23.2674689856)
assert minimizer.f_previous_iteration() >= 0
assert minimizer.floating_point_epsilon() == scitbx.math.floating_point_epsilon_double_get()
assert eps_eq(
minimizer.factr_times_floating_point_epsilon(), minimizer.factr() * minimizer.floating_point_epsilon()
)
assert eps_eq(minimizer.two_norm_line_search_direction_vector(), 1.56259327735e-05)
assert eps_eq(
minimizer.two_norm_line_search_direction_vector_sq(), minimizer.two_norm_line_search_direction_vector() ** 2
)
assert minimizer.accumulated_time_cauchy_search() > -0.02
assert minimizer.accumulated_time_subspace_minimization() > -0.02
assert minimizer.accumulated_time_line_search() > -0.02
assert eps_eq(minimizer.slope_line_search_function_current(), 9.31496613169e-10)
assert eps_eq(minimizer.slope_line_search_function_start(), -3.6762390377e-09)
assert eps_eq(minimizer.maximum_relative_step_length(), 1.37484166517)
assert eps_eq(minimizer.relative_step_length_line_search(), 1.0)
assert eps_eq(minimizer.infinity_norm_projected_gradient(), 0.000143369780806)
def exercise_minimizer_interface():
n = 25
m = 5
l = flex.double(n, -1)
u = flex.double(n, 1)
nbd = flex.int(n)
factr = 1.0e+7
pgtol = 1.0e-5
iprint = -1
for enable_stp_init in [False, True]:
minimizer = lbfgsb.ext.minimizer(n, m, l, u, nbd, enable_stp_init,
factr, pgtol, iprint)
assert minimizer.n() == n
assert minimizer.m() == m
assert minimizer.l().id() == l.id()
assert minimizer.u().id() == u.id()
assert minimizer.nbd().id() == nbd.id()
assert minimizer.enable_stp_init() == enable_stp_init
assert eps_eq(minimizer.factr(), factr)
assert eps_eq(minimizer.pgtol(), pgtol)
assert eps_eq(minimizer.iprint(), iprint)
assert not minimizer.requests_f_and_g()
assert not minimizer.is_terminated()
assert minimizer.task() == "START"
x = flex.double(n, 0)
f = 1
g = flex.double(n, -1)
assert minimizer.process(x, f, g, False)
assert minimizer.task() == "FG_START"
assert minimizer.f() == 0
if (not enable_stp_init):
try:
minimizer.requests_stp_init()
except RuntimeError as e:
assert str(e).endswith(
": SCITBX_ASSERT(enable_stp_init()) failure.")
else:
raise Exception_expected
else:
assert not minimizer.process(x, f, g)
assert minimizer.requests_stp_init()
assert approx_equal(minimizer.relative_step_length_line_search(),
0.2)
assert approx_equal(minimizer.current_search_direction(), [1] * n)
minimizer.set_relative_step_length_line_search(value=0.3)
assert approx_equal(minimizer.relative_step_length_line_search(),
0.3)
assert minimizer.process(x, f, g)
assert minimizer.f() == 1
assert minimizer.task() == "FG_LNSRCH"
assert not minimizer.is_terminated()
if (not enable_stp_init):
assert approx_equal(x, [0.2] * n)
else:
assert approx_equal(x, [0.3] * n)
minimizer.request_stop()
assert not minimizer.process(x, f, g)
assert minimizer.task() == "STOP: NO RESTORE"
minimizer.request_stop_with_restore()
assert minimizer.task() == "STOP: CPU"
minimizer.request_restart()
assert not minimizer.requests_f_and_g()
assert not minimizer.is_terminated()
assert minimizer.task() == "START"
minimizer = lbfgsb.minimizer(n=n)
assert minimizer.l().size() == n
assert minimizer.u().size() == n
assert minimizer.nbd().size() == n
assert minimizer.nbd().all_eq(0)
def driver1(use_fortran_library=False):
n = 25
nbd = flex.int(n)
x = flex.double(n)
l = flex.double(n)
u = flex.double(n)
g = flex.double(n)
if ("--Verbose" in sys.argv[1:]):
iprint = 1000
else:
iprint = -1
for i in range(0, n, 2):
nbd[i] = 2
l[i] = 1.0e0
u[i] = 1.0e2
for i in range(1, n, 2):
nbd[i] = 2
l[i] = -1.0e2
u[i] = 1.0e2
for i in range(n):
x[i] = 3.0e0
minimizer = lbfgsb.minimizer(n=n,
m=5,
l=l,
u=u,
nbd=nbd,
factr=1.0e+7,
pgtol=1.0e-5,
iprint=iprint)
f = 0
while True:
if (minimizer.process(x, f, g, use_fortran_library)):
f = .25e0 * (x[0] - 1.e0)**2
for i in range(1, n):
f = f + (x[i] - x[i - 1]**2)**2
f = 4.e0 * f
t1 = x[1] - x[0]**2
g[0] = 2.e0 * (x[0] - 1.e0) - 1.6e1 * x[0] * t1
for i in range(1, n - 1):
t2 = t1
t1 = x[i + 1] - x[i]**2
g[i] = 8.e0 * t2 - 1.6e1 * x[i] * t1
g[n - 1] = 8.e0 * t1
elif (minimizer.is_terminated()):
break
assert minimizer.task(
) == "CONVERGENCE: REL_REDUCTION_OF_F <= FACTR*EPSMCH"
assert minimizer.f_list().size() == minimizer.n_iteration() + 1
assert minimizer.f_list()[-1] == minimizer.f()
assert minimizer.f_list()[-2] == minimizer.f_previous_iteration()
assert not minimizer.initial_x_replaced_by_projection()
assert minimizer.is_constrained()
assert minimizer.is_fully_constrained()
if ("--soft" not in sys.argv[1:]):
assert minimizer.n_fg_evaluations_total() == 27
assert minimizer.n_fg_evaluations_iter() == 1
assert minimizer.n_intervals_explored_cauchy_search_total() == 48
assert minimizer.n_intervals_explored_cauchy_search_iter() == 1
assert minimizer.n_skipped_bfgs_updates_total() == 0
assert minimizer.n_bfgs_updates_total() == 22
assert minimizer.subspace_argmin_is_within_box() == 1
assert minimizer.n_free_variables() == 25
assert minimizer.n_active_constraints() == 0
assert minimizer.n_variables_leaving_active_set() == 0
assert minimizer.n_variables_entering_active_set() == 0
assert eps_eq(minimizer.theta_bfgs_matrix_current(), 23.2674689856)
assert minimizer.f_previous_iteration() >= 0
assert minimizer.floating_point_epsilon() \
== scitbx.math.floating_point_epsilon_double_get()
assert eps_eq(minimizer.factr_times_floating_point_epsilon(),
minimizer.factr() * minimizer.floating_point_epsilon())
assert eps_eq(minimizer.two_norm_line_search_direction_vector(),
1.56259327735e-05)
assert eps_eq(minimizer.two_norm_line_search_direction_vector_sq(),
minimizer.two_norm_line_search_direction_vector()**2)
assert minimizer.accumulated_time_cauchy_search() > -0.02
assert minimizer.accumulated_time_subspace_minimization() > -0.02
assert minimizer.accumulated_time_line_search() > -0.02
assert eps_eq(minimizer.slope_line_search_function_current(),
9.31496613169e-10)
assert eps_eq(minimizer.slope_line_search_function_start(),
-3.6762390377e-09)
assert eps_eq(minimizer.maximum_relative_step_length(), 1.37484166517)
assert eps_eq(minimizer.relative_step_length_line_search(), 1.0)
assert eps_eq(minimizer.infinity_norm_projected_gradient(),
0.000143369780806)
