基于 Levenberg - Marquardt 法的 BP 网络学习改进算法详解

最新推荐文章于 2025-02-26 11:48:18 发布

fanxbl957

最新推荐文章于 2025-02-26 11:48:18 发布

阅读量1.2k

点赞数 18

分类专栏：人工智能理论与实践文章标签：算法深度学习神经网络

本文链接：https://blog.csdn.net/ashyyyy/article/details/143872839

版权

人工智能理论与实践专栏收录该内容

650 篇文章

订阅专栏

基于 Levenberg - Marquardt 法的 BP 网络学习改进算法详解

一、引言

BP（Back Propagation）神经网络在众多领域有着广泛应用，但传统 BP 算法存在收敛速度慢、易陷入局部最优等问题。Levenberg - Marquardt（LM）算法作为一种有效的优化算法，被应用于改进 BP 网络学习，能够显著提高训练效率和网络性能。本文将深入阐述基于 Levenberg - Marquardt 法的 BP 网络学习改进算法，包括其原理、实现步骤和详细的代码示例。

二、传统 BP 网络学习算法回顾

（一）网络结构与前向传播

BP 神经网络一般由输入层、隐藏层和输出层构成。设输入层有 $n$ 个神经元，输入向量为 $\mathbf{x}=(x_1,x_2,\cdots,x_n)$ ；隐藏层有 $m$ 个神经元，输出向量为 $\mathbf{h}=(h_1,h_2,\cdots,h_m)$ ；输出层有 $p$ 个神经元，输出向量为 $\mathbf{y}=(y_1,y_2,\cdots,y_p)$ 。

在前向传播过程中，对于输入层到隐藏层，隐藏层神经元的输入为：

$net_{j}=\sum_{i = 1}^{n}w_{ij}^{1}x_{i}+b_{j}^{1}$

其中， $w_{ij}^{1}$ 是输入层到隐藏层的连接权重， $b_{j}^{1}$ 是隐藏层的偏置。隐藏层神经元的输出通常经过激活函数（如 Sigmoid 函数 $h_{j}=\frac{1}{1 + e^{-net_{j}}}$ ）处理。

从隐藏层到输出层，输出层神经元的输入为：

$u_{k}=\sum_{j = 1}^{m}w_{jk}^{2}h_{j}+b_{k}^{2}$

输出层神经元的输出 $y_{k}=\frac{1}{1 + e^{-u_{k}}}$ （这里以 Sigmoid 函数为例）。

（二）误差计算与反向传播

对于训练样本集 $\{(\mathbf{x}^{(\mu)},\mathbf{t}^{(\mu)})\}_{\mu = 1}^{N}$ ，其中 $\mathbf{x}^{(\mu)}$ 是第 $\mu$ 个输入样本， $\mathbf{t}^{(\mu)}$ 是对应的目标输出。常用的误差函数是均方误差：

$E=\frac{1}{2}\sum_{\mu = 1}^{N}\sum_{k = 1}^{p}(y_{k}^{(\mu)}-t_{k}^{(\mu)})^{2}$

在反向传播过程中，根据误差函数对权重的梯度来更新权重。以输出层到隐藏层的权重 $w_{jk}^{2}$ 为例，其梯度计算为：

$\frac{\partial E}{\partial w_{jk}^{2}}=\sum_{\mu = 1}^{N}(y_{k}^{(\mu)}-t_{k}^{(\mu)})y_{k}^{(\mu)}(1 - y_{k}^{(\mu)})h_{j}^{(\mu)}$

然后根据梯度下降法更新权重：

$w_{jk}^{2}(t + 1)=w_{jk}^{2}(t)-\eta\frac{\partial E}{\partial w_{jk}^{2}}$

其中， $\eta$ 是学习率， $t$ 表示训练次数。类似地，可以计算输入层到隐藏层的权重更新公式。

三、传统 BP 算法的问题分析

（一）收敛速度问题

学习率的影响
在传统 BP 算法中，学习率的选择至关重要且困难。若学习率过大，权重更新可能会过度，导致网络在误差曲面上跳过最小值点，甚至使训练过程发散；若学习率过小，权重更新缓慢，需要大量的训练迭代才能使误差降低到可接受的水平，尤其在处理复杂的高维数据或复杂函数逼近问题时，收敛速度会非常慢。
梯度下降的局限性
传统 BP 基于梯度下降方法，每次权重更新仅沿着当前梯度的负方向进行。在复杂的误差曲面中，如存在狭长的峡谷或平坦区域，梯度方向可能并不直接指向全局最小值，这会导致在这些区域收敛效率低下。

（二）局部最优问题

由于传统 BP 算法沿着梯度下降方向更新权重，容易陷入局部最优解。在误差曲面中，当达到局部最优点时，梯度为零或接近零，此时权重更新停止，但这个局部最优点可能并非全局最优解，使得网络的性能无法进一步提升。

四、Levenberg - Marquardt 法原理

（一）基本思想

Levenberg - Marquardt 法是一种结合了梯度下降法和牛顿法优点的优化算法。它在接近最优解时具有牛顿法的二次收敛速度，在远离最优解时表现得像梯度下降法一样稳定。

对于目标函数 $E(\mathbf{w})$ （这里 $\mathbf{w}$ 表示网络的所有权重和偏置组成的向量），牛顿法的迭代公式为：

$\mathbf{w}^{t + 1}=\mathbf{w}^{t}-[\nabla^{2}E(\mathbf{w}^{t})]^{-1}\nabla E(\mathbf{w}^{t})$

其中， $\nabla E(\mathbf{w}^{t})$ 是目标函数在 $\mathbf{w}^{t}$ 处的梯度向量， $\nabla^{2}E(\mathbf{w}^{t})$ 是目标函数在 $\mathbf{w}^{t}$ 处的 Hessian 矩阵。然而，计算 Hessian 矩阵及其逆矩阵在实际中计算量很大。

Levenberg - Marquardt 法使用一个近似的 Hessian 矩阵。它将目标函数 $E(\mathbf{w})$ 在当前点 $\mathbf{w}^{t}$ 处进行二阶泰勒展开：

$E(\mathbf{w})\approx E(\mathbf{w}^{t})+\nabla E(\mathbf{w}^{t})^{T}(\mathbf{w}-\mathbf{w}^{t})+\frac{1}{2}(\mathbf{w}-\mathbf{w}^{t})^{T}\mathbf{H}(\mathbf{w}-\mathbf{w}^{t})$

其中， $\mathbf{H}$ 是对 Hessian 矩阵的近似。在 LM 算法中，这个近似的 Hessian 矩阵为：

$\mathbf{H}=\mathbf{J}^{T}\mathbf{J}+\lambda\mathbf{I}$

其中， $\mathbf{J}$ 是雅可比矩阵，它的元素是误差函数对权重的一阶偏导数， $\lambda$ 是一个可调参数， $\mathbf{I}$ 是单位矩阵。当 $\lambda$ 很大时，算法接近梯度下降法；当 $\lambda$ 很小时，算法接近牛顿法。

（二）参数更新公式

权重更新公式为：

$\mathbf{w}^{t + 1}=\mathbf{w}^{t}-(\mathbf{J}^{T}\mathbf{J}+\lambda\mathbf{I})^{-1}\mathbf{J}^{T}\mathbf{e}$

其中， $\mathbf{e}$ 是误差向量。通过调整 $\lambda$ 的值，可以控制算法的收敛速度和稳定性。在每次迭代中，如果误差减小，则减小 $\lambda$ ；如果误差增大，则增大 $\lambda$ 。

五、基于 Levenberg - Marquardt 法的 BP 网络学习改进算法步骤

（一）初始化

网络参数初始化
初始化 BP 网络的权重和偏置，可将权重随机初始化为较小的值，例如在区间 $[- 0.5, 0.5]$ 内。同时，初始化参数 $\lambda$ （通常初始化为一个较小的值，如 0.01）、雅可比矩阵 $\mathbf{J}$ （初始化为相应大小的零矩阵）和其他相关变量。
训练参数初始化
设置训练的相关参数，如最大训练次数、误差阈值等，用于控制训练过程的终止条件。

（二）训练过程

前向传播
对于每个训练样本，按照传统 BP 算法的前向传播方式计算网络的输出。
误差计算与雅可比矩阵计算
计算当前样本的误差向量 $\mathbf{e}$ ，并通过反向传播计算雅可比矩阵 $\mathbf{J}$ 。雅可比矩阵的计算涉及到误差函数对每个权重的偏导数。
近似 Hessian 矩阵构建与权重更新
根据当前的雅可比矩阵 $\mathbf{J}$ 和参数 $\lambda$ ，构建近似 Hessian 矩阵 $\mathbf{H}=\mathbf{J}^{T}\mathbf{J}+\lambda\mathbf{I}$ 。然后，求解线性方程组 $(\mathbf{J}^{T}\mathbf{J}+\lambda\mathbf{I})\Delta\mathbf{w}=\mathbf{J}^{T}\mathbf{e}$ ，得到权重更新量 $\Delta\mathbf{w}$ ，并更新网络的权重和偏置： $\mathbf{w}^{t + 1}=\mathbf{w}^{t}-\Delta\mathbf{w}$ 。
参数调整
计算更新权重后的误差。如果误差减小，则减小 $\lambda$ （例如， $\lambda=\lambda/10$ ）；如果误差增大，则增大 $\lambda$ （例如， $\lambda = 10\lambda$ ）。
停止准则判断
检查是否满足停止准则，如达到最大训练次数或者当前误差小于设定的误差阈值。如果满足，则停止训练；否则，返回步骤 1 继续下一次迭代。

六、代码示例

以下是使用 Python 实现的基于 Levenberg - Marquardt 法的 BP 网络学习改进算法的代码示例：

import numpy as np

# Sigmoid 激活函数
def sigmoid(x):
    return 1 / (1 + np.exp(-x))

# Sigmoid 函数的导数
def sigmoid_derivative(x):
    return x * (1 - x)

class NeuralNetwork:
    def __init__(self, input_size, hidden_size, output_size):
        self.input_size = input_size
        self.hidden_size = hidden_size
        self.output_size = output_size
        # 随机初始化权重
        self.W1 = np.random.rand(self.input_size, self.hidden_size)
        self.b1 = np.zeros((1, self.hidden_size))
        self.W2 = np.random.rand(self.hidden_size, self.output_size)
        self.b2 = np.zeros((1, self.output_size))
        self.lambda_value = 0.01  # 初始lambda值

    def forward_propagation(self, X):
        self.z1 = np.dot(X, self.W1) + self.b1
        self.a1 = sigmoid(self.z1)
        self.z2 = np.dot(self.a1, self.W2) + self.b2
        self.a2 = sigmoid(self.z2)
        return self.a2

    def back_propagation(self, X, y):
        m = X.shape[0]
        dZ2 = (self.a2 - y) * sigmoid_derivative(self.z2)
        dW2 = np.dot(self.a1.T, dZ2)
        db2 = np.sum(dZ2, axis=0, keepdims=True)
        dZ1 = np.dot(dZ2, self.W2.T) * sigmoid_derivative(self.z1)
        dW1 = np.dot(X.T, dZ1)
        db1 = np.sum(dZ1, axis=0, keepdims=True)
        return dW1, db1, dW2, db2

    def jacobian_matrix(self, X, y):
        m = X.shape[0]
        J = np.zeros((m * self.output_size, (self.input_size * self.hidden_size) + self.hidden_size + (self.hidden_size * self.output_size) + self.output_size))
        for i in range(m):
            sample_X = X[i].reshape(1, -1)
            sample_y = y[i].reshape(1, -1)
            dW1, db1, dW2, db2 = self.back_propagation(sample_X, sample_y)
            start_idx_W1 = 0
            end_idx_W1 = self.input_size * self.hidden_size
            start_idx_b1 = end_idx_W1
            end_idx_b1 = end_idx_W1 + self.hidden_size
            start_idx_W2 = end_idx_b1
            end_idx_W2 = end_idx_b1 + self.hidden_size * self.output_size
            start_idx_b2 = end_idx_W2
            end_idx_b2 = end_idx_W2 + self.output_size
            J[i * self.output_size:(i + 1) * self.output_size, start_idx_W1:end_idx_W1] = dW1.flat
            J[i * self.output_size:(i + 1) * self.output_size, start_idx_b1:end_idx_b1] = db1.flat
            J[i * self.output_size:(i + 1) * self.output_size, start_idx_W2:end_idx_W2] = dW2.flat
            J[i * self.output_size:(i + 1) * self.output_size, start_idx_b2:end_idx_b2] = db2.flat
        return J

    def levenberg_marquardt_update(self, X, y):
        output = self.forward_propagation(X)
        error = output - y
        J = self.jacobian_matrix(X, y)
        H = np.dot(J.T, J) + self.lambda_value * np.eye(J.shape[1])
        gradient = np.dot(J.T, error.flat)
        update_vector = np.linalg.solve(H, gradient)
        self.W1 -= update_vector[:self.input_size * self.hidden_size].reshape(self.input_size, self.hidden_size)
        self.b1 -= update_vector[self.input_size * self.hidden_size:self.input_size * self.hidden_size + self.hidden_size].reshape(1, self.hidden_size)
        self.W2 -= update_vector[self.input_size * self.hidden_size + self.hidden_size:self.input_size * self.hidden_size + self.hidden_size + self.hidden_size * self.output_size].reshape(self.hidden_size, self.output_size)
        self.b2 -= update_vector[self.input_size * self.hidden_size + self.hidden_size + self.hidden_size * self.output_size:].reshape(1, self.output_size)
        new_error = np.mean((self.forward_propagation(X) - y) ** 2)
        old_error = np.mean((output - y) ** 2)
        if new_error < old_error:
            self.lambda_value = self.lambda_value / 10
        else:
            self.lambda_value = self.lambda_value * 10

    def train(self, X, y, epochs):
        for epoch in range(epochs):
            self.levenberg_marquardt_update(X, y)
            if epoch % 100 == 0:
                output = self.forward_propagation(X)
                error = np.mean((output - y) ** 2)
                print(f'Epoch {epoch}: Error = {error}, Lambda = {self.lambda_value}')

以下是一个简单的测试示例：

# 示例用法
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])
neural_network = NeuralNetwork(2, 3, 1)
neural_network.train(X, y, 1000)

七、总结

基于 Levenberg - Marquardt 法的 BP 网络学习改进算法通过巧妙地近似 Hessian 矩阵，结合了梯度下降法和牛顿法的优点。这种算法在 BP 网络训练中能够更快地收敛，并且在一定程度上减少了陷入局部最优解的可能性。代码示例详细展示了该算法在 Python 中的实现过程，在实际应用中，可以根据具体的问题和数据集进一步优化算法，如更精细地调整 $\lambda$ 的调整策略、改进雅可比矩阵的计算方法等，以提高网络的训练效果和泛化能力。该算法在函数逼近、数据分类等需要高效训练神经网络的场景中具有重要的应用价值。