不精確線搜索方法

　　精確線搜索花費的計算量一般較大。一般問題中，特別是初始迭代點具體目標點較遠時，不精確線搜索的效率往往要高於精確線搜索。並且牛頓法和擬牛頓法的收斂速度不依賴於步長的搜索，因此可以對α進行不精確線搜索。

 

　　不精確線搜索包括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