def bfgs_method(x0):
gfk = gradient(x0)
I = np.eye(len(x0), dtype=int)
Hk = I
xk = x0
xs = []
alphas = []
steps = 0
while (f(xk) > 0.1e-18):
xs.append(xk)
steps += 1
pk = -np.dot(Hk, gfk)
alpha_k = backtrack_line_search(x0)
alphas.append(alpha_k)
xk1 = xk + alpha_k * pk
sk = xk1 - xk
xk = xk1
gfk1 = gradient(xk)
yk = gfk1 - gfk
gfk = gfk1
term = 1.0 / (np.dot(yk, sk))
term1 = I - term * sk[:, np.newaxis] * yk[np.newaxis, :]
term2 = I - term * yk[:, np.newaxis] * sk[np.newaxis, :]
Hk = np.dot(term1, np.dot(
Hk, term2)) + (term * sk[:, np.newaxis] * sk[np.newaxis, :])
return xs, alphas, steps
def backtrack_line_search(x0):
alpha = 1
while (f(x0) - (f(x0 - alpha * gradient(x0)) +
alpha * C * np.dot(gradient(x0), gradient(x0)))) < 0:
alpha *= Ru
return alpha
def newton(x):
alpha = backtrack_line_search(x)
step = 0
alphas = []
xk_s = []
while (f(x) > 0.1e-18):
print(f(x))
xk_s.append(x)
alphas.append(alpha)
x = (x - np.multiply(alpha, inv(hessiyan(x)).dot(gradient(x))))
alpha = backtrack_line_search(x)
step += 1
if (f(x) == 0):
break
return xk_s, alphas, step
def trust_region_dogleg(xk):
trust_radius = 1.0
iteration = 0
xk_s = []
Ru_s = []
while True:
xk_s.append(xk)
gk = gradient(xk)
Bk = hessiyan(xk)
Hk = np.linalg.inv(Bk)
pk = dogleg_method(Hk, gk, Bk, trust_radius)
xk, trust_radius, Ru = trust_region_find_delta(xk, pk, gk, Bk,
trust_radius)
Ru_s.append(Ru)
if f(xk) < 0.1e-18:
break
iteration = iteration + 1
showResult(xk_s, Ru_s, iteration)
return xk
def trust_region_cauchy(xk):
trust_radius = 1.0
iteration = 0
xk_s = []
Ru_s = []
while True:
xk_s.append(xk)
gk = gradient(xk)
Bk = hessiyan(xk)
pk = find_cauchy_point(gk, Bk, trust_radius)
print(f(xk))
xk, trust_radius, Ru = trust_region_find_delta(xk, pk, gk, Bk,
trust_radius)
Ru_s.append(Ru)
if f(xk) < 0.0012310:
break
iteration = iteration + 1
showResult(xk_s, Ru_s, iteration)
return xk
def inexact_newton(w, i):
'''
execute the inexact newton method using the conjugate gradient
returns the number of steps necessary to achieve the requiered precision
'''
k = 0
while(func.f(w) >= epsilon):
# This is the heart of the inexact newton
# We follow the formula wk+1 = wk - alphak * gradient(wk) / hessian(wk)
# But we use the conjugate gradient method that gives use " - gradient(wk) / hessian(wk) "
w = w + alpha * cg.conjugate_gradient(w, func.hessian(w), -func.gradient(w), i)
k = k+1
return k
def steepestDescent(x):
alpha = backtrack_line_search(x)
xk_s = []
alphas = []
step = 0
while (f(x) > 0.1e-18):
step += 1
xk_s.append(x)
alphas.append(alpha)
x = (x - np.multiply(alpha, gradient(x)))
alpha = backtrack_line_search(x)
return xk_s, alphas, step