【深度学习基础】反向传播BP算法原理详解及实战演示(附源码)

简介: 【深度学习基础】反向传播BP算法原理详解及实战演示(附源码)

需要源码请点赞关注收藏后评论区留言私信~~~

神经网络的设计灵感来源于生物学上的神经网络。如图所示,每个节点就是一个神经元,神经元与神经元之间的连线表示信息传递的方向。Layer 1表示输入层,Layer 2、Layer 3表示隐藏层,Layer 4表示输出层。我们希望通过神经网络,对输入数据进行某种变换,从而获得期望的输出,换句话说,神经网络就是一种映射,将原数据映射成期望获得的数据。BP算法就是其中的一种映射,下面通过一个具体的例子来演示BP算法的过程

假设现在的网络层如图 所示,第一层有两个神经元x1、x2,一个截距项c1;第二层有两个神经元y1、y2,一个截距项c2;第三层是输出,有两个神经元h1、h2;每条线上表示神经元之间连接的权重(具体数值如图 1‑2所示),激活函数σ选用Sigmoid函数。Sigmoid函数及其对x的导数如下所示:

输入:x_1=0.05, x_2=0.1,目标:输出h1、h2尽可能接近[0.03, 0.05]

1:前向传播

输入层->隐藏层

隐藏层->输出层

 

至此,已经完成了前向传播的过程,此时输出为[0.694,0.718],和期望的输出[0.03, 0.05]相差较大。接下来,通过反向传播,更新每条边上的权值,重新计算输出

2:反向传播

计算总误差:均方误差作为我们的总误差函数

target_outℎ_i表示第i个真实值;out_ℎ_i表示预测值;N取值为2

因为每个权值对误差都产生了影响,我们希望了解每个权值对误差产生了多少影响,可以用整体误差对特定的权值求偏导来实现这一目的。从输出层到隐藏层,共有5个参数需要更新,分别为b11,b12,b21,b22,c2。以b22为例,通过链式法则进行计算,如下式:

其中ρ表示学习率,本例设定为0.5。同理可得:b_11^new=0.458,b_12^new=0.560,b_21^new=0.658

对于偏置项,求解方法类似,但由于偏置项对于每个神经元的损失都有贡献,所以应为对每个神经元求偏导后再求和。由于最后一项在本例中求导后值为1,一般情况下都为1,故可简化

隐藏层->输入层

方法与“输出层—>隐藏层”类似,但是有一点区别。如图 ,可以发现神经元h1向后就直接输出了,没有再输入下一个神经元,而神经元y1的输出值要输入到神经元h1、h2,导致神经元y1会接受来自h1、h2两个神经元传递的误差,因此h1、h2均要计算

从隐藏层到输入层,共有5个参数需要更新,分别为a11,a12,a21,a22,c1,以a11为例计算

式中几项偏微分均已在输出层—>隐藏层的权值更新中有相应的计算公式

同理可得,a_12^new=0.199,a_21^new=0.298,a_22^new=0.398

偏置项的求法与输出层->隐含层方法一致,这里不再赘述,但应注意的是c1的更新与y1、y2、h1、h2均有关系,带入数值可得:c_1^new=0.307

至此,所有参数均已更新完毕

利用更新完毕之后的参数可以计算得到新的输出为[0.667, 0.693] (原来的输出为[0.694, 0.718],目标输出为[0.03, 0.05]) 新的总误差为0.44356(原来的总误差为0.444)

通过新的权值计算,可以发现输出值与目标值逐渐接近,总误差逐渐减小,随着迭代次数的增加,输出值会与目标值高度相近

3:Numpy实现反向传播算法

1:导入数据集

数据集采用sklearn.make_moons()数据集(下图),并借助sklearn包进行数据预处理,数据集可视化如下

2:预处理

我们的模型基于梯度下降的优化方式算法,为了让这类算法能更好的优化神经网络,我们需要对数据集进行归一化,我们借用sklearn的库函数完成

重新搭建一个两层的神经网络,如图所示

其中X是一个p×q的矩阵。选取交叉熵损失函数作为该神经网络的损失函数。学习率为0.05,采用梯度下降法进行参数更新

对于权重矩阵W及偏置矩阵B,采用随机初始化的方法。W和B的纬度较高时,不易手工初始化。且若W和B初始化为0或者同一个值,会导致在梯度下降的更新过程中梯度保持相等,权值相同,导致不同的隐藏单元都以相同的函数或函数值作为输入,可以通过参数的随机初始化打破这种僵局。

 同时要注意参数初始化应合理,否则会出现梯度消失或梯度爆炸

在实现sigmoid时,当x很大的时候,会存在上溢问题,我们可以使用scipy.expit()实现sigmoid

至此,我们完成了基本框架的搭建,现在我们编写训练模型 我们假定 学习率为0.05

3:训练和测试

测试集预测结果如下

定义预测函数,在测试集上通过以下代码预测,并将预测结果可视化,可以发现可以较为明显的将数据集分为两类

误差绘图如下 可见在迭代次数在300次左右时基本已经趋于稳定

最后 部分代码如下

# 导入模块
import numpy as np
import matplotlib.pyplot as plt
%matplotlib inline
from matplotlib.colors import ListedColormap
from sklearn.datasets import make_moons
X, y = make_moons(n_samples=2000, noise=0.4, random_state=None)
# 将数据集可视化
plt.figure(figsize=(8, 8))
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=ListedColormap(['#B22222', '#87CEFA']), edgecolors='k')
# 60%作为训练集,40%作为测试集
from sklearn.model_selection import train_test_split
trainX, ard.fit_transform(trainX)
# 使用标准化器在训练集上的均值和标准差,对测试集进行归一化
testX = standard.transform(testX)# 定义神经网络
# 我们选用较简单的神经网络,它只有两个参数,W(权重矩阵)和 B(偏置矩阵)
def _init_(q):
    # q:W的维度(也就是有 q 个神经元)
    # 我们将 W 与 B 随机初始化
    np.ranB
def train(trainX, trainY, testX, testY, W, B, epochs, flag):
    # trainX: np.ndarray, 训练集, 维度 = (p,q)
    # trainY: np.ndarray, 训练集标签, 维度 = (p, )
    # testX: np.ndarray, 测试集, 维度 = (m,q)
    # testY: np.ndarray, 测试集标签, 维度 = (m, )
    # W:np.ndarray, 权重矩阵, 维度 = (q,)
    # B: np.ndarray, 偏置项, 维度 = (1,)
    # epochs: 迭代次数
    # flag: flag == True 打印损失值\\ flag == False不打印损失值
    train_loss_list = []
    test_loss_list = []
    for i in range(epochs):
        # 训练集
        pred_train_Y = forward(trainX, W, B)
        train_loss = loss_func(trainY, pred_train_Y)
        # 测试集
        pred_test_Y = forward(testX, W, B)
        test_loss = loss_func(testY, pred_test_Y)
        if flag == True:
            print('the traing loss of %s epoch : %s'%(i+1, train_loss))
            print('the test loss of %s epoch : %s'%(i+1, test_loss))
            print('=========================')
        train_loss_list.append(train_loss)
        test_loss_list.append(test_loss)
        #反向传播
        backword(W, B, trainY, pred_train_Y, trainX, learning_rate)
    return train_loss_list, test_loss_list
def predict(X, W, B):
    # X: np.ndarray, 训练集, 维度 = (n, m)
    # W: np.ndarray, 参数, 维度 = (m, 1)
    # B: np.ndarray, 参数b, 维度 = (1, )
    y_pred = forward(X,W,B)
    n = len(y_pred)
    prediction = np.zeros((n,1))
    for i in range(n):
        if y_pred[i] > 0.5:
            prediction[i,0] = 1
        else:
            prediction[i,0] = 0
    return prediction
def plot_loss(train_loss_list, test_loss_list):
    plt.figure(figsize = (10,8))
    plt.plot(train_loss_list, label='train_loss')
    plt.plot(test_loss_list, label='test_loss')
    plt.xlabel('epoch')
    plt.ylabel('loss')
    plt.legend()

创作不易 觉得有帮助请点赞关注收藏~~~

相关文章
|
7天前
|
机器学习/深度学习 前端开发 算法
婚恋交友系统平台 相亲交友平台系统 婚恋交友系统APP 婚恋系统源码 婚恋交友平台开发流程 婚恋交友系统架构设计 婚恋交友系统前端/后端开发 婚恋交友系统匹配推荐算法优化
婚恋交友系统平台通过线上互动帮助单身男女找到合适伴侣,提供用户注册、个人资料填写、匹配推荐、实时聊天、社区互动等功能。开发流程包括需求分析、技术选型、系统架构设计、功能实现、测试优化和上线运维。匹配推荐算法优化是核心,通过用户行为数据分析和机器学习提高匹配准确性。
34 3
|
29天前
|
机器学习/深度学习 自然语言处理 语音技术
深入探索深度学习中的兼容性函数:从原理到实践
深入探索深度学习中的兼容性函数:从原理到实践
38 3
|
29天前
|
机器学习/深度学习 自然语言处理 语音技术
揭秘深度学习中的兼容性函数:原理、类型与应用
揭秘深度学习中的兼容性函数:原理、类型与应用
|
1月前
|
搜索推荐 算法 C语言
【排序算法】八大排序(上)(c语言实现)(附源码)
本文介绍了四种常见的排序算法:冒泡排序、选择排序、插入排序和希尔排序。通过具体的代码实现和测试数据,详细解释了每种算法的工作原理和性能特点。冒泡排序通过不断交换相邻元素来排序,选择排序通过选择最小元素进行交换,插入排序通过逐步插入元素到已排序部分,而希尔排序则是插入排序的改进版,通过预排序使数据更接近有序,从而提高效率。文章最后总结了这四种算法的空间和时间复杂度,以及它们的稳定性。
103 8
|
1月前
|
搜索推荐 算法 C语言
【排序算法】八大排序(下)(c语言实现)(附源码)
本文继续学习并实现了八大排序算法中的后四种:堆排序、快速排序、归并排序和计数排序。详细介绍了每种排序算法的原理、步骤和代码实现,并通过测试数据展示了它们的性能表现。堆排序利用堆的特性进行排序,快速排序通过递归和多种划分方法实现高效排序,归并排序通过分治法将问题分解后再合并,计数排序则通过统计每个元素的出现次数实现非比较排序。最后,文章还对比了这些排序算法在处理一百万个整形数据时的运行时间,帮助读者了解不同算法的优劣。
115 7
|
28天前
|
机器学习/深度学习 人工智能 自然语言处理
探索深度学习中的注意力机制:原理、应用与未来展望
探索深度学习中的注意力机制:原理、应用与未来展望
|
28天前
|
机器学习/深度学习 自然语言处理 并行计算
探索深度学习中的Transformer模型:原理、优势与应用
探索深度学习中的Transformer模型:原理、优势与应用
|
28天前
|
机器学习/深度学习 人工智能 自然语言处理
探索深度学习中的注意力机制:原理、应用与未来趋势
探索深度学习中的注意力机制:原理、应用与未来趋势
|
29天前
|
机器学习/深度学习 人工智能 自然语言处理
深度学习中的兼容性函数:原理、类型与未来趋势
深度学习中的兼容性函数:原理、类型与未来趋势
|
1月前
|
机器学习/深度学习 人工智能 TensorFlow
基于TensorFlow的深度学习模型训练与优化实战
基于TensorFlow的深度学习模型训练与优化实战
90 0