深度学习-BP算法

BP网络 (Back Propagation Neural Network, BP Neural Network) 是一种经典的人工神经网络结构，广泛应用于机器学习和深度学习领域。它基于多层感知器（MLP）模型，并通过反向传播算法来优化网络的权重和偏置。

BP网络的主要组成部分：

1. 输入层（Input Layer）：接收外部输入的数据，每个节点通常代表一个特征。
2. 隐藏层（Hidden Layer）：位于输入层和输出层之间，负责特征的抽象和转换。隐藏层可以有多层，形成深度神经网络。
3. 输出层（Output Layer）：输出最终的预测结果，节点的数量通常与任务（如分类或回归）有关。

反向传播算法（Backpropagation Algorithm）：

BP网络通过反向传播算法进行训练，目标是最小化损失函数。反向传播的步骤包括：

1. 前向传播（Forward Propagation）：从输入层到输出层，计算每一层的输出。
2. 计算误差（Error Calculation）：通过损失函数计算输出值和真实值之间的误差。
3. 反向传播（Backpropagation）：从输出层到输入层，利用梯度下降法调整权重和偏置，逐步减少误差。
4. 更新权重：根据学习率更新各层的权重，直到误差足够小或达到设定的训练次数。

BP网络的特点：

• 非线性映射：BP网络可以逼近任意的非线性函数，适合解决复杂的分类和回归问题。
• 梯度消失问题：当网络层数过深时，梯度可能会在反向传播过程中逐渐变小，导致网络难以收敛。
• 局部最优：由于梯度下降可能会陷入局部最优，导致网络无法找到全局最优解。

BP网络常用于模式识别、函数拟合和时间序列预测等领域。

下面具体给出BP算法的实现过程

import numpy as np

_w = [0.1, 0.15, 0.2, 0.25, 0.3, 0.35, 0.4, 0.45, 0.5, 0.55, 0.6, 0.65]
_b = [0.35, 0.65]

_x = [5.0, 10.0]
_y = [0.01, 0.99]
_lr = 0.5

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def w(index):
    return _w[index-1]

def set_w(index, gd):
    _w[index-1] = _w[index-1] - _lr * gd

def x(index):
    return _x[index-1]

def b(index):
    return _b[index-1]

def y(index):
    return _y[index-1]

def training():
    # 前向过程计算损失
    h1 = sigmoid(w(1) * x(1) + w(2) * x(2) + b(1))
    h2 = sigmoid(w(3) * x(1) + w(4) * x(2) + b(1))
    h3 = sigmoid(w(5) * x(1) + w(6) * x(2) + b(1))
    o1 = sigmoid(w(7) * h1 + w(9) * h2 + w(11) * h3 + b(2))
    o2 = sigmoid(w(8) * h1 + w(10) * h2 + w(12) * h3 + b(2))
    loss = 0.5 * (y(1) - o1) ** 2 + 0.5 * (y(2) - o2) ** 2

    # 反向过程参数更新
    # 基于求导的链式法则进行loss对w1的梯度求解
    # 梯度的简化写法：loss/w1 = loss/h2 * h1/w1 = (loss/o1*o1/h1 + loss/o2*o2/h1)*h1/w1
    # loss/w2 = loss/h1 * h1/w1 = (loss/o1*o1/h1+loss/o2*o2/h1)*h1/w2
    # loss/w3 = loss/h2 * h2/w1 = (loss/o1*o1/h2 + loss/o2*o2/h2) * h2/w3
    t1 = (o1 - y(1)) * o1 * (1 - o1) # loss对net_O1导数
    t2 = (o2 - y(2)) * o2 * (1 - o2) # loss对net_O2导数
    set_w(1, (t1 * w(7) + t2 * w(8)) * h1 * (1 - h1) * x(1))
    set_w(2, (t1 * w(7) + t2 * w(8)) * h1 * (1 - h1) * x(2))
    set_w(3, (t1 * w(9) + t2 * w(10)) * h2 * (1 - h2) * x(1))
    set_w(4, (t1 * w(9) + t2 * w(10)) * h2 * (1 - h2) * x(2))
    set_w(5, (t1 * w(11) + t2 * w(12)) * h3 * (1 - h3) * x(1))
    set_w(6, (t1 * w(11) + t2 * w(12)) * h3 * (1 - h3) * x(2))
    set_w(7, t1 * h1)
    set_w(8, t2 * h1)
    set_w(9, t1 * h2)
    set_w(10, t2 * h2)
    set_w(11, t1 * h3)
    set_w(12, t2 * h3)
    return loss, o1, o2


if __name__ == '__main__':
    print('demo')
    training()
    for i in range(1, 10):
        _loss = training()
    print(_loss)
    print(_w)

结果：

(0.2190668647071352, 0.6663686878646866, 0.90447880376737)
[0.05160471548484033, 0.053209430969680616, 0.18570412119230073, 0.2214082423846014, 0.2956996495090842, 0.34139929901816823, -0.0853333793179348, 0.48046880592360275, -0.08276170468097616, 0.5861326894107288, 0.0044584051418106035, 0.6869063121606734]