不精确线搜索方法

　　精确线搜索花费的计算量一般较大。一般问题中，特别是初始迭代点具体目标点较远时，不精确线搜索的效率往往要高于精确线搜索。并且牛顿法和拟牛顿法的收敛速度不依赖于步长的搜索，因此可以对α进行不精确线搜索。

 

　　不精确线搜索包括Goldstein准则、Wofle准则和Armijo准则。

 

1. GoldStein准则

　　

　　其中0<ρ<1/2，第一个不等式是充分下降条件，第二个不等式表示α_k不会太小.

　　也可以写成

　　

 

 2. Wolfe准则

　　Goldstein准则的第二个不等式可能造成把极小点排除在可接受区间外，为了解决这个问题，提出了下面的代替条件

　　σ∈(ρ,1)

　　即

　　

　　这个条件叫做曲率条件

　　充分下降条件与曲率条件一起构成了Wolfe准则

　　

　　其中　

　　但曲率条件的不足之处是即使σ→0时也不能精确线搜索，因此有了强Wolfe准则

　　

3. Armijo准则

　　给定β∈(0,1)，ρ∈(0,1/2)，τ>0，m_k是使不等式

　　

　　成立的最小非负整数，令

　　

　　上面的不等式实际上就是充分下降条件，这个方法可以令α从1开始缩小（增大m），直到满足充分下降条件

 

下面给出这几种算法的python实现

Goldstein准则：

from linear_search.Function import *
from numpy import *


def goldstein(f, val, d):
    a = 0
    b = 10000
    alpha = 1

    def _fi(_alpha):
        return f(val + _alpha * array(d))

    fi = Function(_fi)
    fi0 = fi.value(0)
    dfi0 = fi.diff(0)
    while True:
        fi_alpha = fi.value(alpha)
        if fi_alpha > fi0 + 1 / 3 * alpha * dfi0:
            b = alpha
            alpha = (a + b) / 2
        elif fi_alpha < fi0 + 2 / 3 * alpha * dfi0:
            a = alpha
            if b == 10000:
                alpha = 2 * alpha
            else:
                alpha = (a + b) / 2.
        else:
            return alpha

Wolfe准则：

from linear_search.Function import *
from numpy import *


def wolfe(_f, val, d):
    a = 0.0
    b = 10000.0

    def _fi(_alpha):
        return _f(val + _alpha * array(d))

    fi = Function(_fi)
    f = Function(_f)

    fi1 = f.value(val)
    g=f.grad(val)
    print(f.part(0,[1,2]))
    print(f.part(1,[1,2]))
    dfi1 = dot(g,array(d).T)
    dfi0 = fi.diff(0)
    alpha = 1.0

    while True:
        fi_=fi.value(alpha)
        if fi_-fi1>1/3*alpha*dfi1:
            alpha_=a+(alpha-a)/2/(1+(fi1-fi_)/(alpha-a)/dfi1)
            b=alpha
            alpha=alpha_
        else:
            dfi_alpha=fi.diff(alpha)
            if dfi_alpha<1/2*dfi1:
                alpha_=alpha+(alpha-a)*dfi_alpha/(dfi1-dfi_alpha)
                a=alpha
                fi1=fi_
                dfi1=dfi_alpha
                alpha=alpha_
            else:
                return alpha

 Armijo准则：

from linear_search.Function import *
from numpy import *


def armijo(_f, val, d):
    alpha=1

    def _fi(_alpha):
        return _f(val + _alpha * array(d))

    fi = Function(_fi)
    f = Function(_f)
    fi_=fi.value(alpha)
    f_=f.value(val)
    while True:
        if fi_>f_+1/3*alpha*dot(f.grad(val),array(d).T):
            alpha=0.7*alpha
        else:
            return alpha