BP算法推导python实现

def sigmoid(inX):
return 1.0/(1+exp(-inX))

‘‘‘
标准bp算法
每次更新都只针对单个样例，参数更新得很频繁s
dataSet 训练数据集
labels 训练数据集对应的标签
标签采用one-hot编码(一位有效编码)，例如类别0对应标签为[1,0],类别1对应标签为[0,1]
alpha 学习率
num 隐层数，默认为1层
eachCount 每一层隐层的神经元数目
repeat 最大迭代次数
算法终止条件：达到最大迭代次数或者相邻一百次迭代的累计误差的差值不超过0.001
‘‘‘
def bp(dataSet, labels, alpha = 0.01, num = 1, eachCount = 10, repeat = 500):
dataSet = mat(dataSet)
m,n = shape(dataSet)
if len(labels) == 0:
print ‘no train data! ‘
return
yCount = shape(labels[0])[1] # 输出神经元的数目
firstWMat = mat(random.sample((n + 1, eachCount))) # 输入层到第一层隐层的w值和阈值，每列第一个为阈值
hideWArr = random.sample((num - 1, eachCount + 1, eachCount)) # 隐藏间的w值和阈值，每列第一个为阈值
lastWMat = mat(random.sample((eachCount + 1, yCount))) # 最后一个隐层到输出神经元的w值和阈值，每列第一个为阈值
hideInputs = mat(zeros((num, eachCount))) # 隐层的输入
hideOutputs = mat(zeros((num, eachCount + 1))) # 隐层的输出
hideOutputs[:, 0] = -1.0 # 初始化隐层输出的每列第一个值为-1，即下一层功能神经元的阈值对应的输入恒为-1
hideEh = mat(zeros((num, eachCount))) # 隐层的梯度项
yInputs = mat(zeros((1, yCount))) # 输出层的输入
i = 0 # 迭代次数
old_ey = 0 # 前一次迭代的累积误差
sn = 0 # 相邻迭代的累计误差的差值不超过0.001的次数
while i < repeat:
for r in range(len(dataSet)):
line = dataSet[r]
# 根据输入样本计算隐层的输入和输出
xMat = mat(insert(line, 0, values=-1.0, axis=1))
hideInputs[0, :] = xMat * firstWMat
hideOutputs[0, 1:] = sigmoid(hideInputs[0, :])
for j in range(1, len(hideInputs)):
hideInputs[j, :] = hideOutputs[j - 1, :] * mat(hideWArr[j - 1, :, :])
hideOutputs[j, 1:] = sigmoid(hideInputs[j, :])
# 根据与输出层连接的隐层的输出值计算输出层神经元的输入
yInputs[0, :] = hideOutputs[len(hideInputs) - 1, :] * lastWMat
# 计算近似输出
yHead = sigmoid(yInputs)
# 获取真实类别
yReal = labels[r]
# 计算输出层神经元的梯度项
gj = array(yHead) * array(1 - yHead) * array((yReal - yHead))
#计算隐层的梯度项
lastSumWGj = lastWMat[1:, :] * mat(gj).T
bMb = multiply(hideOutputs[num - 1, 1:], 1 - hideOutputs[num - 1, 1:])
hideEh[num - 1, :] = multiply(bMb, lastSumWGj.T)
for q in range(num - 1):
index = num - 2 - q
hideSumWEh = mat(hideWArr[index])[1:, :] * hideEh[index + 1].T
bMb = multiply(hideOutputs[index, 1:], 1 - hideOutputs[index, 1:])
hideEh[index, :] = multiply(bMb, hideSumWEh.T)
# 更新各层神经元的连接权和阈值
lastWMat[:,:] = lastWMat[:,:] + alpha * hideOutputs[num - 1].T * mat(gj)
firstWMat[:,:] = firstWMat[:,:] + alpha * xMat[0, :].T * mat(hideEh[0, :])
for p in range(num - 1):
hideWArrMat = mat(hideWArr[p])
hideWArrMat[:, :] = hideWArrMat[:, :] + alpha * hideOutputs[p].T * mat(hideEh[p + 1, :])
hideWArr[p] = array(hideWArrMat)
print ‘repeat: %d‘ % i
# 计算迭代累积误差
ey = (yHead - yReal) * (yHead - yReal).T
# 判断是否达到迭代终止条件
if abs(ey - old_ey) < 0.001:
sn = sn + 1
old_ey = ey
if sn >= 100:
break
else:
sn = 0
old_ey = ey
i = i + 1
return firstWMat, hideWArr,lastWMat, old_ey
获取到了训练参数后，我们就可以使用以下代码对输入向量进行类别预测：
‘‘‘
获取y的近似输出
‘‘‘
def getYHead(inX, yCount, firstWMat, hideWArr, lastWMat):
num = len(hideWArr) + 1 # 隐层数目
eachCount = shape(hideWArr)[2] # 每一层隐层的神经元数目
hideInputs = mat(zeros((num, eachCount))) # 隐层的输入
hideOutputs = mat(zeros((num, eachCount + 1))) # 隐层的输出
hideOutputs[:, 0] = -1.0 ## 初始化隐层输出的每列第一个值为-1，即下一层功能神经元的阈值对应的输入恒为-1
yInputs = mat(zeros((1, yCount))) # 输出层的输入
# 计算隐层的输入
xMat = mat(insert(inX, 0, values=-1.0, axis=1))
hideInputs[0, :] = xMat * firstWMat
hideOutputs[0, 1:] = sigmoid(hideInputs[0, :])
for j in range(1, len(hideInputs)):
hideInputs[j, :] = hideOutputs[j - 1, :] * mat(hideWArr[j - 1, :, :])
hideOutputs[j, 1:] = sigmoid(hideInputs[j, :])

# 计算输出层的输入
yInputs[0, :] = hideOutputs[len(hideInputs) - 1, :] * lastWMat

# 计算近似输出
yHead = sigmoid(yInputs)
return yHead
需要注意的是，不管是训练数据中的类别数据，还是上面的分类函数给出的分类结果，采用的都是one-hot（一位有效）编码，例如对于手写识别系统，如果分类结果是10，则输出的类别会是一个10维的向量，每一维代表了类别为对应下标的概率大小。因为这里被没有对其进行正则化处理，因此总和不一定为1.0.
下面使用一份《机器学习与实战》图书逻辑回归一章附带的一份数据集来对上述分类算法进行训练和测试，数据集如下：

-0.017612 14.053064 0
-1.395634 4.662541 1
-0.752157 6.538620 0
-1.322371 7.152853 0
0.423363 11.054677 0
0.406704 7.067335 1
0.667394 12.741452 0
-2.460150 6.866805 1
0.569411 9.548755 0
-0.026632 10.427743 0
0.850433 6.920334 1
1.347183 13.175500 0
1.176813 3.167020 1
-1.781871 9.097953 0
-0.566606 5.749003 1
0.931635 1.589505 1
-0.024205 6.151823 1
-0.036453 2.690988 1
-0.196949 0.444165 1
1.014459 5.754399 1
1.985298 3.230619 1
-1.693453 -0.557540 1
-0.576525 11.778922 0
-0.346811 -1.678730 1
-2.124484 2.672471 1
1.217916 9.597015 0
-0.733928 9.098687 0
-3.642001 -1.618087 1
0.315985 3.523953 1
1.416614 9.619232 0
-0.386323 3.989286 1
0.556921 8.294984 1
1.224863 11.587360 0
-1.347803 -2.406051 1
1.196604 4.951851 1
0.275221 9.543647 0
0.470575 9.332488 0
-1.889567 9.542662 0
-1.527893 12.150579 0
-1.185247 11.309318 0
-0.445678 3.297303 1
1.042222 6.105155 1
-0.618787 10.320986 0
1.152083 0.548467 1
0.828534 2.676045 1
-1.237728 10.549033 0
-0.683565 -2.166125 1
0.229456 5.921938 1
-0.959885 11.555336 0
0.492911 10.993324 0
0.184992 8.721488 0
-0.355715 10.325976 0
-0.397822 8.058397 0
0.824839 13.730343 0
1.507278 5.027866 1
0.099671 6.835839 1
-0.344008 10.717485 0
1.785928 7.718645 1
-0.918801 11.560217 0
-0.364009 4.747300 1
-0.841722 4.119083 1
0.490426 1.960539 1
-0.007194 9.075792 0
0.356107 12.447863 0
0.342578 12.281162 0
-0.810823 -1.466018 1
2.530777 6.476801 1
1.296683 11.607559 0
0.475487 12.040035 0
-0.783277 11.009725 0
0.074798 11.023650 0
-1.337472 0.468339 1
-0.102781 13.763651 0
-0.147324 2.874846 1
0.518389 9.887035 0
1.015399 7.571882 0
-1.658086 -0.027255 1
1.319944 2.171228 1
2.056216 5.019981 1
-0.851633 4.375691 1
-1.510047 6.061992 0
-1.076637 -3.181888 1
1.821096 10.283990 0
3.010150 8.401766 1
-1.099458 1.688274 1
-0.834872 -1.733869 1
-0.846637 3.849075 1
1.400102 12.628781 0
1.752842 5.468166 1
0.078557 0.059736 1
0.089392 -0.715300 1
1.825662 12.693808 0
0.197445 9.744638 0
0.126117 0.922311 1
-0.679797 1.220530 1
0.677983 2.556666 1
0.761349 10.693862 0
-2.168791 0.143632 1
1.388610 9.341997 0
0.317029 14.739025 0
这是一个二分类问题，包含了100个样本，每个样本包含两个特征的取值以及一个类别标签。

以下代码将从文本文件中读取上述数据集并转化为我们所需的格式：

def loadDataSet(fileName):
dataMat = []
labelMat = []
with open(fileName, ‘r‘) as fr:
for line in fr.readlines():
lineArr = line.strip().split()
dataMat.append([float(lineArr[0]), float(lineArr[1])])
if int(lineArr[2]) == 0:
labelMat.append([1.0, 0.0])
else:
labelMat.append([0.0, 1.0])
return mat(dataMat), mat(labelMat)
训练和测试的代码为：
def test():
dataSet, labels = loadDataSet(‘testSet.txt‘)
firstWMat, hideWArr, lastWMat,ey = bp(dataSet, labels)
labelsHead = []
for line in dataSet:
yHead = getYHead(line, 2, firstWMat, hideWArr, lastWMat)
labelsHead.append(yHead)
errorCount = 0
for i in range(len(labels)):
if labels[i, 0] == 1:
yReal = 0
else:
yReal = 1
if labelsHead[i][0, 0] > labelsHead[i][0, 1]:
yEs = 0
else:
yEs = 1
if yReal != yEs:
print ‘error when test: [%f, %f], real: %d, error: %d‘ %(dataSet[i][0, 0], dataSet[i][0, 1], yReal, yEs)
errorCount = errorCount + 1
print ‘error rate: %f‘ %(float(errorCount) / len(dataSet))
return labelsHead
为了简单，以上代码把同一份数据集既当作了训练数据，也当作了测试数据，最后的正确率大概在97%。

原文地址：https://www.cnblogs.com/limingqi/p/11830247.html

时间： 2024-11-09 07:44:57

BP算法推导python实现的相关文章

误差逆传播(error BackPropagation, BP)算法推导及向量化表示

1.前言看完讲卷积神经网络基础讲得非常好的cs231后总感觉不过瘾,主要原因在于虽然知道了卷积神经网络的计算过程和基本结构,但还是无法透彻理解卷积神经网络的学习过程.于是找来了进阶的教材Notes on Convolutional Neural Networks,结果刚看到第2章教材对BP算法的回顾就犯难了,不同于之前我学习的对每一个权值分别进行更新的公式推导,通过向量化表示它只用了5个式子就完成了对连接权值更新公式的描述,因此我第一眼看过去对每个向量的内部结构根本不清楚.原因还估计是自己当初

机器学习之神经网络bp算法推导

这是一篇学习UFLDL反向传导算法的笔记,按自己的思路捋了一遍,有不对的地方请大家指点. 首先说明一下神经网络的符号: 1. nl 表示神经网络的层数. 2. sl 表示第 l 层神经元个数,不包含偏置单元. 3. z(l)i 表示第 l 层第 i 个神经元的输入:a(l)i 表示第 l 层第 i 个神经元的输出. 4. W(l)ij 表示第 l 层第 j 个神经元连接到第 l+1 层第 i 个神经元的权重,因此权值矩阵 W 的维数为 sl+1 x sl 第二层各神经元的计算方法如下: a(2)

BP神经网络推导过程详解

BP算法是一种最有效的多层神经网络学习方法,其主要特点是信号前向传递,而误差后向传播,通过不断调节网络权重值,使得网络的最终输出与期望输出尽可能接近,以达到训练的目的. 一.多层神经网络结构及其描述下图为一典型的多层神经网络. 通常一个多层神经网络由L层神经元组成,其中:第1层称为输入层,最后一层(第L层)被称为输出层,其它各层均被称为隐含层(第2层~第L-1层). 令输入向量为: \[ \vec x = [x_1 \quad x_2 \quad \ldots \quad x_i \quad

神经网络和BP算法C及python代码

以上仅给出了代码.具体BP实现原理及神经网络相关知识请见:神经网络和反向传播算法推导首先是前向传播的计算: 输入: 首先为正整数 n.m.p.t,分别代表特征个数.训练样本个数.隐藏层神经元个数.输出层神经元个数.其中(1<n<=100,1<m<=1000, 1<p<=100, 1<t<=10). 随后为 m 行,每行有 n+1 个整数.每行代表一个样本中的 n 个特征值 (x 1 , x 2 ,..., x n ) 与样本的实际观测结果 y.特征值的

BP算法从原理到python实现

BP算法从原理到实践反向传播算法Backpropagation的python实现觉得有用的话,欢迎一起讨论相互学习~Follow Me 博主接触深度学习已经一段时间,近期在与别人进行讨论时,发现自己对于反向传播算法理解的并不是十分的透彻,现在想通过这篇博文缕清一下思路.自身才疏学浅欢迎各位批评指正. 参考文献李宏毅深度学习视频 The original location of the code 关于反向传播算法的用途在此不再赘述,这篇博文主要是理解形象化理解反向传播算法与python进行实

BP算法基本原理推导----《机器学习》笔记

前言多层网络的训练需要一种强大的学习算法,其中BP(errorBackPropagation)算法就是成功的代表,它是迄今最成功的神经网络学习算法. 今天就来探讨下BP算法的原理以及公式推导吧. 神经网络先来简单介绍一下神经网络,引入基本的计算公式,方便后面推导使用图1 神经网络神经元模型图1就是一个标准的M-P神经元模型.

深度学习BP算法的推导（附加RNN,LSTM的推导说明）

注:1)这篇文章主要参考Alex Graves的博士论文<Supervised Sequence Labelling with Recurrent Neural Networks> 详细介绍其关于BP算法的推导过程. 2)论文没有提到过偏差的处理,不过如果能耐心推导出论文给出的公式,那么这将十分简单. 3)由于是结合语音训练的,最后是softmax出来是获得有限结果的概率值,然后做交叉熵作为目标函数,所以可能与其他的网络不一致,但是反馈的推导应该是一样的,除了输出层和最后一个隐层之间的个推导.

多层神经网络BP算法原理及推导

首先什么是人工神经网络?简单来说就是将单个感知器作为一个神经网络节点,然后用此类节点组成一个层次网络结构,我们称此网络即为人工神经网络(本人自己的理解).当网络的层次大于等于3层(输入层+隐藏层(大于等于1)+输出层)时,我们称之为多层人工神经网络. 1.神经单元的选择那么我们应该使用什么样的感知器来作为神经网络节点呢?在上一篇文章我们介绍过感知器算法,但是直接使用的话会存在以下问题: 1)感知器训练法则中的输出由于sign函数时非连续函数,这使得它不可微,因而不能使用上面的梯度下降算法来最

神经网络误差逆传播算法推导 BP算法

??误差逆传播算法是迄今最成功的神经网络学习算法,现实任务中使用神经网络时,大多使用BP算法进行训练. ??给定训练集\(D={(x_1,y_1),(x_2,y_2),......(x_m,y_m)},x_i \in R^d,y_i \in R^l\),即输入示例由\(d\)个属性描述,输出\(l\)个结果.如图所示,是一个典型的单隐层前馈网络,它拥有\(d\)个输入神经元.\(l\)个输出神经元.\(q\)个隐层神经元,其中,\(\theta_j\)表示第\(j\)个神经元的阈值,\(\gam