Caffe修炼之路（3）——自己编写卷积神经网络
 
（一）前 言
（二）网络proto文件编写
（三）Solver配置
（四）开始训练


 

 
（一）前 言
 
上一节我们跑了Caffe自带的MNIST示例，感觉用Caffe训练还是挺简单的，不由得说一句：
 
 这一节就开始自己编写神经网络了，数据就暂时使用上一节下载好的MNIST数据，之后再自己制作数据，ok我们开始吧！
 
（二）网络proto文件编写
 
这就是写你的神经网络的结构，由若干个layer字段组成，以卷积层为例：
 
layer {
  name: "conv1"  这一层的名字
  type: "Convolution" 层的类型，这里是卷积
  bottom: "data" 输入数据的来源
  top: "conv1" 表示输出结果的数据保存到存储结构conv1中
  param { 所有层共用的内容，学习率之类的
    lr_mult: 1
  }
  param {
    lr_mult: 2
  }
  convolution_param { 可选参数，卷积核的大小，滑动步长之类的，之后再细讲
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
 
我们来尝试定义一个含有两个卷积层的卷积网络，并加入BN层，命名为network.prototxt：
 
name: "my_net"
# 加载训练数据
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TRAIN
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "examples/mnist/mnist_train_lmdb"
    batch_size: 64
    backend: LMDB
  }
}
layer {
  name: "mnist"
  type: "Data"
  top: "data"
  top: "label"
  include {
    phase: TEST
  }
  transform_param {
    scale: 0.00390625
  }
  data_param {
    source: "examples/mnist/mnist_test_lmdb"
    batch_size: 100
    backend: LMDB
  }
}
# 定义网络结构
layer {
  name: "conv1"
  type: "Convolution"
  bottom: "data"
  top: "conv1"
  param {
    lr_mult: 1
  }
  convolution_param {
    num_output: 20
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool1"
  type: "Pooling"
  bottom: "conv1"
  top: "pool1"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer{
  name: "bn_1"
  type: "BatchNorm"
  bottom: "pool1"
  top: "bn_1"
  param {
      lr_mult: 0
    }
}
layer {
  name: "conv2"
  type: "Convolution"
  bottom: "bn_1"
  top: "conv2"
  param {
    lr_mult: 1
  }
  convolution_param {
    num_output: 50
    kernel_size: 5
    stride: 1
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "pool2"
  type: "Pooling"
  bottom: "conv2"
  top: "pool2"
  pooling_param {
    pool: MAX
    kernel_size: 2
    stride: 2
  }
}
layer{
  name: "bn_2"
  type: "BatchNorm"
  bottom: "pool2"
  top: "bn_2"
  param {
      lr_mult: 0
    }
}
layer {
  name: "ip1"
  type: "InnerProduct"
  bottom: "bn_2"
  top: "ip1"
  param {
    lr_mult: 1
  }
  inner_product_param {
    num_output: 500
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
layer {
  name: "relu1"
  type: "ReLU"
  bottom: "ip1"
  top: "ip1"
}
layer {
  name: "ip2"
  type: "InnerProduct"
  bottom: "ip1"
  top: "ip2"
  param {
    lr_mult: 1
  }
  inner_product_param {
    num_output: 10
    weight_filler {
      type: "xavier"
    }
    bias_filler {
      type: "constant"
    }
  }
}
# 定义精度和损失函数
layer {
  name: "accuracy"
  type: "Accuracy"
  bottom: "ip2"
  bottom: "label"
  top: "accuracy"
  include {
    phase: TEST
  }
}
layer {
  name: "loss"
  type: "SoftmaxWithLoss"
  bottom: "ip2"
  bottom: "label"
  top: "loss"
}
 
（三）Solver配置
 
接下来定义solver.prototxt文件，在这里定义相关训练参数：
 
net: "examples/exercise/network.prototxt"
test_iter: 100
# 每训练500次进行一次测试
test_interval: 500
# 基础学习率、上一次更新的权重、权重衰减
base_lr: 0.01
momentum: 0.9
weight_decay: 0.0005
# 学习率改变策略
lr_policy: "inv"
gamma: 0.0001
power: 0.75
# 每多少次显示训练变化数据
display: 100
# 最大迭代次数
max_iter: 10000
# 每迭代多少次创建训练快照
snapshot: 5000
snapshot_prefix: "examples/mnist/lenet"
# 用CPU还是GPU训练
solver_mode: CPU
 
（四）开始训练
 
在caffe-master目录下键入：
 
build/tools/caffe train --solver=examples/exercise/solver.prototxt
 
输出：
 
I0703 15:15:15.058523 47871 solver.cpp:239] Iteration 980 (12.5313 iter/s, 0.798s/10 iters), loss = 0.0946411
I0703 15:15:15.058604 47871 solver.cpp:258]     Train net output #0: loss = 0.0946413 (* 1 = 0.0946413 loss)
I0703 15:15:15.058629 47871 sgd_solver.cpp:112] Iteration 980, lr = 0.00932284
I0703 15:15:15.866871 47871 solver.cpp:239] Iteration 990 (12.3762 iter/s, 0.808s/10 iters), loss = 0.0414168
I0703 15:15:15.866932 47871 solver.cpp:258]     Train net output #0: loss = 0.0414169 (* 1 = 0.0414169 loss)
I0703 15:15:15.866943 47871 sgd_solver.cpp:112] Iteration 990, lr = 0.00931648
I0703 15:15:16.583163 47871 solver.cpp:464] Snapshotting to binary proto file examples/mnist/lenet_iter_1000.caffemodel
I0703 15:15:16.591723 47871 sgd_solver.cpp:284] Snapshotting solver state to binary proto file examples/mnist/lenet_iter_1000.solverstate
I0703 15:15:16.630581 47871 solver.cpp:327] Iteration 1000, loss = 0.0563128
I0703 15:15:16.630635 47871 solver.cpp:347] Iteration 1000, Testing net (#0)
I0703 15:15:17.115231 47871 solver.cpp:414]     Test net output #0: accuracy = 0.978
I0703 15:15:17.115291 47871 solver.cpp:414]     Test net output #1: loss = 0.0601787 (* 1 = 0.0601787 loss)
I0703 15:15:17.115298 47871 solver.cpp:332] Optimization Done.
I0703 15:15:17.115303 47871 caffe.cpp:250] Optimization Done.
 
我这用的CPU版本，不得不说Caffe训练起来还是挺快的，毕竟是C++写的，C++牛逼！！！感觉TensorFlow要抛弃我这个粉丝了。。。。。。

最近在看一些经典的论文，想要动手复现其中的代码，无奈自己水平过于低，总感觉对于神经网络的理解不够深入，于是想补一下相关的知识。
 便找到了《Python神经网络编程》这本书，若稍微有些基础看起来很快，看完之后给我的感觉是对于神经网络的基本知识、神经网络背后的核心思想有了更深的理解，及时记录下来，方便自己学习。
 
 
 
首先附上这本书的PDF与相关资源
 链接：https://pan.baidu.com/s/1lcVimFBDDCYGTIi6xzxV_g
 提取码：oiv7
 
 


 
关于神经网络的理解
 
1.关于神经元，神经网络的解释
2.为何神经网络需要很多个节点
3.神经网络的工作原理：前向传播
4.神经网络学习的途径：反向传播
5.数据中输入与输出的标准化处理
6.关于权重的随机初始值
   
实例：搭建一个神经网络
源程序及代码注释
  
 

 
1.关于神经元，神经网络的解释
 
①首先来观察生物大脑中的基本单元——神经元。
 
 虽然神经元有各种形式，但是所有的神经元都是将电信号从一端传输到另一端，沿着轴突，将电信号从树突传到树突。然后，这些信号从一个神经元传递到另一个神经元。这就是身体感知光、声、触压、热等信号的机制。来自专门的感觉神经元的信号沿着神经系统，传输到大脑，而大脑本身主要也是由神经元构成的。
 ②那机器怎么做才能有这种功能？
 上图中的神经元功能可以简化为如下这幅图：
 
 可以发现神经元的工作原理可以理解为它接受了一个电信号输入，输出另一个电信号。这看起来，似乎与分类或预测的机器一模一样，这些机器也是接受了一个输入，进行一些处理，然后弹出一个输出。
 ③激活函数的作用
 在看神经网络相关的书时，总会少不了激活函数，那激活函数的作用是什么？
 生物大脑中的神经元，对于某些外部刺激的时候，不会立即得到反馈，就好比走在路上，很远处看到一辆汽车向你驶来，可能不会在意，但如果离你越来越近，得到的反馈与作出的反应就更剧烈，这似乎其中有一个刺激神经元的度量。
 观察表明，神经元不会立即反应，而是会抑制输入，直到输入增强，强大到可以触发输出。你可以这样认为，在产生输出之前，输入必须到达一个阈值。就像水在杯中——直到水装满了杯子，才可能溢出。直观上，这是有道理的——神经元不希望传递微小的噪声信号，而只是传递有意识的明显信号。下图说明了这种思想，只有输入超过了阈值（threshold），足够接通电路，才会产生输出信号。
 
 上图可知，虽然这个函数接受了输入信号，产生了输出信号，但是我们要将某种称为激活函数的阈值考虑在内。在数学上，有许多激活函数可以达到这样的效果。可能有人觉得将神经元表示为线性函数不行吗？虽然这是个好主意，但是不可以这样做。生物神经元与简单的线性函数不一样，不能简单地对输入做出的响应，生成输出。也就是说，它的输出不能采用这种形式：输出=（常数*输入）+（也许另一常数）。
 这里采用Sigmoid函数。（当然采用tanh、relu、leakyrelu、softmax等函数都可以）
 网上关于sigmoid介绍的很详细。
 PS：激活函数的作用：对于输入信号进行过滤的作用，若是输入太小，则忽略不计，若是达到了你设定的阈值，则神经元（节点）作出反馈。
 
 
2.为何神经网络需要很多个节点
 
可以参考这篇博客中关于感知机的局限性、多层感知机、从感知机到神经网络的解释。
 
3.神经网络的工作原理：前向传播
 
举一个小的神经网络为例：
 
 （上图中：两个输入值分别为1.0和0.5。这些值输入到这个较小的神经网络，每个节点使用激活函数，将输入转变成输出。还将使用先前的Sigmoid函数y = 1/(1 + e−x )，其中神经元输入信号的总和为x ，神经元输出为y）
 权重：即上图中的w1,1，w1,2，w2,1，w2,2 ，可以理解为各个神经元节点对于外部输入的敏感程度，w1,1 表示上层中的节点1到下层中的节点1之间的权重值。这里的权重值随机设置的，随着分类器学习各个样本，随机值就可以得到改进。对于神经网络链接的权重而言，这也是一样的。
 计算过程：
 第一层节点是输入层，这一层不做其他事情，仅表示输入信号。也就是说，输入节点不对输入值应用激活函数。这没有什么其他奇妙的原因，自然而然地，历史就是这样规定的。神经网络的第一层是输入层，这层所做的所有事情就是表示输入，仅此而已。
 第一层输入层很容易，此处，无需进行计算。
 接下来的第二层，我们需要做一些计算。对于这一层的每个节点们需要算出组合输入。还记得Sigmoid函数y = 1 /（1 + e-x ）吗？这个函数中的x表示一个节点的组合输入。此处组合的是所连接的前一层中的原始输出，但是这些输出得到了链接权重的调节。下图包括使用链接权重调节输入信号的过程。
 
 因此，对于第二层的节点1。第一层输入层中的两个节点连接到了这个节点。这些输入节点具有1.0和0.5的原始值。来自第一个节点的链接具有0.9的相关权重，来自第二个节点的链接具有0.3的权重。因此，组合经过了权重调节后的输入，如下所示：
 x = （第一个节点的输出链接权重）+（第二个节点的输出链接权重）
 x =（1.0 * 0.9）+（0.5 * 0.3）
 x = 0.9 + 0.15
 x = 1.05
 我们不希望看到：不使用权重调节信号，只进行一个非常简单的信号相加1.0 + 0.5。
 权重是神经网络进行学习的内容，这些权重持续进行优化，得到越来越好的结果。
 现在，已经得到了x =1.05，这是第二层第一个节点的组合调节输入。最终，我们可以使用激活函数y = 1 /（1 + e -x ）计算该节点的输出。答案为y = 1 /（1 + 0.3499）= 1/ 1.3499。因此，y = 0.7408。
 第二层第二个节点的计算方法类比上面的计算过程。
 矩阵的便捷
 从一个非常简化的网络得到两个输出值，这个工作量相对较小。对于一个相对较大的网络，具有多于两层，每一层有4、8甚至100个节点的网络，其计算量就很复杂。这时候，可以借助计算机，通过矩阵之间的计算解决。
 
 
 
 
4.神经网络学习的途径：反向传播
 

 如上图，假设输入x1=1.0，x2=0.5，则输出为y1=0.7408，y2=0.6457，对于误差值（输出-输入），即神经网络的输出与实际输入的差别，神经网络通过这种误差，不断反馈给前面层的节点，从而让权重进行相应的修改（变大或变小），以便让输出无限接近于输入，这个过程称为反向传播，数学化后，给出一个损失函数的概念，即判断神经网络的准确程度（即误差值=（输出-输入）的绝对值，当误差小于你事先设定好了的阈值或者神经网络学习的次数小于事先设置的次数大小，则神经网络停止学习），也就是神经网络不断进行学习的原因。
 ①如何学习来自多个节点的权重
 当输出和误差是多个节点共同作用的结果时，如何更新链接权重呢？下图详细阐释了这个问题。
 
 当只有一个节点前馈信号到输出节点，事情要简单得多。如果有两个节点，如何使用输出误差值呢？使用所有的误差值，只对一个权重进行更新，这种做法忽略了其他链接及其权重，毫无意义。多条链接都对这个误差值有影响。只有一条链接造成了误差，这种机会微乎其微。如果我们改变了已经“正确”的权重而使情况变得更糟，那么在下一次迭代中，这个权重就会得到改进，因此神经网络并没有失去什么。
 一种思想：在所有造成误差的节点中平分误差，如下图所示：
 
 另一种思想：不等分误差。与前一种思想相反，该思想认为较大链接权重的连接分配更多的误差。为什么这样做呢？这是因为这些链接对造成误差的贡献较大。下图详细阐释了这种思想。
 
 此处，有两个节点对输出节点的信号做出了贡献，它们的链接权重分别是3.0和1.0。如果按权重比例分割误差，那么我们就可以观察到输出误差的3/4应该可以用于更新第一个较大的权重，误差的1/4 可以用来更新较小的权重。
 我们可以将同样的思想扩展到多个节点。如果我们拥有100个节点链接到输出节点，那么我们要在这100条链接之间，按照每条链接对误差所做贡献的比例（由链接权重的大小表示），分割误差。
 将不等分思想用矩阵表示其计算过程：
 
 
 ②实际中更新权重的方法
 对于上面提到了两个思想，我们都没有采纳。
 到目前为止，已经理解了让误差反向传播到网络的每一层。为什么这样做呢？原因就是，我们使用误差来指导如何调整链接权重，从而改进神经网络输出的总体答案。
 但是，这些节点都不是简单的线性分类器。这些稍微复杂的节点，对加权后的信号进行求和，并应用了S阈值函数，将所得到的结果输出给下一层的节点。因此，如何才能真正地更新连接这些相对复杂节点链接的权重呢？
 即使是一个只有3层、每层3个神经元的小小的神经网络，就像我们刚才使用的神经网络，也具有太多的权重和函数需要组合。在此情况下，你如何调整输入层第一个节点和隐藏层第二个节点之间链路的权重，以使得输出层第三个节点的输出增加0.5呢？即使我们碰运气做到了这一点，这个效果也会由于需要调整另一个权重来改进不同的输出节点而被破坏。
 
 要意识到这件事情的重要性，请观察上面的表达式，这是一个简单的3层、每层3个节点的神经网络，其中输入层节点的输出是输入值和链接权重的函数。在节点i处的输入是xi ，连接输入层节点i到隐藏层节点j的链接权重为wi,j ，类似地，隐藏层节点j的输出是xj ，连接隐藏层节点j和输出层节点k的链接权重是wj,k 。
 可以看到，对于3层每层3个节点的计算都这么复杂，若是更复杂的神经网络，这种暴力的方法不切实际。
 ③对此引出了梯度下降法
 这里不做赘述，网上有很多讲梯度下降法的。
 权重更新的公式：
 
 （其中：tk 是一个常数，即输入的目标值，ok 表示神经网络实际的输出值，wj,k 表示隐藏层与输出层之间的权重矩阵）
 该公式的具体推导见《Python神经网络编程》书上的P98
 
 
 ④对③中的公式进行优化
 
 
 ⑤学习率
 对于权重参数的更新方法如下：
 
 其中α表示学习率，可以理解为梯度下降法中每次移动的步长，可以调节这些变化的强度，确保不会超调。
 最终的权重更新公式如下：
 
 
5.数据中输入与输出的标准化处理
 
①输入
 观察下图的Sigmoid函数：
 
 由图可知，如果输入变大，激活函数就会变得非常平坦。由于我们使用梯度学习新的权重，因此一个平坦的激活函数会出问题。
 回头仔细观察关于权重变化的表达式。权重的改变取决于激活函数的梯度。小梯度意味着限制神经网络学习的能力。这就是所谓的饱和神经网络。这意味着，我们应该尽量保持小的输入。
 有趣的是，这个表达式也取决于输入信号（oj ），因此，我们也不应该让输入信号太小。当计算机处理非常小或非常大的数字时，可能会丧失精度，因此，使用非常小的值也会出现问题。
 一个好的建议是重新调整输入值，将其范围控制在0.0到1.0。输入0会将oj 设置为0，这样权重更新表达式就会等于0，从而造成学习能力的丧失，因此在某些情况下，我们会将此输入加上一个小小的偏移，如0.01，避免输入0带来麻烦。
 ②输出
 
 由上图可知，神经网络的输出是最后一层节点弹出的信号。如果我们使用的激活函数不能生成大于1的值，那么尝试将训练目标值设置为比较大的值就有点愚蠢了。（因为Sigmoid函数不能取到1.0，只能接近1.0，接近于0）
 如果我们将目标值设置在这些不可能达到的范围，训练网络将会驱使更大的权重，以获得越来越大的输出，而这些输出实际上是不可能由激活函数生成的。这使得网络饱和，因此我们知道这种情况是很糟糕的。因此，我们应该重新调整目标值，匹配激活函数的可能输出，注意避开激活函数不可能达到的值。
 虽然，常见的使用范围为0.0～1.0，但是由于0.0和1.0这两个数也不可能是目标值，并且有驱动产生过大的权重的风险，因此一些人也使用0.01～0.99的范围。（下面程序中会有体现）
 
# 将输入数据进行归一化处理
inputs = (np.asfarray(all_values[1:]) / 255.0*0.99) + 0.01
 
6.关于权重的随机初始值
 
权重的初始值有很多的选择，这里按照书上讲的，方便后面程序的理解。
 与输入和输出一样，同样的道理也适用于初始权重的设置。由于大的初始权重会造成大的信号传递给激活函数，导致网络饱和，从而降低网络学习到更好的权重的能力，因此应该避免大的初始权重值。我们可以从-1.0～+1.0之间随机均匀地选择初始权重。比起使用非常大的范围，比如说-1000～+1000，这是一个好得多的思路。
 按照书上讲的，我们可以在一个节点传入链接数量平方根倒数的大致范围内随机采样，初始化权重。因此，如果每个节点具有3条传入链接，那么初始权重的范围应该在从-1/根号3到+1/根号3 ，即±0.577之间。如果每个节点具有100条传入链接，那么权重的范围应该在-1/根号100至 +1/根号100，即±0.1之间。
 
 （下面程序中会有体现）
 
# 初始化权重矩阵
# 数组中的权重是wij，含义是从上一层节点i到下一层的节点j
# np.random.normal()三个参数，分别代表生成的高斯分布的随机数的均值、方差以及输出的size
# 数组中的每个值减去0.5，这样，在效果上，数组中的每个值都成为了-0.5到0.5之间的随机值
# 使用正态概率分布采样权重，其中平均值为0，标准方差为节点传入链接数目的开方，即1/ 根号下传入链接数目
self.wih = np.random.normal(0.0,pow(self.hiddennotes,-0.5),(self.hiddennotes,self.inputnotes))
self.who = np.random.normal(0.0,pow(self.outputnotes,-0.5),(self.outputnotes,self.hiddennotes))
 
实例：搭建一个神经网络
 
①框架代码：
 初始化函数——设定输入层节点、隐藏层节点和输出层节点的数量。
 训练——学习给定训练集样本后，优化权重。
 查询——给定输入，从输出节点给出答案。
 PS：在训练神经网络的过程中有两个阶段，第一个阶段就是计算输出，如同query()所做的事情，第二个阶段就是反向传播误差，告知如何优化链接权重。将计算得到的输出与所需输出对比，使用差值来指导网络权重的更新。
 query()函数接受神经网络的输入，返回网络的输出。
 ②权重
 
 ③用于更新节点j与其下一层节点k之间链接权重的矩阵形式的表达式
 
 ④关于优化神经网络的方法：
 a.调整学习率
 b.进行多次训练运行
 c.改变网络的形状：修改隐藏层节点的数目
 在尝试使用不同数目的隐藏层节点进行实验之前，让我们思考一下，如果这样做可能会发生什么情况。隐藏层是发生学习过程的层次。请记住，输入节点只需引入输入信号，输出节点只要送出神经网络的答案，是隐藏层（可以多层）进行学习，将输入转变为答案。这是学习发生的场所。事实上，隐藏层节点前后的链接权重具有学习能力。
 如果隐藏层节点太少，比如说3个，那么你可以想象，这不可能有足够的空间让网络学习任何知识，并将所有输入转换为正确的输出。这就像要5座车去载10个人。你不可能将那么多人塞进去。计算机科学家称这种限制为学习容量。虽然学习能力不能超过学习容量，但是可以通过改变车辆或网络形状来增加容量。
 如果有10 000个隐藏层节点，会发生什么情况呢？虽然我们不会缺少学习容量，但是由于目前有太多的路径供学习选择，因此可能难以训练网络。这也许需要使用10 000个世代来训练这样的网络。
 随着增加隐藏层节点的数量，结果有所改善，但是不显著。由于增加一个隐藏层节点意味着增加了到前后层的每个节点的新网络链接，这一切都会产生额外较多的计算，因此训练网络所用的时间也显著增加了！因此，必须在可容忍的运行时间内选择某个数目的隐藏层节点。
 ⑤数据集MNIST的处理
 打开其中一个训练集：
 
 在这个文本中：
 ●第一个值是标签，即书写者实际希望表示的数字，如“5”或“9”。这是我们希望神经网络学习得到的正确答案。
 ●随后的值，由逗号分隔，是手写体数字的像素值。像素数组的尺寸是28乘以28，因此在标签后有784个值。
 ⑥将28*28的数组转化为图像
 
 ⑦numpy.asfarray()这个函数将文本字符串转换成实数，并创建这些数字的数组
 https://blog.csdn.net/qq_36501722/article/details/87829743
 
源程序及代码注释
 
# python制作自己的神经网络
# 代码为一个3层神经网络，使用MNIST数据集

import numpy as np
import scipy.special # 调用sigmoid函数模块
import matplotlib.pyplot as plt

# 定义神经网络类
class neuralNetwork():
    '''初始化神经网络'''
    def __init__(self,inputnodes,hiddennodes,outputnodes,learningrate):
        # 设置输入、隐藏、输出层的节点数
        self.inputnotes = inputnodes
        self.hiddennotes = hiddennodes
        self.outputnotes = outputnodes

        # 学习率
        self.lr = learningrate

        # 初始化权重矩阵
        # 数组中的权重是wij，含义是从上一层节点i到下一层的节点j
        # np.random.normal()三个参数，分别代表生成的高斯分布的随机数的均值、方差以及输出的size
        # 数组中的每个值减去0.5，这样，在效果上，数组中的每个值都成为了-0.5到0.5之间的随机值
        # 使用正态概率分布采样权重，其中平均值为0，标准方差为节点传入链接数目的开方，即1/ 根号下传入链接数目
        self.wih = np.random.normal(0.0,pow(self.hiddennotes,-0.5),(self.hiddennotes,self.inputnotes))
        self.who = np.random.normal(0.0,pow(self.outputnotes,-0.5),(self.outputnotes,self.hiddennotes))

        # 激活函数为sigmoid函数
        self.activation_function = lambda x: scipy.special.expit(x)

    '''训练神经网络'''
    def train(self,inputs_lists,targets_list):
        # 将输入列表转换为二维数组
        inputs = np.array(inputs_lists,ndmin=2).T # ndmin=2表示二维数组
        targets = np.array(targets_list,ndmin=2).T

        # 计算信号从输入层进入到隐藏层输入
        hidden_inputs = np.dot(self.wih, inputs)

        # 计算从隐含层后出现的信号，经过sigmoid函数
        hidden_outputs = self.activation_function(hidden_inputs)

        # 计算信号到最终的输出层
        final_inputs = np.dot(self.who, hidden_outputs)

        # 计算从最终输出层出现的信号
        final_outputs = self.activation_function(final_inputs)

        # 输出层误差为(目标-实际)
        output_errors = targets - final_outputs

        # 隐藏层误差是output_errors，按权重分割，在隐藏节点处重新组合
        hidden_errors = np.dot(self.who.T,output_errors)

        # 更新隐藏层和输出层之间的链接的权重（按公式来）
        # np.transpose：对于二维 ndarray，transpose在不指定参数是默认是矩阵转置
        self.who += self.lr * np.dot((output_errors*final_outputs * (1.0-final_outputs)),np.transpose(hidden_outputs))
        # 更新输入层和隐藏层之间的链接的权重
        self.wih += self.lr * np.dot((hidden_errors*hidden_outputs*(1.0-hidden_outputs)),np.transpose(inputs))

    '''查询神经网络，用以预测测试集的输出结果'''
    def query(self,inputs_list):
        # 将输入列表转换为二维数组
        inputs = np.array(inputs_list,ndmin=2).T

        # 计算信号到隐藏层
        hidden_inputs = np.dot(self.wih,inputs)

        # 计算从隐含层后出现的信号，经过sigmoid函数
        hidden_outputs = self.activation_function(hidden_inputs)

        # 计算信号到最终的输出层
        final_inputs = np.dot(self.who,hidden_outputs)

        # 计算从最终输出层出现的信号
        final_outputs = self.activation_function(final_inputs)

        return  final_outputs

# 输入层、隐藏层和输出层节点的数量
input_nodes = 784 # 28×28的结果，即组成手写数字图像的像素个数
hidden_nodes = 100
'''选择使用100个隐藏层节点并不是通过使用科学的方法得到的。我们认为，神经网络应该可以发现在输入中的特征或模式，
这些模式或特征可以使用比输入本身更简短的形式表达，因此没有选择比784大的数字。通过选择使用比输入节点的数量小的值，
强制网络尝试总结输入的主要特点。但是，如果选择太少的隐藏层节点，那么就限制了网络的能力，使网络难以找到足够的
特征或模式，也就会剥夺神经网络表达其对MNIST数据理解的能力。给定的输出层需要10个标签，对应于10个输出层节点，
因此，选择100这个中间值作为中间隐藏层的节点数量，似乎有点道理。
这里应该强调一点。对于一个问题，应该选择多少个隐藏层节点，并不存在一个最佳方法。同时，我们也没有最佳方法选择
需要几层隐藏层。就目前而言，最好的办法是进行实验，直到找到适合你要解决的问题的一个数字。'''
output_nodes = 10
learning_rate = 0.1 # 学习率

# 创建神经网络实例
n = neuralNetwork(input_nodes,hidden_nodes,output_nodes,learning_rate)


# 将mnist数据集的CSV文件加载到列表中
training_data_file = open("mnist_dataset_full/mnist_train.csv",'r')
training_data_list = training_data_file.readlines()
training_data_file.close()

# epochs是训练数据集用于训练的次数
epochs = 5

# 训练神经网络
for e in range(epochs):
    # 检查训练数据集中的所有记录
    for record in training_data_list:
        all_values = record.split(',') # 逗号分割列表中的数据

        # 将输入数据进行归一化处理
        # 将输入颜色值从0到255，缩放至0.01 到 1.0。然后，需要将所得到的输入乘以0.99，
        # 把它们的范围变成0.0 到0.99。接下来，加上0.01，将这些值整体偏移到所需的范围0.01到1.00。
        inputs = (np.asfarray(all_values[1:]) / 255.0*0.99) + 0.01

        # 创建目标的输出值(都是0.01，除了所需的标签为0.99，即正确标签)
        targets = np.zeros(output_nodes) + 0.01
        # all_values[0]表示正确的目标标签
        targets[int(all_values[0])] = 0.99
        n.train(inputs,targets)



# 将mnist测试数据CSV文件加载到列表中
test_data_file = open("mnist_dataset_full/mnist_test.csv",'r')
test_data_list = test_data_file.readlines()
test_data_file.close()

# 测试神经网络
# 建一个计分器，如若正确的标签和预测的输出值一样，为1，否则为0
scorecard = []
for record in test_data_list:
    all_values = record.split(',')
    correct_label = int(all_values[0]) # 正确的标签值是每组数据的第一个数
    inputs = (np.asfarray(all_values[1:]) / 255.0 * 0.99) + 0.01
    outputs = n.query(inputs)
    label = np.argmax(outputs) # 输出值中最大值的索引对应当前预测的标签值
    if (label == correct_label):
        scorecard.append(1)
    else:
        scorecard.append(0)

# 计算模型的得分情况
# np.array （默认情况下）将会copy该对象，而 np.asarray 除非必要，否则不会copy该对象
scorecard_array = np.asarray(scorecard)
print("performance：{}".format(scorecard_array.sum() / scorecard_array.size))
 
输出：
 
 
 
 
书中也给出了①如何识别自己的手写数字，将图像改为28*28像素，具体操作见书上P190
 ②神经网络也可以通过标签值，生成一个手写数字的图像P194
 

人工神经网络是一种经典的机器学习模型，随着深度学习的发展神经网络模型日益完善.
 
联想大家熟悉的回归问题， 神经网络模型实际上是根据训练样本创造出一个多维输入多维输出的函数， 并使用该函数进行预测， 网络的训练过程即为调节该函数参数提高预测精度的过程.神经网络要解决的问题与最小二乘法回归解决的问题并无根本性区别.
 
回归和分类是常用神经网络处理的两类问题， 如果你已经了解了神经网络的工作原理可以在http://playground.tensorflow.org/上体验一个浅层神经网络的工作过程.
 
感知机(Perceptron)是一个简单的线性二分类器， 它保存着输入权重， 根据输入和内置的函数计算输出.人工神经网络中的单个神经元即是感知机.
 
在前馈神经网络的预测过程中， 数据流从输入到输出单向流动， 不存在循环和返回的通道.
 
目前大多数神经网络模型都属于前馈神经网络， 在下文中我们将详细讨论前馈过程.
 
多层感知机(Multi Layer Perceptron， MLP)是由多个感知机层全连接组成的前馈神经网络， 这种模型在非线性问题中表现出色.
 
所谓全连接是指层A上任一神经元与临近层B上的任意神经元之间都存在连接.
 
反向传播(Back Propagation，BP)是误差反向传播的简称，这是一种用来训练人工神经网络的常见算法， 通常与最优化方法(如梯度下降法)结合使用.
 
本文介绍的神经网络模型在结构上属于MLP， 因为采用BP算法进行训练， 人们也称其为BP神经网络.
 
BP神经网络原理
 
经典的BP神经网络通常由三层组成: 输入层， 隐含层与输出层.通常输入层神经元的个数与特征数相关，输出层的个数与类别数相同， 隐含层的层数与神经元数均可以自定义.
 
 
每个神经元代表对数据的一次处理:
 
 
每个隐含层和输出层神经元输出与输入的函数关系为:
 
 

 
  
   Ij=∑iWijOi
  
 
 
 

 
  
   Oj=sigmod(Il)=11+e−Il
  
 
 
其中
   
    Wij
   
 
表示神经元i与神经元j之间连接的权重，

  
   Oj
   
代表神经元j的输出， sigmod是一个特殊的函数用于将任意实数映射到(0，1)区间.
 
上文中的sigmod函数称为神经元的激励函数(activation function)， 除了sigmod函数
   
    11+e−Il
   
 
外， 常用还有tanh和ReLU函数.
 
我们用一个完成训练的神经网络处理回归问题， 每个样本拥有n个输入.相应地，神经网络拥有n个输入神经元和1个输出神经元.
 
实际应用中我们通常在输入层额外增加一个偏置神经元， 提供一个可控的输入修正;或者为每个隐含层神经元设置一个偏置参数.
 
我们将n个特征依次送入输入神经元， 隐含层神经元获得输入层的输出并计算自己输出值， 输出层的神经元根据隐含层输出计算出回归值.
 
上述过程一般称为前馈(Feed-Forward)过程， 该过程中神经网络的输入输出与多维函数无异.
 
现在我们的问题是如何训练这个神经网络.
 
作为监督学习算法，BP神经网络的训练过程即是根据前馈得到的预测值和参考值比较， 根据误差调整连接权重
   
    Wij
   
 
的过程.
 
训练过程称为反向传播过程(BackPropagation)， 数据流正好与前馈过程相反.
 
首先我们随机初始化连接权重
   
    Wij
   
 
， 对某一训练样本进行一次前馈过程得到各神经元的输出.
 
首先计算输出层的误差:
 
 

 
  
   Ej=sigmod′(Oj)∗(Tj−Oj)=Oj(1−Oj)(Tj−Oj)
  
 
 
其中
   
    Ej
   
 
代表神经元j的误差，

  
   Oj
  
表示神经元j的输出， 

  
   Tj
  
表示当前训练样本的参考输出， 

  
   sigmod′(x)
   
是上文sigmod函数的一阶导数.
 
计算隐含层误差:
 
 

 
  
   Ej=sigmod′(Oj)∗∑kEkWjk=Oj(1−Oj)∑kEkWjk
  
 
 
隐含层输出不存在参考值， 使用下一层误差的加权和代替
   
    (Tj−Oj)
   
 
.
 
计算完误差后就可以更新
   
    Wij
   
 
和

  
   θj
   
:
 
 

 
  
   Wij=Wij+λEjOi
  
 
 
其中
   
    λ
   
 
是一个称为学习率的参数，一般在(0，0.1)区间上取值.
 
实际上为了加快学习的效率我们引入称为矫正矩阵的机制， 矫正矩阵记录上一次反向传播过程中的
   
    EjOi
   
 
值， 这样

  
   Wj
   
更新公式变为:
 
 

 
  
   Wij=Wij+λEjOi+μCij
  
 
 

   
    μ
   
 
是一个称为矫正率的参数.随后更新矫正矩阵:
 
 

 
  
   Cij=EjOi
  
 
 
每一个训练样本都会更新一次整个网络的参数.我们需要额外设置训练终止的条件.
 
最简单的训练终止条件为设置最大迭代次数， 如将数据集迭代1000次后终止训练.
 
单纯的设置最大迭代次数不能保证训练结果的精确度， 更好的办法是使用损失函数(loss function)作为终止训练的依据.
 
损失函数可以选用输出层各节点的方差:
 
 

 
  
   L=∑j(Tj−Oj)2
  
 
 
为了避免神经网络进行无意义的迭代， 我们通常在训练数据集中抽出一部分用作校验.当预测误差高于阈值时提前终止训练.
 
Python实现BP神经网络
 
首先实现几个工具函数:
 
def rand(a， b):
    return (b - a) * random.random() + a


def make_matrix(m， n， fill=0.0):  # 创造一个指定大小的矩阵
    mat = []
    for i in range(m):
        mat.append([fill] * n)
    return mat
 
定义sigmod函数和它的导数:
 
def sigmoid(x):
    return 1.0 / (1.0 + math.exp(-x))


def sigmod_derivate(x):
    return x * (1 - x)
 
定义BPNeuralNetwork类， 使用三个列表维护输入层，隐含层和输出层神经元， 列表中的元素代表对应神经元当前的输出值.使用两个二维列表以邻接矩阵的形式维护输入层与隐含层， 隐含层与输出层之间的连接权值， 通过同样的形式保存矫正矩阵.
 
定义setup方法初始化神经网络:
 
def setup(self， ni， nh， no):
    self.input_n = ni + 1
    self.hidden_n = nh
    self.output_n = no
    # init cells
    self.input_cells = [1.0] * self.input_n
    self.hidden_cells = [1.0] * self.hidden_n
    self.output_cells = [1.0] * self.output_n
    # init weights
    self.input_weights = make_matrix(self.input_n， self.hidden_n)
    self.output_weights = make_matrix(self.hidden_n， self.output_n)
    # random activate
    for i in range(self.input_n):
        for h in range(self.hidden_n):
            self.input_weights[i][h] = rand(-0.2， 0.2)
    for h in range(self.hidden_n):
        for o in range(self.output_n):
            self.output_weights[h][o] = rand(-2.0， 2.0)
    # init correction matrix
    self.input_correction = make_matrix(self.input_n， self.hidden_n)
    self.output_correction = make_matrix(self.hidden_n， self.output_n)
 
定义predict方法进行一次前馈， 并返回输出:
 
def predict(self， inputs):
    # activate input layer
    for i in range(self.input_n - 1):
        self.input_cells[i] = inputs[i]
    # activate hidden layer
    for j in range(self.hidden_n):
        total = 0.0
        for i in range(self.input_n):
            total += self.input_cells[i] * self.input_weights[i][j]
        self.hidden_cells[j] = sigmoid(total)
    # activate output layer
    for k in range(self.output_n):
        total = 0.0
        for j in range(self.hidden_n):
            total += self.hidden_cells[j] * self.output_weights[j][k]
        self.output_cells[k] = sigmoid(total)
    return self.output_cells[:]
 
定义back_propagate方法定义一次反向传播和更新权值的过程， 并返回最终预测误差:
 
def back_propagate(self， case， label， learn， correct):
    # feed forward
    self.predict(case)
    # get output layer error
    output_deltas = [0.0] * self.output_n
    for o in range(self.output_n):
        error = label[o] - self.output_cells[o]
        output_deltas[o] = sigmod_derivate(self.output_cells[o]) * error
    # get hidden layer error
    hidden_deltas = [0.0] * self.hidden_n
    for h in range(self.hidden_n):
        error = 0.0
        for o in range(self.output_n):
            error += output_deltas[o] * self.output_weights[h][o]
        hidden_deltas[h] = sigmod_derivate(self.hidden_cells[h]) * error
    # update output weights
    for h in range(self.hidden_n):
        for o in range(self.output_n):
            change = output_deltas[o] * self.hidden_cells[h]
            self.output_weights[h][o] += learn * change + correct * self.output_correction[h][o]
            self.output_correction[h][o] = change
    # update input weights
    for i in range(self.input_n):
        for h in range(self.hidden_n):
            change = hidden_deltas[h] * self.input_cells[i]
            self.input_weights[i][h] += learn * change + correct * self.input_correction[i][h]
            self.input_correction[i][h] = change
    # get global error
    error = 0.0
    for o in range(len(label)):
        error += 0.5 * (label[o] - self.output_cells[o]) ** 2
    return error
 
定义train方法控制迭代， 该方法可以修改最大迭代次数， 学习率
   
    λ
   
 
， 矫正率

  
   μ
   
三个参数.
 
def train(self， cases， labels， limit=10000， learn=0.05， correct=0.1):
    for i in range(limit):
        error = 0.0
        for i in range(len(cases)):
            label = labels[i]
            case = cases[i]
            error += self.back_propagate(case， label， learn， correct)
 
编写test方法，演示如何使用神经网络学习异或逻辑:
 
def test(self):
    cases = [
            [0， 0]，
            [0， 1]，
            [1， 0]，
            [1， 1]，
        ]
    labels = [[0]， [1]， [1]， [0]]
    self.setup(2， 5， 1)
    self.train(cases， labels， 10000， 0.05， 0.1)
    for case in cases:
        print(self.predict(case))
 
完整源代码参见bpnn.py

matlab下编写bp神经网络实现手写数字识别（含图片及代码）
 
本文参考链接https://blog.csdn.net/huang_miao_xin/article/details/51364152。修改了其中部分代码，可以完美运行。
 代码主要包括以下五个部分。
 
一、神经网络初始化
 
V=double(rand(256,64));
W=double(rand(64,10));
delta_V=double(rand(256,64));
delta_W=double(rand(64,10));
% lf=0;用来看错误在哪一步的参考数据
yita=0.2;%缩放系数，有的文章称学习率
yita1=0.05;%我自己加的参数，缩放激活函数的自变量防止输入过大进入函数的饱和区，可以去掉体会一下变化
train_number=10;%训练样本中，有多少个数字，一共9个，没有0
train_num=400;%训练样本中，每种数字多少张图，一共100张
x=double(zeros(1,256));%输入层
y=double(zeros(1,64));%中间层，也是隐藏层
output=double(zeros(1,10));%输出层
tar_output=double(zeros(1,10));%目标输出，即理想输出
delta=double(zeros(1,10));%一个中间变量，可以不管
%记录总的均方差便于画图
s_record=1:400;
 
二、读入图片
 
tic %计时
for train_control_num=1:400   %训练次数控制，在调参的最后发现1000次其实有多了，大概400次完全够了
    s=0;
%读图，输入网络
for number=1:train_number %train_number=10
ReadDir=['D:\contrl\BP\BP\training\',num2str(number-1)];%读取样本的路径
for num=1:train_num  %控制多少张  train_num=30
photo_name=['\a (',num2str(num),').png'];%图片名
photo_index=[ReadDir,photo_name];%路径加图片名得到总的图片索引
photo_matrix=imread(photo_index);%使用imread得到图像矩阵
photo_matrix=imresize(photo_matrix,[16,16]);
photo_matrix=uint8(photo_matrix>=30);%二值化，黑色是1

tmp=photo_matrix';
tmp=tmp(:);%以上两步完成了图像二维矩阵转变为列向量，256维，作为输入  就是把矩阵的元素按列的顺序变为一列，矩阵转化为向量
 
三、前向计算
 
%计算输入层输入
x=double(tmp');%转化为行向量因为输入层X是行向量，并且化为浮点数
%得到隐层输入
y0=x*V;
%激活
y=1./(1+exp(-y0*yita1));
%得到输出层输入
output0=y*W;
% lf=lf+1;之前用来看错误在哪一步的参考数据
output=1./(1+exp(-output0*yita1));
%计算预期输出
tar_output=double(zeros(1,10));
tar_output(number)=1.0;
 
四、反向传播
 
%计算误差
%按照公式计算W和V的调整，为了避免使用for循环比较耗费时间，下面采用了直接矩阵乘法，更高效
delta=(tar_output-output).*output.*(1-output);%1*10
delta_W=yita*repmat(y',1,10).*repmat(delta,64,1);%64*10
tmp=sum((W.*repmat(delta,64,1))');
tmp=tmp.*y.*(1-y);
delta_V=yita*repmat(x',1,64).*repmat(tmp,256,1);
%计算均方差
s=s+sum((tar_output-output).*(tar_output-output))/10;
%更新权值
W=W+delta_W;
V=V+delta_V;
end
end
 
五、绘图，查看运行状态
 
s=s/train_number/train_num  %不加分号，随时输出误差观看收敛情况
train_control_num           %不加分号，随时输出迭代次数观看运行状态
s_record(train_control_num)=s;%记录
end
toc %计时结束
plot(1:400,s_record);
 
六、测试
 
correct_num=0;%记录正确的数量
incorrect_num=0;%记录错误数量
test_number=10;%测试集中，一共多少数字，9个，没有0
test_num=800;%测试集中，每个数字多少个，最大100个
% load W;%%之前训练得到的W保存了，可以直接加载进来
% load V;
% load yita1;

%记录时间
tic %计时开始
for number=1:test_number
number
ReadDir=['D:\contrl\BP\BP\training\',num2str(number-1)];
for num=1:test_num  %控制多少张
photo_name=['\a (',num2str(num),').png'];
photo_index=[ReadDir, photo_name];
photo_matrix=imread(photo_index);
%大小改变
photo_matrix=imresize(photo_matrix,[16 16]);
%二值化
photo_matrix=uint8(photo_matrix>=30);%黑色是1
%行向量
tmp=photo_matrix';
tmp=tmp(:);
%计算输入层输入
x=double(tmp');
%得到隐层输入
y0=x*V;
%激活
y=1./(1+exp(-y0*yita1));
%得到输出层输入
o0=y*W;
tar_output=double(zeros(1,10));
tar_output(number)=1.0;
o=1./(1+exp(-o0*yita1));

%最大的输出即是识别到的数字
output=double(zeros(1,10));


[o,index]=sort(o);
p=index(10);
output(p)=1.0;
if p==number
    correct_num=correct_num+1;
else
    incorrect_num=incorrect_num+1;

    %显示不成功的数字，显示会比较花时间
%     figure(incorrect_num)
%     imshow((1-photo_matrix)*255);
%     title(num2str(number));

end

end

end
plotconfusion(tar_output,output);

correct_rate=correct_num/test_number/test_num;
toc %计时结束
 
手写数字图片资源已上传至csdn，码字不易，希望能给些积分，谢大佬们！！！
 https://download.csdn.net/download/qu_learner/12527007