def __init__(self,
uaniso,
x_initial,
adp_nma,
# weights,
n_modes,
zero_mode_flag,
max_iterations):
adopt_init_args(self, locals())
# assert self.uaniso.size() == self.weights.size()
self.x = self.x_initial
self.x_min = self.x_initial
self.n = self.x.size()
t1 = time.time()
self.minimizer = lbfgs.run(
target_evaluator = self,
termination_params = lbfgs.termination_parameters(
max_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params =
lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = False,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = False)
)
self.compute_functional_and_gradients()
t2 = time.time()
print t2 - t1
def __init__(self,
fmodels,
constrained_groups_selections,
selections,
par_initial,
max_number_of_iterations):
adopt_init_args(self, locals())
self.fmodels.create_target_functors()
self.fmodels.prepare_target_functors_for_minimization()
from phenix.refinement import weight_xray_chem
self.weights = weight_xray_chem.weights(wx = 1,
wx_scale = 1,
angle_x = None,
wn = 1,
wn_scale = 1,
angle_n = None,
w = 0,
wxn = 1) # XXX
self.par_min = self.par_initial.deep_copy()
self.x = self.pack(self.par_min)
self.n = self.x.size()
self.minimizer = lbfgs.run(
target_evaluator = self,
termination_params = lbfgs.termination_parameters(
max_iterations = max_number_of_iterations),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True))
self.compute_functional_and_gradients()
del self.x
def __init__(self,
uiso,
T_initial,
L_initial,
S_initial,
refine_T,
refine_L,
refine_S,
origin,
sites,
max_iterations):
adopt_init_args(self, locals())
assert uiso.size() == sites.size()
self.dim_T = len(self.T_initial)
self.dim_L = len(self.L_initial)
self.dim_S = len(self.S_initial)
assert self.dim_T == 1 and self.dim_S == 3 and self.dim_L == 6
self.T_min = self.T_initial
self.L_min = self.L_initial
self.S_min = self.S_initial
self.x = self.pack(self.T_min, self.L_min, self.S_min)
self.n = self.x.size()
self.minimizer = lbfgs.run(
target_evaluator = self,
termination_params = lbfgs.termination_parameters(
max_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params =
lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True)
)
self.compute_functional_and_gradients()
del self.x
def __init__(self, d_i, psi_i, eta_rad, Deff):
import sys
self.safelog = -1. + math.log(sys.float_info.max)
self.S = StringIO.StringIO()
pickle.dump([d_i, psi_i, eta_rad, Deff],self.S,0)
assert len(d_i) == len(psi_i)
self.d_i = d_i
self.psi_i = psi_i
self.Nobs = len(d_i)
self.escalate = 10. # 10 is a soft switch; 50-100 a hard switch
self.x = flex.double([log(2./Deff), log(eta_rad)]) # parameters alpha, eta
self.minimizer = run(
target_evaluator=self,
core_params=core_parameters(
gtol=0.1
# increasing the accuracy of the line search technique (default=0.9)
# as suggested by source code. Otherwise Deff is set unreasonably high
# and the exponential blows up.
),
termination_params = termination_parameters(
traditional_convergence_test=False,
drop_convergence_test_max_drop_eps=1.e-5,
min_iterations=0,
max_iterations = 100,
max_calls=200),
exception_handling_params=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)
)
self.x=flex.exp(self.x)
def __init__(
self,
fmodel,
sc_start,
selections,
par_initial,
refine_adp,
refine_occ,
max_number_of_iterations,
run_finite_differences_test = False,
restraints_weight = None,
restraints_manager = None):
adopt_init_args(self, locals())
self.target_functor = fmodel.target_functor()
self.target_functor.prepare_for_minimization()
self.counter=0
assert len(self.selections) == len(self.par_initial)
self.par_min = copy.deepcopy(self.par_initial)
self.x = self.pack(self.par_min)
self.n = self.x.size()
self.weight = restraints_weight
if(self.restraints_manager is not None and self.weight is None):
gx = self.target_functor(
compute_gradients=True).gradients_wrt_atomic_parameters(
u_iso = refine_adp,
occupancy = refine_occ)
rtg = self.restraints_manager.target_and_gradients(
xray_structure = self.fmodel.xray_structure,
to_compute_weight = True)
gx_norm = gx.norm()
if(gx_norm != 0):
self.weight = rtg.gradients.norm()/gx_norm
else: self.weight = 1.0
if(self.weight is not None):
assert self.restraints_manager is not None
if(run_finite_differences_test):
self.buffer_ana = flex.double()
self.buffer_fin = flex.double()
self.minimizer = lbfgs.run(
target_evaluator = self,
termination_params = lbfgs.termination_parameters(
max_iterations = max_number_of_iterations),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True))
self.compute_functional_and_gradients()
del self.x
self.tested = 0
if(run_finite_differences_test):
for a,f in zip(self.buffer_ana, self.buffer_fin):
print a, f
diff = flex.abs(self.buffer_ana - self.buffer_fin)
s = diff < 1.e-3
if(s.size()>0 and s.count(True)*100./s.size()>50):
self.tested += 1
def __init__(self,
fmodel,
tlsos_initial,
refine_T,
refine_L,
refine_S,
selections,
selections_1d,
max_iterations,
run_finite_differences_test = False,
correct_adp = True):
adopt_init_args(self, locals())
fmodel.xray_structure.scatterers().flags_set_grads(state=False)
xray.set_scatterer_grad_flags(scatterers = fmodel.xray_structure.scatterers(),
u_aniso = True)
if(self.run_finite_differences_test): self.correct_adp = False
self.fmodel_copy = self.fmodel.deep_copy()
self.target_functor = self.fmodel_copy.target_functor()
self.run_finite_differences_test_counter = 0
self.T_initial = []
self.L_initial = []
self.S_initial = []
self.origins = []
for tlso_ in tlsos_initial:
self.T_initial.append(tlso_.t)
self.L_initial.append(tlso_.l)
self.S_initial.append(tlso_.s)
self.origins.append(tlso_.origin)
self.counter = 0
self.n_groups = len(self.T_initial)
self.dim_T = len(self.T_initial[0])
self.dim_L = len(self.L_initial[0])
self.dim_S = len(self.S_initial[0])
self.T_min = self.T_initial
self.L_min = self.L_initial
self.S_min = self.S_initial
self.x = self.pack(self.T_min, self.L_min, self.S_min)
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(maxfev = 10),
termination_params = lbfgs.termination_parameters(
min_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True))
self.compute_functional_and_gradients()
del self.x
self.tlsos_result = generate_tlsos(
selections = self.selections,
xray_structure = self.fmodel.xray_structure,
T = self.T_min,
L = self.L_min,
S = self.S_min)
def __init__(self, MI, Fr, n_frames, eps):
self.counter=0
self.MI = MI
self.Fr = Fr
self.n_frames=n_frames
self.x = flex.double(self.n_frames,1)
termination_params = lbfgs.termination_parameters(
traditional_convergence_test=True,
traditional_convergence_test_eps=eps)
self.minimizer = lbfgs.run(target_evaluator=self, termination_params=termination_params)
print "End of minimization: Converged"
def __init__(self, *args, **kwargs):
Refinery.__init__(self, *args, **kwargs)
self._termination_params = lbfgs.termination_parameters(max_iterations=self._max_iterations)
import cStringIO
self._log_string = cStringIO.StringIO
return
def __init__(self, orient, constraint='triclinic',
min_iterations=25, max_calls=1000):
self.constraint=constraint
adopt_init_args(self, locals())
self.n = 9
self.x = flex.double(orient.direct_matrix())
self.minimizer = lbfgs.run(
target_evaluator=self,
termination_params=lbfgs.termination_parameters(
traditional_convergence_test=00000,
min_iterations=min_iterations,
max_calls=max_calls))
del self.g
def __init__(self, I, weight, hkl, frames, G, Ih, eps):
self.counter=0
self.I = flex.double(I)
self.weight = flex.double(weight)
self.frames = flex.size_t(frames)
self.hkl = flex.size_t(hkl)
self.Ih = flex.double(Ih)
self.x = flex.double(G)
termination_params = lbfgs.termination_parameters(
traditional_convergence_test=True,
traditional_convergence_test_eps=eps)
self.minimizer = lbfgs.run(target_evaluator=self, termination_params=termination_params)
print "End of minimization: Converged after", self.counter, "steps"
def __init__(self,
fmodel,
model,
xs_initial,
adp_nmas,
selections,
selections_1d,
max_iterations,
n_modes,
weight_nmre = 1.0,
run_finite_differences_test = False,
correct_adp = True,
zero_mode_flag = True):
adopt_init_args(self, locals())
fmodel.xray_structure.scatterers().flags_set_grads(state=False)
xray.set_scatterer_grad_flags(scatterers = fmodel.xray_structure.scatterers(),
u_aniso = True)
if(self.run_finite_differences_test): self.correct_adp = False
self.fmodel_copy = self.fmodel.deep_copy()
self.target_functor = self.fmodel_copy.target_functor()
self.run_finite_differences_test_counter = 0
self.counter = 0
self.n_groups = len(self.xs_initial)
self.dim_x = len(self.xs_initial[0])
self.xs_min = self.xs_initial
self.x = self.pack(self.xs_min)
# for adp_nma_selected, selection in zip(adp_nmas, selections):
# weights_selected = self.fmodel.xray_structure.atomic_weights.select(selection)
# modes1d_selected = selected_modes_to_1D(modes = self.modes, n_modes = self.n_modes,
# selection = self.selection)
# assert len(modes1d_selected)/n_modes == len(weights_selected)
# adp_nma_selected = init_nm_adp(modes = modes1d_selected,
# weights = weights_selected,
# n_modes = n_modes,
# zero_mode_flag = zero_mode_flag)
# self.adp_nmas.append(adp_nma_selected)
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(),
termination_params = lbfgs.termination_parameters(
min_iterations = max_iterations,
max_calls = int(max_iterations*1.5)),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = False,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = False))
self.compute_functional_and_gradients()
del self.x
self.xs_result = self.xs_min
def __init__(self,
fmodel,
selections,
r_initial,
t_initial,
refine_r,
refine_t,
max_iterations,
euler_angle_convention,
lbfgs_maxfev):
adopt_init_args(self, locals())
self.fmodel_copy = self.fmodel.deep_copy()
self.target_functor = self.fmodel_copy.target_functor()
self.target_functor.prepare_for_minimization()
self.atomic_weights = self.fmodel.xray_structure.atomic_weights()
self.sites_cart = self.fmodel.xray_structure.sites_cart()
self.sites_frac = self.fmodel.xray_structure.sites_frac()
self.n_groups = len(self.selections)
assert self.n_groups > 0
self.counter=0
assert len(self.r_initial) == len(self.t_initial)
assert len(self.selections) == len(self.t_initial)
self.dim_r = 3
self.dim_t = 3
self.r_min = copy.deepcopy(self.r_initial)
self.t_min = copy.deepcopy(self.t_initial)
for i in xrange(len(self.r_min)):
self.r_min[i] = tuple(self.r_min[i])
self.t_min[i] = tuple(self.t_min[i])
self.x = self.pack(self.r_min, self.t_min)
self.n = self.x.size()
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(
maxfev = lbfgs_maxfev),
termination_params = lbfgs.termination_parameters(
max_iterations = max_iterations),
exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True)
)
self.compute_functional_and_gradients(suppress_gradients=True)
del self.x
def __init__(self,
fmodel_core_data,
f_obs,
u_initial=[0,0,0,0,0,0],
refine_u=True,
min_iterations=500,
max_iterations=500,
symmetry_constraints_on_b_cart = True,
u_min_max = 500.,
u_min_min =-500.):
adopt_init_args(self, locals())
self.u_min = self.u_initial
self.u_factor = self.fmodel_core_data.uc.volume()**(2/3.)
if(self.symmetry_constraints_on_b_cart):
self.adp_constraints = self.f_obs.space_group().adp_constraints()
u_star = self.f_obs.space_group().average_u_star(u_star = self.u_initial)
self.dim_u = self.adp_constraints.n_independent_params()
assert self.dim_u <= 6
independent_params = self.adp_constraints.independent_params(u_star)
self.x = self.pack(
u=independent_params,
u_factor=self.u_factor)
else:
self.dim_u = len(self.u_initial)
assert self.dim_u == 6
self.x = self.pack(
u=flex.double(self.u_min),
u_factor=self.u_factor)
lbfgs_exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True)
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(),
termination_params = lbfgs.termination_parameters(
min_iterations = min_iterations,
max_iterations = max_iterations),
exception_handling_params = lbfgs_exception_handling_params)
self.compute_functional_and_gradients()
del self.x
def __init__(self,
fmodel,
groups,
call_back_after_minimizer_cycle=None,
number_of_minimizer_cycles=3,
lbfgs_max_iterations=20,
number_of_finite_difference_tests=0):
adopt_init_args(self, locals())
self.x = flex.double()
for group in groups:
if (group.refine_f_prime): self.x.append(group.f_prime)
if (group.refine_f_double_prime): self.x.append(group.f_double_prime)
fmodel.xray_structure.scatterers().flags_set_grads(state=False)
for group in groups:
if (group.refine_f_prime):
fmodel.xray_structure.scatterers().flags_set_grad_fp(
iselection=group.iselection)
if (group.refine_f_double_prime):
fmodel.xray_structure.scatterers().flags_set_grad_fdp(
iselection=group.iselection)
self.target_functor = fmodel.target_functor()
self.target_functor.prepare_for_minimization()
for self.i_cycle in xrange(number_of_minimizer_cycles):
self.lbfgs = lbfgs.run(
target_evaluator=self,
termination_params=lbfgs.termination_parameters(
max_iterations=lbfgs_max_iterations),
exception_handling_params=lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True))
if (call_back_after_minimizer_cycle is not None):
self.unpack()
if (not call_back_after_minimizer_cycle(minimizer=self)):
break
if (call_back_after_minimizer_cycle is None):
self.unpack()
del self.i_cycle
del self.lbfgs
del self.x
del self.target_functor
del self.fmodel
del self.groups
def __init__(self, current_x=None, args=None,
min_iterations=0, max_iterations=None, max_calls=1000, max_drop_eps=1.e-5):
self.n = current_x.size()
self.x = current_x
self.args = args
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=max_iterations,
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,
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)
)
def __init__(self, current_x=None, args=None,
min_iterations=0, max_iterations=None, max_calls=1000, max_drop_eps=1.e-5):
self.n = current_x.size()
self.x = current_x
self.args = args
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=max_iterations,
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,
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)
)
def __init__(self, current_x=None, parameterization=None, refinery=None, out=None,
min_iterations=0, max_calls=1000, max_drop_eps=1.e-5):
adopt_init_args(self, locals())
self.n = current_x.size()
self.x = current_x
from scitbx import lbfgs
self.minimizer = lbfgs.run(
target_evaluator=self,
termination_params=lbfgs.termination_parameters(
traditional_convergence_test=True,
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)
)
def __init__(self, current_x=None, parameterization=None, refinery=None, out=None,
min_iterations=0, max_calls=1000, max_drop_eps=1.e-5):
adopt_init_args(self, locals())
self.n = current_x.size()
self.x = current_x
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)
)
def __init__(self, uiso, T_initial, L_initial, S_initial, refine_T,
refine_L, refine_S, origin, sites, max_iterations):
adopt_init_args(self, locals())
assert uiso.size() == sites.size()
self.dim_T = len(self.T_initial)
self.dim_L = len(self.L_initial)
self.dim_S = len(self.S_initial)
assert self.dim_T == 1 and self.dim_S == 3 and self.dim_L == 6
self.T_min = self.T_initial
self.L_min = self.L_initial
self.S_min = self.S_initial
self.x = self.pack(self.T_min, self.L_min, self.S_min)
self.n = self.x.size()
self.minimizer = lbfgs.run(
target_evaluator=self,
termination_params=lbfgs.termination_parameters(
max_iterations=max_iterations,
max_calls=int(max_iterations * 1.5)),
exception_handling_params=lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound=True,
ignore_line_search_failed_step_at_upper_bound=True,
ignore_line_search_failed_maxfev=True))
self.compute_functional_and_gradients()
del self.x
def __init__(self, d_i, psi_i, eta_rad, Deff):
import sys
self.safelog = -1. + math.log(sys.float_info.max)
self.S = StringIO.StringIO()
pickle.dump([d_i, psi_i, eta_rad, Deff], self.S, 0)
assert len(d_i) == len(psi_i)
self.d_i = d_i
self.psi_i = psi_i
self.Nobs = len(d_i)
self.escalate = 10. # 10 is a soft switch; 50-100 a hard switch
self.x = flex.double([log(2. / Deff),
log(eta_rad)]) # parameters alpha, eta
self.minimizer = run(
target_evaluator=self,
core_params=core_parameters(
gtol=0.1
# increasing the accuracy of the line search technique (default=0.9)
# as suggested by source code. Otherwise Deff is set unreasonably high
# and the exponential blows up.
),
termination_params=termination_parameters(
traditional_convergence_test=False,
drop_convergence_test_max_drop_eps=1.e-5,
min_iterations=0,
max_iterations=100,
max_calls=200),
exception_handling_params=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))
self.x = flex.exp(self.x)
def refine(self):
'''Actually perform the parameter refinement.'''
tp = lbfgs.termination_parameters(max_iterations=1000)
r = lbfgs.run(target_evaluator=self, termination_params=tp)
return r
def __init__(self,
fmodel_core_data,
f_obs,
k_initial,
b_initial,
u_initial,
refine_k,
refine_b,
refine_u,
min_iterations,
max_iterations,
fmodel_core_data_twin = None,
twin_fraction = None,
symmetry_constraints_on_b_cart = True,
u_min_max = 500.,
u_min_min =-500.,
k_sol_max = 10.,
k_sol_min =-10.,
b_sol_max = 500.,
b_sol_min =-500.):
adopt_init_args(self, locals())
if(twin_fraction == 0):
twin_fraction = None
self.twin_fraction = None
fmodel_core_data_twin=None
self.fmodel_core_data_twin=None
assert [fmodel_core_data_twin,twin_fraction].count(None) in [0,2]
self.n_shells = self.fmodel_core_data.data.n_shells()
if not self.fmodel_core_data_twin is None:
assert self.fmodel_core_data_twin.data.n_shells() == self.n_shells
assert self.n_shells > 0 and self.n_shells <= 10
self.k_min = self.k_initial
assert len(self.k_min) == self.n_shells
self.b_min = self.b_initial
self.u_min = self.u_initial
self.u_factor = self.fmodel_core_data.uc.volume()**(2/3.)
if(self.symmetry_constraints_on_b_cart):
self.adp_constraints = self.f_obs.space_group().adp_constraints()
u_star = self.f_obs.space_group().average_u_star(u_star = self.u_initial)
self.dim_u = self.adp_constraints.n_independent_params()
assert self.dim_u <= 6
independent_params = self.adp_constraints.independent_params(u_star)
self.x = self.pack(
u=independent_params,
k=self.k_min,
b=self.b_min,
u_factor=self.u_factor)
else:
self.dim_u = len(self.u_initial)
assert self.dim_u == 6
self.x = self.pack(
u=flex.double(self.u_min),
k=self.k_min,
b=self.b_min,
u_factor=self.u_factor)
lbfgs_exception_handling_params = lbfgs.exception_handling_parameters(
ignore_line_search_failed_step_at_lower_bound = True,
ignore_line_search_failed_step_at_upper_bound = True,
ignore_line_search_failed_maxfev = True)
self.minimizer = lbfgs.run(
target_evaluator = self,
core_params = lbfgs.core_parameters(),
termination_params = lbfgs.termination_parameters(
min_iterations = min_iterations,
max_iterations = max_iterations),
exception_handling_params = lbfgs_exception_handling_params)
self.compute_functional_and_gradients()
del self.x
def __init__(self,height_list=None,xyz_list=None,shape="parabola",
max_iterations=25):
self.height_list = height_list
self.xyz_list = xyz_list
# pick shape
if (shape == "parabola"):
self.n = parabola().n
self.fit = parabola
self.check_lengths(height_list=height_list,xyz_list=xyz_list)
# construct vector and matrix for initial guess
b_elements = []
A_elements = []
for i in xrange(self.n):
b_elements.append(height_list[i])
A_elements.append(xyz_list[i][0]*xyz_list[i][0])
A_elements.append(xyz_list[i][1]*xyz_list[i][1])
A_elements.append(xyz_list[i][2]*xyz_list[i][2])
A_elements.append(xyz_list[i][0])
A_elements.append(xyz_list[i][1])
A_elements.append(xyz_list[i][2])
A_elements.append(1.0)
A = matrix.sqr(A_elements)
b = matrix.col(b_elements)
elif ((shape == "quadratic") or (shape == "gaussian")):
self.n = quadratic().n
if (shape == "quadratic"):
self.fit = quadratic
else:
self.fit = gaussian
self.check_lengths(height_list=height_list,xyz_list=xyz_list)
# construct vector and matrix for initial guess
b_elements = []
A_elements = []
for i in xrange(self.n):
b_elements.append(height_list[i])
A_elements.append(xyz_list[i][0]*xyz_list[i][0])
A_elements.append(xyz_list[i][1]*xyz_list[i][1])
A_elements.append(xyz_list[i][2]*xyz_list[i][2])
A_elements.append(xyz_list[i][0])
A_elements.append(xyz_list[i][1])
A_elements.append(xyz_list[i][2])
A_elements.append(xyz_list[i][0]*xyz_list[i][1])
A_elements.append(xyz_list[i][0]*xyz_list[i][2])
A_elements.append(xyz_list[i][1]*xyz_list[i][2])
A_elements.append(1.0)
A = matrix.sqr(A_elements)
b = matrix.col(b_elements)
else:
print "fit_peak error: shape not valid"
exit()
# get initial guess (solve Ax = b)
self.x = flex.double(A.inverse()*b)
# if there are more points, minimize using the LBFGS minimizer
if (len(height_list) > self.n):
self.minimizer = lbfgs.run(\
target_evaluator=self,termination_params=\
lbfgs.termination_parameters(max_iterations=max_iterations))
# finalize fit
answer = self.fit(parameters=self.x)
self.vertex = answer.vertex
x_max = xyz_list[1][0] # these min and max values are based on the order
x_min = xyz_list[2][0]
y_max = xyz_list[3][1]
y_min = xyz_list[4][1]
z_max = xyz_list[5][2]
z_min = xyz_list[6][2]
assert(x_max > x_min)
assert(y_max > y_min)
assert(z_max > z_min)
if ((self.vertex[0] < x_min) or (self.vertex[0] > x_max)):
self.vertex[0] = xyz_list[0][0]
if ((self.vertex[1] < y_min) or (self.vertex[1] > y_max)):
self.vertex[1] = xyz_list[0][1]
if ((self.vertex[2] < z_min) or (self.vertex[2] > z_max)):
self.vertex[2] = xyz_list[0][2]
def refine(self):
'''Actually perform the parameter refinement.'''
tp = lbfgs.termination_parameters(max_iterations=1000)
r = lbfgs.run(target_evaluator = self, termination_params=tp)
return r
def __init__(self,
height_list=None,
xyz_list=None,
shape="parabola",
max_iterations=25):
self.height_list = height_list
self.xyz_list = xyz_list
# pick shape
if (shape == "parabola"):
self.n = parabola().n
self.fit = parabola
self.check_lengths(height_list=height_list, xyz_list=xyz_list)
# construct vector and matrix for initial guess
b_elements = []
A_elements = []
for i in range(self.n):
b_elements.append(height_list[i])
A_elements.append(xyz_list[i][0] * xyz_list[i][0])
A_elements.append(xyz_list[i][1] * xyz_list[i][1])
A_elements.append(xyz_list[i][2] * xyz_list[i][2])
A_elements.append(xyz_list[i][0])
A_elements.append(xyz_list[i][1])
A_elements.append(xyz_list[i][2])
A_elements.append(1.0)
A = matrix.sqr(A_elements)
b = matrix.col(b_elements)
elif ((shape == "quadratic") or (shape == "gaussian")):
self.n = quadratic().n
if (shape == "quadratic"):
self.fit = quadratic
else:
self.fit = gaussian
self.check_lengths(height_list=height_list, xyz_list=xyz_list)
# construct vector and matrix for initial guess
b_elements = []
A_elements = []
for i in range(self.n):
b_elements.append(height_list[i])
A_elements.append(xyz_list[i][0] * xyz_list[i][0])
A_elements.append(xyz_list[i][1] * xyz_list[i][1])
A_elements.append(xyz_list[i][2] * xyz_list[i][2])
A_elements.append(xyz_list[i][0])
A_elements.append(xyz_list[i][1])
A_elements.append(xyz_list[i][2])
A_elements.append(xyz_list[i][0] * xyz_list[i][1])
A_elements.append(xyz_list[i][0] * xyz_list[i][2])
A_elements.append(xyz_list[i][1] * xyz_list[i][2])
A_elements.append(1.0)
A = matrix.sqr(A_elements)
b = matrix.col(b_elements)
else:
print("fit_peak error: shape not valid")
exit()
# get initial guess (solve Ax = b)
self.x = flex.double(A.inverse() * b)
# if there are more points, minimize using the LBFGS minimizer
if (len(height_list) > self.n):
self.minimizer = lbfgs.run(\
target_evaluator=self,termination_params=\
lbfgs.termination_parameters(max_iterations=max_iterations))
# finalize fit
answer = self.fit(parameters=self.x)
self.vertex = answer.vertex
x_max = xyz_list[1][
0] # these min and max values are based on the order
x_min = xyz_list[2][0]
y_max = xyz_list[3][1]
y_min = xyz_list[4][1]
z_max = xyz_list[5][2]
z_min = xyz_list[6][2]
assert (x_max > x_min)
assert (y_max > y_min)
assert (z_max > z_min)
if ((self.vertex[0] < x_min) or (self.vertex[0] > x_max)):
self.vertex[0] = xyz_list[0][0]
if ((self.vertex[1] < y_min) or (self.vertex[1] > y_max)):
self.vertex[1] = xyz_list[0][1]
if ((self.vertex[2] < z_min) or (self.vertex[2] > z_max)):
self.vertex[2] = xyz_list[0][2]
def mpi_split_evaluator_run(target_evaluator,
termination_params=None,
core_params=None,
exception_handling_params=None,
log=None,
#---> Insertion starts
gradient_only=False,
line_search=True):
#<--- Insertion ends
"""The supported scenario is that each MPI worker rank has a target evaluator
that has part of the data. Each rank calculates a bit of the functional and
gradients, but then mpi reduce is used to sum them all up. There has been
no low-level redesign to support MPI. In particular, the ext.minimizer is
run (wastefully) by every worker rank, using the same data. It is assumed that
the calculation of compute_functional_and_gradients() is overwhelmingly the rate
limiting step, and that is what MPI parallelism is intended to distribute here."""
from libtbx.mpi4py import MPI
comm = MPI.COMM_WORLD
rank = comm.Get_rank()
size = comm.Get_size()
if (termination_params is None):
termination_params = termination_parameters()
if (core_params is None):
core_params = core_parameters()
if (exception_handling_params is None):
exception_handling_params = exception_handling_parameters()
x = target_evaluator.x
if (log is not None):
print >> log, "lbfgs minimizer():"
print >> log, " x.size():", x.size()
print >> log, " m:", core_params.m
print >> log, " maxfev:", core_params.maxfev
print >> log, " gtol:", core_params.gtol
print >> log, " xtol:", core_params.xtol
print >> log, " stpmin:", core_params.stpmin
print >> log, " stpmax:", core_params.stpmax
print >> log, "lbfgs traditional_convergence_test:", \
termination_params.traditional_convergence_test
minimizer = ext.minimizer(
x.size(),
core_params.m,
core_params.maxfev,
core_params.gtol,
core_params.xtol,
core_params.stpmin,
core_params.stpmax)
if (termination_params.traditional_convergence_test):
is_converged = ext.traditional_convergence_test(
x.size(),
termination_params.traditional_convergence_test_eps)
else:
is_converged = ext.drop_convergence_test(
n_test_points=termination_params.drop_convergence_test_n_test_points,
max_drop_eps=termination_params.drop_convergence_test_max_drop_eps,
iteration_coefficient
=termination_params.drop_convergence_test_iteration_coefficient)
callback_after_step = getattr(target_evaluator, "callback_after_step", None)
diag_mode = getattr(target_evaluator, "diag_mode", None)
if (diag_mode is not None): assert diag_mode in ["once", "always"]
f_min, x_min = None, None
f, g = None, None
try:
while 1:
if (diag_mode is None):
#XXX Only the diag_mode==None case is currently implemented, just as example
f_term, g_term = target_evaluator.compute_functional_and_gradients()
f_total = comm.reduce(f_term, MPI.SUM, 0)
g_total = comm.reduce(g_term, MPI.SUM, 0)
if rank==0: transmit = (f_total,g_total)
else: transmit = None
f, g = comm.bcast(transmit, root=0)
if False and rank==0: # for debug
print ("%s %10.4f"%("MPI stp",f),"["," ".join(["%10.4f"%a for a in x]),"]")
d = None
else:
f, g, d = target_evaluator.compute_functional_gradients_diag()
if (diag_mode == "once"):
diag_mode = None
if (f_min is None):
if (not termination_params.traditional_convergence_test):
is_converged(f)
f_min, x_min = f, x.deep_copy()
elif (f_min > f):
f_min, x_min = f, x.deep_copy()
if (log is not None):
print >> log, "lbfgs minimizer.run():" \
" f=%.6g, |g|=%.6g, x_min=%.6g, x_mean=%.6g, x_max=%.6g" % (
f, g.norm(), flex.min(x), flex.mean(x), flex.max(x))
if (d is None):
#---> Insertion starts
if (minimizer.run(x, f, g, gradient_only,line_search)): continue
#<--- Insertion ends
else:
#---> Insertion starts
if (minimizer.run(x, f, g, d, gradient_only,line_search)): continue
#<--- Insertion ends
if (log is not None):
print >> log, "lbfgs minimizer step"
if (callback_after_step is not None):
if (callback_after_step(minimizer) is True):
if (log is not None):
print >> log, "lbfgs minimizer stop: callback_after_step is True"
break
if (termination_params.traditional_convergence_test):
if ( minimizer.iter() >= termination_params.min_iterations
and is_converged(x, g)):
if (log is not None):
print >> log, "lbfgs minimizer stop: traditional_convergence_test"
break
else:
if (is_converged(f)):
if (log is not None):
print >> log, "lbfgs minimizer stop: drop_convergence_test"
break
if ( termination_params.max_iterations is not None
and minimizer.iter() >= termination_params.max_iterations):
if (log is not None):
print >> log, "lbfgs minimizer stop: max_iterations"
break
if ( termination_params.max_calls is not None
and minimizer.nfun() > termination_params.max_calls):
if (log is not None):
print >> log, "lbfgs minimizer stop: max_calls"
break
if (d is None):
#---> Insertion starts
if (not minimizer.run(x, f, g, gradient_only,line_search)): break
#<--- Insertion ends
else:
#---> Insertion starts
if (not minimizer.run(x, f, g, d, gradient_only,line_search)): break
#<--- Insertion ends
except RuntimeError as e:
minimizer.error = str(e)
if (log is not None):
print >> log, "lbfgs minimizer exception:", str(e)
if (x_min is not None):
x.clear()
x.extend(x_min)
error_classification = exception_handling_params.filter(
minimizer.error, x.size(), x, g)
if (error_classification > 0):
raise
elif (error_classification < 0):
minimizer.is_unusual_error = True
else:
minimizer.is_unusual_error = False
else:
minimizer.error = None
minimizer.is_unusual_error = None
if (log is not None):
print >> log, "lbfgs minimizer done."
return minimizer
