牛顿法,阻尼牛顿法

最新推荐文章于 2025-03-16 08:17:42 发布

大鹏的NLP博客

最新推荐文章于 2025-03-16 08:17:42 发布

阅读量2.1w

点赞数 6

分类专栏：数值计算 Java 文章标签：牛顿法阻尼牛顿法

本文链接：https://blog.csdn.net/philosophyatmath/article/details/70153705

版权

Java 同时被 2 个专栏收录

30 篇文章

订阅专栏

数值计算

6 篇文章

订阅专栏

本文深入解析牛顿法原理及其在优化问题中的应用，包括基本牛顿法与阻尼牛顿法，并提供具体实例代码。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

泰勒公式

本质就是多项式逼近推广到无穷级数逼近，在实际应用中对于具有复杂形式的函数，我们常常希望用较为简单的函数形式表示它，那多项式就是这种简单的形式。

用吴文俊的话说就是：把质的困难转化成量的复杂。

展开前求解函数的值很困难，展开后是幂函数的线性组合，虽然有很多很多项，但是每一项都是幂函数，因此每一项都容易求解。于是只要对展开后的求和，就能得到展开前的函数的值

本质就是对于一个无穷阶连续可导的函数，它的各阶导数值就给出了这个函数的所有信息，你可以就把这个函数想象为无穷阶的多项式函数，系数定了这个函数也就定了。

泰勒公式可以说是用函数在某一点的导数逐次逼近函数的过程。

概述

牛顿法的基本思想是利用迭代点处的一阶导数(梯度)和二阶导数(Hessen矩阵)对目标函数进行二次函数近似，然后把二次模型的极小点作为新的迭代点，并不断重复这一过程，直至求得满足精度的近似极小值。牛顿法的速度相当快，而且能高度逼近最优值。牛顿法分为基本的牛顿法和全局牛顿法。

基本牛顿法

基本牛顿法是一种用导数求解的算法，它每一步的迭代方向都是沿着当前点函数值下降最快的方向。主要是为了解决非线性优化问题，其收敛速度比梯度下降速度更快。其需要解决的问题可以描述为：对于目标函数f(x)，在无约束条件的情况下求它的最小值。

min x \in R n f (x)

$\min \limits_{x \in R^n} f\left(x\right)$

当 $n=1$ 时

对于一个需要求解的优化函数 $f(x)$ ,求函数的极值的问题，可以转化为求导函数 $f'(x)=0$
，对函数 $f(x)$ 进行泰勒展开到二阶：

f (x) = f (x k) + f' (x k) (x - x k) + 1 2 f'' (x k) (x - x k) 2 + R n (x) \approx f (x k) + f' (x k) (x - x k) + 1 2 f'' (x k) (x - x k) 2

$f(x)=f(x_k)+f'(x_k)(x-x_k)+\frac{1}{2}f''(x_k)(x-x_k)^2+R_n(x)\approx f(x_k)+f'(x_k)(x-x_k)+\frac{1}{2}f''(x_k)(x-x_k)^2$
对上式求导并令其为0，

f' (x) = 0 + f' (x k) (1 - 0) + 1 2 f'' (x k) 2 (x - x k) = f' (x k) + f'' (x k) (x - x k) = 0

$f'(x)=0+f'(x_k)(1-0)+\frac{1}{2}f''(x_k)2(x-x_k)=f'(x_k)+f''(x_k)(x-x_k)=0$

即

x = x k - f ' ( x k ) f '' ( x k )

$x=x_k-\frac{f'(x_k)}{f''(x_k)}$

这个就是牛顿法的更新公式。若从初始值 $x=x_0$ 开始进行迭代，将得到 $x$ 的一个序列： $x_0,x_1,…x_k$ 。在一定条件下，此序列可以收敛到 $f(x)$ 的极小值点。

当 $n\gt 1$ 时

此时，可以将 $x$ 写成 $x=(x_1,x_2,\dots,x_n)$ 。对函数 $f(x)$ 进行泰勒展开到二阶：

f (x) = f (x k) + f' (x k) (x - x k) + 1 2 f'' (x k) (x - x k) 2 + R n (x) \approx f (x k) + f' (x k) (x - x k) + 1 2 f'' (x k) (x - x k) 2

$f(x)=f(x_k)+f'(x_k)(x-x_k)+\frac{1}{2}f''(x_k)(x-x_k)^2+R_n(x)\approx f(x_k)+f'(x_k)(x-x_k)+\frac{1}{2}f''(x_k)(x-x_k)^2$
对上式求导并令其为0，由于

f(x) $f(x)$ 中的

x $x$ 是一个向量，

f(x) $f(x)$ 对

x $x$ 求导意味着对

x $x$ 向量中的每个值求偏导。即，

f(x) $f(x)$ 对

x $x$ 的一阶导数为一个向量，对

x $x$ 的二阶导数为一个

n∗n $n*n$ 的矩阵

f' (x) = (\partial f ( x ) \partial x 1 ， \partial f ( x ) \partial x 2, \dots, \partial f ( x ) \partial x n) f'' (x) = [\partial 2 f ( x ) \partial x i \partial x j] n * n

$f'(x)=\left( \frac{\partial f(x)}{\partial x_1}， \frac{\partial f(x)}{\partial x_2},\dots, \frac{\partial f(x)}{\partial x_n}\right)\\ f''(x)=\left[\frac{\partial^2f(x)}{\partial x_i\partial x_j}\right]_{n*n}\\$
求导后得:

f' (x) = f' (x k) + f'' (x k) (x - x k)

$f'(x)=f'(x_k)+f''(x_k)(x-x_k)$
令：

g k = f' (x k), H k = f'' (x k)

$g_k=f'(x_k),H_k=f''(x_k)$
此时的

gk $g_k$ 为一个向量，

Hk $H_k$ 为一个矩阵。
令上式

f′(x)=0 $f'(x)=0$ ,即

f′(x)=f′(xk)+f′′(xk)(x−xk)=0 $f'(x)=f'(x_k)+f''(x_k)(x-x_k)=0$
即

x k + 1 = x k - g k H k

$x_{k+1}=x_k-\frac{g_k}{H_k}$

算法

1.给定终止误差值 $0\le\epsilon\ll1$ ,初始化 $x_0\in R^n$ ，设 $k=0$ .
2.计算 $g_k=\nabla f(x_k)$ ，若 $\left\| g_k\right\|\le\epsilon$ ,则停止，输出 $x^* \approx x_k$
3.计算 $h_k=\nabla^2f(x_k)$ ,求关于 $g_k$ 与 $h_k$ 的比， $h_kr=-g_k,r=-g_kh_k^{-1}$
4.令 $x_{k+1}=x_k+r_k,k=k+1$ ,并转向2

优缺点

它比传统的梯度下降算法收敛速度明显要快。

阻尼牛顿法

牛顿法最突出的优点是收敛速度快，具有局部二阶收敛性，但是，基本牛顿法初始点需要足够“靠近”极小点，否则，有可能导致算法不收敛。这样就引入了阻尼牛顿法，阻尼牛顿法最核心的一点在于可以修改每次迭代的步长，通过沿着牛顿法确定的方向一维搜索最优的步长，最终选择使得函数值最小的步长。

算法

1.给定终止误差值 $0\le\epsilon\ll1，\delta \in (0,1)，\sigma \in (0,0.5)$ ,初始化 $x_0\in R^n$ ，设 $k=0$ .
2.计算 $g_k=\nabla f(x_k)$ ，若 $\left\| g_k\right\|\le\epsilon$ ,则停止，输出 $x^* \approx x_k$
3.计算 $G_k=\nabla^2f(x_k)$ ,求关于 $g_k$ 与 $G_k$ 的比， $G_kr=-g_k$
4.设 $m_k$ 是不满足下列不等式的最小非负整数 $m$ ：

f (x k + δ m r k) \leq f (x k) + σ δ m g T k r k

$f(x_k+\delta^mr_k)\le f(x_k)+\sigma \delta^m g_k^Tr_k$
4.令

αk=δmk,xk+1=xk+αkrk,k=k+1 $\alpha_k=\delta^{m_k}, x_{k+1}=x_k+\alpha_kr_k,k=k+1$ ,并转向2

Armijo搜索

阻尼牛顿法是基于Armijo的搜索，满足Armijo准则：
给定: $\delta \in (0,1)，\sigma \in (0,0.5)$ ,令步长因子 $\alpha_k=\delta^{m_k}$

f (x k + δ m r k) \leq f (x k) + σ δ m g T k r k

$f(x_k+\delta^mr_k)\le f(x_k)+\sigma \delta^m g_k^Tr_k$

代码示例：

函数： $f(x)=x^2-3x+1$ ,最小值为 $f(\frac{3}{2})=-\frac{1}{4}=-0.25$

package newtonmethod;

/**
 * Newton法
 * 
 * @author zhangdapeng
 * 
 */
public class NewtonMethod {
    private double x0;// 初始点
    private double e;// 误差阈值
    private double maxCycle;// 最大循环次数

    /**
     * 构造方法
     * 
     * @param x0初始值
     * @param e误差阈值
     * @param maxCycle最大循环次数
     */
    public NewtonMethod(double x0, double e, double maxCycle) {
        this.x0 = x0;
        this.e = e;
        this.maxCycle = maxCycle;
    }

    /**
     * 原始函数
     * 
     * @param x变量
     * @return 原始函数的值
     */
    public double getOriginal(double x) {
        return x * x - 3 * x + 2;
    }

    /**
     * 一次导函数
     * 
     * @param x变量
     * @return 一次导函数的值
     */
    public double get1Derivative(double x) {
        return 2 * x - 3;
    }

    /**
     * 二次导函数
     * 
     * @param x变量
     * @return 二次导函数的值
     */
    public double get2Derivative(double x) {
        return 2;
    }

    /**
     * 利用牛顿法求解
     * 
     * @return
     */
    public double getNewtonMin() {
        double x = this.x0;
        double y = 0;
        double k = 1;
        while (k <= maxCycle) {
            y = this.getOriginal(x);
            double d1 = this.get1Derivative(x);
            if (Math.abs(d1) <= e) {
                break;
            }
            double d2 = this.get2Derivative(x);
            x = x - d1 / d2; // 更新x的值
            k++;
        }
        return y;
    }
    public static void main(String args[]) {
        NewtonMethod newton = new NewtonMethod(0, 0.00001, 100);
        System.out.println("基本牛顿法求解：" + newton.getNewtonMin());
    }
}

package newtonmethod;

/**
 * 阻尼牛顿法
 * 
 * @author zhangdapeng
 * 
 */
public class DampedNewtonMethod {
    private double x0;
    private double delta;
    private double sigma;
    private double e;
    private double maxCycle;

    public DampedNewtonMethod(double x0, double delta, double sigma, double e, double maxCycle) {
        this.x0 = x0;
        this.delta = delta;
        this.sigma = sigma;
        this.e = e;
        this.maxCycle = maxCycle;
    }

    /**
     * 原始函数
     * 
     * @param x变量
     * @return 原始函数的值
     */
    public double getOriginal(double x) {
        return x * x - 3 * x + 2;
    }

    /**
     * 一次导函数
     * 
     * @param x变量
     * @return 一次导函数的值
     */
    public double get1Derivative(double x) {
        return 2 * x - 3;
    }

    /**
     * 二次导函数
     * 
     * @param x变量
     * @return 二次导函数的值
     */
    public double get2Derivative(double x) {
        return 2;
    }

    /**
     * 利用牛顿法求解
     * 
     * @return
     */
    public double getDampedNewtonMin() {
        double x = this.x0;
        double y = 0;
        double k = 1;
        // 更新公式
        while (k <= maxCycle) {
            y = this.getOriginal(x);
            double d1 = this.get1Derivative(x);
            if (Math.abs(d1) <= e) {
                break;
            }
            double d2 = this.get2Derivative(x);
            double dr = -d1 / d2;// 搜索的方向
            double m = 0;
            double mk = 0;
            while (m < 20) {
                double left = this.getOriginal(x + Math.pow(this.delta, m) * dr);
                double right = this.getOriginal(x) + this.sigma * Math.pow(this.delta, m) * this.get1Derivative(x) * dr;
                if (left <= right) {
                    mk = m;
                    break;
                }
                m++;
            }
            x = x + Math.pow(this.delta, mk) * dr;
            k++;
        }
        return y;
    }

    public static void main(String args[]) {

        DampedNewtonMethod gNewton = new DampedNewtonMethod(0, 0.55, 0.4, 0.00001, 100);
        System.out.println("全局牛顿法求解：" + gNewton.getDampedNewtonMin());
    }
}