def __call__(self, vec_x0, conf=None, fun_smooth=None, fun_smooth_grad=None,
fun_a=None, fun_a_grad=None, fun_b=None, fun_b_grad=None,
lin_solver=None, status=None):
conf = get_default(conf, self.conf)
fun_smooth = get_default(fun_smooth, self.fun_smooth)
fun_smooth_grad = get_default(fun_smooth_grad, self.fun_smooth_grad)
fun_a = get_default(fun_a, self.fun_a)
fun_a_grad = get_default(fun_a_grad, self.fun_a_grad)
fun_b = get_default(fun_b, self.fun_b)
fun_b_grad = get_default(fun_b_grad, self.fun_b_grad)
lin_solver = get_default(lin_solver, self.lin_solver)
status = get_default(status, self.status)
time_stats = {}
vec_x = vec_x0.copy()
vec_x_last = vec_x0.copy()
vec_dx = None
if self.log is not None:
self.log.plot_vlines(color='r', linewidth=1.0)
err0 = -1.0
err_last = -1.0
it = 0
step_mode = 'regular'
r_last = None
reuse_matrix = False
while 1:
ls = 1.0
vec_dx0 = vec_dx;
i_ls = 0
while 1:
tt = time.clock()
try:
vec_smooth_r = fun_smooth(vec_x)
vec_a_r = fun_a(vec_x)
vec_b_r = fun_b(vec_x)
except ValueError:
vec_smooth_r = vec_semismooth_r = None
if (it == 0) or (ls < conf.ls_min):
output('giving up!')
raise
else:
ok = False
else:
if conf.semismooth:
# Semi-smooth equation.
vec_semismooth_r = (nm.sqrt(vec_a_r**2.0 + vec_b_r**2.0)
- (vec_a_r + vec_b_r))
else:
# Non-smooth equation (brute force).
vec_semismooth_r = nm.where(vec_a_r < vec_b_r,
vec_a_r, vec_b_r)
r_last = (vec_smooth_r, vec_a_r, vec_b_r, vec_semismooth_r)
ok = True
time_stats['rezidual'] = time.clock() - tt
if ok:
vec_r = nm.r_[vec_smooth_r, vec_semismooth_r]
try:
err = nla.norm(vec_r)
except:
output('infs or nans in the residual:',
vec_semismooth_r)
output(nm.isfinite(vec_semismooth_r).all())
debug()
if self.log is not None:
self.log(err, it)
if it == 0:
err0 = err;
break
if err < (err_last * conf.ls_on):
step_mode = 'regular'
break
else:
output('%s step line search' % step_mode)
red = conf.ls_red[step_mode];
output('iter %d, (%.5e < %.5e) (new ls: %e)'\
% (it, err, err_last * conf.ls_on, red * ls))
else: # Failed to compute rezidual.
red = conf.ls_red_warp;
output('rezidual computation failed for iter %d'
' (new ls: %e)!' % (it, red * ls))
if ls < conf.ls_min:
if step_mode == 'regular':
output('restore previous state')
vec_x = vec_x_last.copy()
(vec_smooth_r, vec_a_r, vec_b_r,
vec_semismooth_r) = r_last
err = err_last
reuse_matrix = True
step_mode = 'steepest_descent'
else:
output('linesearch failed, continuing anyway')
break
ls *= red;
vec_dx = ls * vec_dx0;
vec_x = vec_x_last.copy() - vec_dx
i_ls += 1
# End residual loop.
output('%s step' % step_mode)
if self.log is not None:
self.log.plot_vlines([1],
color=self._colors[step_mode],
linewidth=0.5)
err_last = err;
vec_x_last = vec_x.copy()
condition = conv_test(conf, it, err, err0)
if condition >= 0:
break
tt = time.clock()
if not reuse_matrix:
mtx_jac = self.compute_jacobian(vec_x, fun_smooth_grad,
fun_a_grad, fun_b_grad,
vec_smooth_r,
vec_a_r, vec_b_r)
else:
reuse_matrix = False
time_stats['matrix'] = time.clock() - tt
tt = time.clock()
if step_mode == 'regular':
vec_dx = lin_solver(vec_r, mtx=mtx_jac)
vec_e = mtx_jac * vec_dx - vec_r
lerr = nla.norm(vec_e)
if lerr > (conf.eps_a * conf.lin_red):
output('linear system not solved! (err = %e)' % lerr)
output('switching to steepest descent step')
step_mode = 'steepest_descent'
vec_dx = mtx_jac.T * vec_r
else:
vec_dx = mtx_jac.T * vec_r
time_stats['solve'] = time.clock() - tt
for kv in six.iteritems(time_stats):
output('%10s: %7.2f [s]' % kv)
vec_x -= vec_dx
it += 1
if status is not None:
status['time_stats'] = time_stats
status['err0'] = err0
status['err'] = err
status['condition'] = condition
if conf.log.plot is not None:
if self.log is not None:
self.log(save_figure=conf.log.plot)
return vec_x
def __call__(self, vec_x0, conf=None, fun_smooth=None, fun_smooth_grad=None,
fun_a=None, fun_a_grad=None, fun_b=None, fun_b_grad=None,
lin_solver=None, status=None):
conf = get_default(conf, self.conf)
fun_smooth = get_default(fun_smooth, self.fun_smooth)
fun_smooth_grad = get_default(fun_smooth_grad, self.fun_smooth_grad)
fun_a = get_default(fun_a, self.fun_a)
fun_a_grad = get_default(fun_a_grad, self.fun_a_grad)
fun_b = get_default(fun_b, self.fun_b)
fun_b_grad = get_default(fun_b_grad, self.fun_b_grad)
lin_solver = get_default(lin_solver, self.lin_solver)
status = get_default(status, self.status)
time_stats = {}
vec_x = vec_x0.copy()
vec_x_last = vec_x0.copy()
vec_dx = None
if self.log is not None:
self.log.plot_vlines(color='r', linewidth=1.0)
err0 = -1.0
err_last = -1.0
it = 0
step_mode = 'regular'
r_last = None
reuse_matrix = False
while 1:
ls = 1.0
vec_dx0 = vec_dx;
i_ls = 0
while 1:
tt = time.clock()
try:
vec_smooth_r = fun_smooth(vec_x)
vec_a_r = fun_a(vec_x)
vec_b_r = fun_b(vec_x)
except ValueError:
vec_smooth_r = vec_semismooth_r = None
if (it == 0) or (ls < conf.ls_min):
output('giving up!')
raise
else:
ok = False
else:
if conf.semismooth:
# Semi-smooth equation.
vec_semismooth_r = (nm.sqrt(vec_a_r**2.0 + vec_b_r**2.0)
- (vec_a_r + vec_b_r))
else:
# Non-smooth equation (brute force).
vec_semismooth_r = nm.where(vec_a_r < vec_b_r,
vec_a_r, vec_b_r)
r_last = (vec_smooth_r, vec_a_r, vec_b_r, vec_semismooth_r)
ok = True
time_stats['residual'] = time.clock() - tt
if ok:
vec_r = nm.r_[vec_smooth_r, vec_semismooth_r]
try:
err = nla.norm(vec_r)
except:
output('infs or nans in the residual:',
vec_semismooth_r)
output(nm.isfinite(vec_semismooth_r).all())
debug()
if self.log is not None:
self.log(err, it)
if it == 0:
err0 = err;
break
if err < (err_last * conf.ls_on):
step_mode = 'regular'
break
else:
output('%s step line search' % step_mode)
red = conf.ls_red[step_mode];
output('iter %d, (%.5e < %.5e) (new ls: %e)'\
% (it, err, err_last * conf.ls_on, red * ls))
else: # Failed to compute residual.
red = conf.ls_red_warp;
output('residual computation failed for iter %d'
' (new ls: %e)!' % (it, red * ls))
if ls < conf.ls_min:
if step_mode == 'regular':
output('restore previous state')
vec_x = vec_x_last.copy()
(vec_smooth_r, vec_a_r, vec_b_r,
vec_semismooth_r) = r_last
err = err_last
reuse_matrix = True
step_mode = 'steepest_descent'
else:
output('linesearch failed, continuing anyway')
break
ls *= red;
vec_dx = ls * vec_dx0;
vec_x = vec_x_last.copy() - vec_dx
i_ls += 1
# End residual loop.
output('%s step' % step_mode)
if self.log is not None:
self.log.plot_vlines([1],
color=self._colors[step_mode],
linewidth=0.5)
err_last = err;
vec_x_last = vec_x.copy()
condition = conv_test(conf, it, err, err0)
if condition >= 0:
break
tt = time.clock()
if not reuse_matrix:
mtx_jac = self.compute_jacobian(vec_x, fun_smooth_grad,
fun_a_grad, fun_b_grad,
vec_smooth_r,
vec_a_r, vec_b_r)
else:
reuse_matrix = False
time_stats['matrix'] = time.clock() - tt
tt = time.clock()
if step_mode == 'regular':
vec_dx = lin_solver(vec_r, mtx=mtx_jac)
vec_e = mtx_jac * vec_dx - vec_r
lerr = nla.norm(vec_e)
if lerr > (conf.eps_a * conf.lin_red):
output('linear system not solved! (err = %e)' % lerr)
output('switching to steepest descent step')
step_mode = 'steepest_descent'
vec_dx = mtx_jac.T * vec_r
else:
vec_dx = mtx_jac.T * vec_r
time_stats['solve'] = time.clock() - tt
for kv in six.iteritems(time_stats):
output('%10s: %7.2f [s]' % kv)
vec_x -= vec_dx
it += 1
if status is not None:
status['time_stats'] = time_stats
status['err0'] = err0
status['err'] = err
status['condition'] = condition
if conf.log.plot is not None:
if self.log is not None:
self.log(save_figure=conf.log.plot)
return vec_x