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%。

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

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

    1.前言 看完讲卷积神经网络基础讲得非常好的cs231后总感觉不过瘾,主要原因在于虽然知道了卷积神经网络的计算过程和基本结构,但还是无法透彻理解卷积神经网络的学习过程.于是找来了进阶的教材Notes ...

  2. 神经网络和BP算法推导

    注意:绘画太难了,因为他们画,本文中的所有插图来自基本算法饺子机类.请勿转载 1.习模型: 事实上,基本上全部的基本机器学习模型都能够概括为下面的特征:依据某个函数,将输入计算并输出. 图形化表示为下 ...

  3. bp算法推导过程

    参考:张玉宏<深度学习之美:AI时代的数据处理与最佳实践>265-271页

  4. 深度学习——前向传播算法和反向传播算法(BP算法)及其推导

    1 BP算法的推导 图1 一个简单的三层神经网络 图1所示是一个简单的三层(两个隐藏层,一个输出层)神经网络结构,假设我们使用这个神经网络来解决二分类问题,我们给这个网络一个输入样本,通过前向运算得到 ...

  5. BP神经网络算法推导及代码实现笔记zz

    一. 前言: 作为AI入门小白,参考了一些文章,想记点笔记加深印象,发出来是给有需求的童鞋学习共勉,大神轻拍! [毒鸡汤]:算法这东西,读完之后的状态多半是 --> “我是谁,我在哪?” 没事的 ...

  6. BP神经网络推导过程详解

    BP算法是一种最有效的多层神经网络学习方法,其主要特点是信号前向传递,而误差后向传播,通过不断调节网络权重值,使得网络的最终输出与期望输出尽可能接近,以达到训练的目的. 一.多层神经网络结构及其描述 ...

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

    上面只显示代码. 详BP原理和神经网络的相关知识,请参阅:神经网络和反向传播算法推导 首先是前向传播的计算: 输入: 首先为正整数 n.m.p.t,分别代表特征个数.训练样本个数.隐藏层神经元个数.输 ...

  8. BP算法从原理到python实现

    BP算法从原理到实践 反向传播算法Backpropagation的python实现 觉得有用的话,欢迎一起讨论相互学习~Follow Me 博主接触深度学习已经一段时间,近期在与别人进行讨论时,发现自 ...

  9. BP算法的矩阵推导

    目录 1. 需要的微积分知识 1.1 导数 1.2 求导的链式法则 2. 梯度下降法 2.1 梯度 2.2 梯度算法的解释 3.误差反向传播算法 3.1 理论推导 3.1.1 符号说明 3.1.2 推 ...

随机推荐

  1. 永久免费云服务器搭建国内Moon服务加速ZeroTier

    ZeroTier One本身的服务器都在国外访问速度很慢.可以通过搭建国内Moon服务加速解决连接慢的问题. 但是需要有固定外网IP的服务器,可以注册sanfengyun账号申请免费云服务器. 下面是 ...

  2. reduce()、filter()、map()、some()、every()、...展开属性

    reduce().filter().map().some().every()....展开属性   这些概念属于es5.es6中的语法,跟react+redux并没有什么联系,我们直接在https:// ...

  3. 常用Java工具类

    一. org.apache.commons.io.IOUtils closeQuietly:关闭一个IO流.socket.或者selector且不抛出异常,通常放在finally块 toString: ...

  4. 二十九、SAP中输出漂亮的表格

    一.代码如下 二.输出效果如下 *&---------------------------------------------------------------------* *& ...

  5. java排序,效率高的是哪种排序方法

    和所有其他语言是一样的.应该还是快速排序效率最高. public static void bubbleSort(int a[]) {int len = a.length;for (int i = 0; ...

  6. junit基础学习之-引用spring容器的测试(7)

    context 自动注入的文章链接:http://www.360doc.com/content/11/0815/09/2371584_140471325.shtml

  7. 第十九篇 同源策略与Jsonp

    同源策略 同源策略(Same origin policy)是一种约定,它是浏览器最核心也最基本的安全功能,如果缺少了同源策略,则浏览器的正常功能可能都会受到影响.可以说Web是构建在同源策略基础之上的 ...

  8. ESP8266 SDK开发: 外设篇-串口

    串口分布 串口切换说明 1.默认所有的数据都使用串口0输出 官方提供了函数可以选择printf利用哪一个串口输出 配置printf使用串口1打印输出,波特率115200 (注:这样配置对于调试程序很有 ...

  9. Mac 终端命令使用自动补全时忽略大小写设置

    Mac 终端在使用 tab 补全命令时默认大小写敏感,通过以下设置方法可以忽略大小写,方法同样适用于 iTerm2. 打开终端输入以下命令: nano .inputrc 将以下命令复制进去: set ...

  10. 留学生如何在Presentation中拿高分?

    掐指一算,留学生们最近应该马上遇到Presentation任务.一般来说,这类的任务会占最终成绩的20-30%,对于期末成绩有一定的影响,如果想拿高分,就需要好好的准备. 所以本文算是系列里的第一篇( ...