BP算法推导python实现

1. def sigmoid(inX):
2.  
   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%。