A. BP神经网络的训练集需要大样本吗一般样本个数为多少
BP神经网络的训练集需要大样本吗？一般样本个数为多少？
BP神经网络样本数有什么影响
学习神经网络这段时间，有一个疑问，BP神经网络中训练的次数指的网络的迭代次数，如果有a个样本,每个样本训练次数n，则网络一共迭代an次，在n>>a 情况下 ， 网络在不停的调整权值，减小误差，跟样本数似乎关系不大。而且，a大了的话训练时间必然会变长。
换一种说法，将你的数据集看成一个固定值， 那么样本集与测试集 也可以按照某种规格确定下来如7：3 所以如何看待 样本集的多少与训练结果呢？ 或者说怎么使你的网络更加稳定，更加符合你的所需 。
我尝试从之前的一个例子中看下区别
如何用70行Java代码实现深度神经网络算法
作者其实是实现了一个BP神经网络 ，不多说，看最后的例子
一个运用神经网络的例子
最后我们找个简单例子来看看神经网络神奇的效果。为了方便观察数据分布，我们选用一个二维坐标的数据，下面共有4个数据，方块代表数据的类型为1，三角代表数据的类型为0，可以看到属于方块类型的数据有（1，2）和（2，1），属于三角类型的数据有（1，1），（2，2），现在问题是需要在平面上将4个数据分成1和0两类，并以此来预测新的数据的类型。
图片描述
我们可以运用逻辑回归算法来解决上面的分类问题，但是逻辑回归得到一个线性的直线做为分界线，可以看到上面的红线无论怎么摆放，总是有一个样本被错误地划分到不同类型中，所以对于上面的数据，仅仅一条直线不能很正确地划分他们的分类，如果我们运用神经网络算法，可以得到下图的分类效果，相当于多条直线求并集来划分空间，这样准确性更高。
图片描述
简单粗暴，用作者的代码运行后 训练5000次 。根据训练结果来预测一条新数据的分类（3,1）
预测值 （3,1）的结果跟（1,2）（2,1）属于一类 属于正方形
这时如果我们去掉 2个样本，则样本输入变成如下
//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1}};
1
2
3
4
1
2
3
4
则（3,1）结果变成了三角形，
如果你选前两个点 你会发现直接一条中间线就可以区分 这时候的你的结果跟之前4个点时有区别 so 你得增加样本 直到这些样本按照你所想要的方式分类 ，所以样本的多少 重要性体现在，样本得能反映所有的特征值（也就是输入值） ，样本多少或者特征（本例子指点的位置特征）决定的你的网络的训练结果，！！！这是 我们反推出来的结果 。这里距离深度学习好像近了一步。
另外，这个70行代码的神经网络没有保存你训练的网络 ，所以你每次运行都是重新训练的网络。其实，在你训练过后 权值已经确定了下来，我们确定网络也就是根据权值，so只要把训练后的权值保存下来，将需要分类的数据按照这种权值带入网络，即可得到输出值，也就是一旦网络确定， 权值也就确定，一个输入对应一个固定的输出，不会再次改变！个人见解。
最后附上作者的源码，作者的文章见开头链接
下面的实现程序BpDeep.java可以直接拿去使用，
import java.util.Random;
public class BpDeep{
public double[][] layer;//神经网络各层节点
public double[][] layerErr;//神经网络各节点误差
public double[][][] layer_weight;//各层节点权重
public double[][][] layer_weight_delta;//各层节点权重动量
public double mobp;//动量系数
public double rate;//学习系数
public BpDeep(int[] layernum, double rate, double mobp){
this.mobp = mobp;
this.rate = rate;
layer = new double[layernum.length][];
layerErr = new double[layernum.length][];
layer_weight = new double[layernum.length][][];
layer_weight_delta = new double[layernum.length][][];
Random random = new Random();
for(int l=0;l<layernum.length;l++){
layer[l]=new double[layernum[l]];
layerErr[l]=new double[layernum[l]];
if(l+1<layernum.length){
layer_weight[l]=new double[layernum[l]+1][layernum[l+1]];
layer_weight_delta[l]=new double[layernum[l]+1][layernum[l+1]];
for(int j=0;j<layernum[l]+1;j++)
for(int i=0;i<layernum[l+1];i++)
layer_weight[l][j][i]=random.nextDouble();//随机初始化权重
}
}
}
//逐层向前计算输出
public double[] computeOut(double[] in){
for(int l=1;l<layer.length;l++){
for(int j=0;j<layer[l].length;j++){
double z=layer_weight[l-1][layer[l-1].length][j];
for(int i=0;i<layer[l-1].length;i++){
layer[l-1][i]=l==1?in[i]:layer[l-1][i];
z+=layer_weight[l-1][i][j]*layer[l-1][i];
}
layer[l][j]=1/(1+Math.exp(-z));
}
}
return layer[layer.length-1];
}
//逐层反向计算误差并修改权重
public void updateWeight(double[] tar){
int l=layer.length-1;
for(int j=0;j<layerErr[l].length;j++)
layerErr[l][j]=layer[l][j]*(1-layer[l][j])*(tar[j]-layer[l][j]);
while(l-->0){
for(int j=0;j<layerErr[l].length;j++){
double z = 0.0;
for(int i=0;i<layerErr[l+1].length;i++){
z=z+l>0?layerErr[l+1][i]*layer_weight[l][j][i]:0;
layer_weight_delta[l][j][i]= mobp*layer_weight_delta[l][j][i]+rate*layerErr[l+1][i]*layer[l][j];//隐含层动量调整
layer_weight[l][j][i]+=layer_weight_delta[l][j][i];//隐含层权重调整
if(j==layerErr[l].length-1){
layer_weight_delta[l][j+1][i]= mobp*layer_weight_delta[l][j+1][i]+rate*layerErr[l+1][i];//截距动量调整
layer_weight[l][j+1][i]+=layer_weight_delta[l][j+1][i];//截距权重调整
}
}
layerErr[l][j]=z*layer[l][j]*(1-layer[l][j]);//记录误差
}
}
}
public void train(double[] in, double[] tar){
double[] out = computeOut(in);
updateWeight(tar);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
下面是这个测试程序BpDeepTest.java的源码：
import java.util.Arrays;
public class BpDeepTest{
public static void main(String[] args){
//初始化神经网络的基本配置
//第一个参数是一个整型数组，表示神经网络的层数和每层节点数，比如{3,10,10,10,10,2}表示输入层是3个节点，输出层是2个节点，中间有4层隐含层，每层10个节点
//第二个参数是学习步长，第三个参数是动量系数
BpDeep bp = new BpDeep(new int[]{2,10,2}, 0.15, 0.8);
//设置样本数据，对应上面的4个二维坐标数据
double[][] data = new double[][]{{1,2},{2,2},{1,1},{2,1}};
//设置目标数据，对应4个坐标数据的分类
double[][] target = new double[][]{{1,0},{0,1},{0,1},{1,0}};
//迭代训练5000次
for(int n=0;n<5000;n++)
for(int i=0;i<data.length;i++)
bp.train(data[i], target[i]);
//根据训练结果来检验样本数据
for(int j=0;j<data.length;j++){
double[] result = bp.computeOut(data[j]);
System.out.println(Arrays.toString(data[j])+":"+Arrays.toString(result));
}
//根据训练结果来预测一条新数据的分类
double[] x = new double[]{3,1};
double[] result = bp.computeOut(x);
System.out.println(Arrays.toString(x)+":"+Arrays.toString(result));
}
}
B. 神经网络对输入变量个数有没有要求，六十个可以吗
可以，但是网络规模太大，很臃肿，需要调整的参数过多，影响收敛速度。
关于隐层节点数：在BP 网络中，隐层节点数的选择非常重要，它不仅对建立的神经网络模型的性能影响很大，而且是训练时出现“过拟合”的直接原因，但是目前理论上还没有一种科学的和普遍的确定方法。 目前多数文献中提出的确定隐层节点数的计算公式都是针对训练样本任意多的情况，而且多数是针对最不利的情况，一般工程实践中很难满足，不宜采用。事实上，各种计算公式得到的隐层节点数有时相差几倍甚至上百倍。为尽可能避免训练时出现“过拟合”现象，保证足够高的网络性能和泛化能力，确定隐层节点数的最基本原则是：在满足精度要求的前提下取尽可能紧凑的结构，即取尽可能少的隐层节点数。研究表明，隐层节点数不仅与输入/输出层的节点数有关，更与需解决的问题的复杂程度和转换函数的型式以及样本数据的特性等因素有关。
在确定隐层节点数时必须满足下列条件：
（1）隐层节点数必须小于N-1（其中N为训练样本数），否则，网络模型的系统误差与训练样本的特性无关而趋于零，即建立的网络模型没有泛化能力，也没有任何实用价值。同理可推得：输入层的节点数（变量数）必须小于N-1。
(2) 训练样本数必须多于网络模型的连接权数，一般为2~10倍，否则，样本必须分成几部分并采用“轮流训练”的方法才可能得到可靠的神经网络模型。
总之，若隐层节点数太少，网络可能根本不能训练或网络性能很差；若隐层节点数太多，虽然可使网络的系统误差减小，但一方面使网络训练时间延长，另一方面，训练容易陷入局部极小点而得不到最优点，也是训练时出现“过拟合”的内在原因。因此，合理隐层节点数应在综合考虑网络结构复杂程度和误差大小的情况下用节点删除法和扩张法确定。
C. 神经网络神经元个数的确定
当训练集确定之后，输入层结点数和输出层结点数随之而确定，首先遇到的一个十分重要而又困难的问题是如何优化隐层结点数和隐层数。实验表明，如果隐层结点数过少，网络不能具有必要的学习能力和信息处理能力。反之，若过多，不仅会大大增加网络结构的复杂性（这一点对硬件实现的网络尤其重要），网络在学习过程中更易陷入局部极小点，而且会使网络的学习速度变得很慢。隐层结点数的选择问题一直受到神经网络研究工作者的高度重视。
方法1：
fangfaGorman指出隐层结点数s与模式数N的关系是：s＝log2N；
方法二：
Kolmogorov定理表明，隐层结点数s＝2n＋1（n为输入层结点数）；
方法三：
s＝sqrt（0.43mn＋0.12nn＋2.54m＋0.77n＋0.35）＋0.51
（m是输入层的个数，n是输出层的个数）。
D. OPENNN如何加快神经网络训练速度（54个输入，100个隐层，1个输出）
开头注释：针对这些问题，都是在tensorflow框架下，去寻找代码解决问题的。所以非tensorflow框架下编程的，可以看看出现该类问题的原因，以及解决问题的方向，具体的解决问题的代码需要自行查阅资料。
情况1：训练速度慢
针对实体链接任务，搭建了Bi-LSTM+CNN的模型，目前训练速度很慢，半个小时才出一个批次的预测结果。
类比于手写数字识别，无论是使用LSTM，还是CNN，都不会很慢，最慢的至少在10分钟内能出每一个批次的预测结果。
E. matlab 神经网络一直训练不好。
归一化：使用Matlab自带的mapminmax函数。
mapminmax按行逐行地对数据进行标准化处理，将每一行数据分别标准化到区间[ymin, ymax]内，其计算公式是：y = (ymax-ymin)*(x-xmin)/(xmax-xmin) + ymin。如果某行的数据全部相同，此时xmax=xmin，除数为0，则Matlab内部将此变换变为y = ymin。
(1) [Y,PS] = mapminmax(X,YMIN,YMAX)——将数据X归一化到区间[YMIN,YMAX]内，YMIN和YMAX为调用mapminmax函数时设置的参数，如果不设置这两个参数，这默认归一化到区间[-1, 1]内。标准化处理后的数据为Y，PS为记录标准化映射的结构体。
【例1】Matlab命令窗口输入：X=12+8*randn(6,8); [Y,PS] = mapminmax(X,0,1)，则将随机数矩阵X按行逐行标准化到区间[0,1]内，并返回标准矩阵Y和结构体PS（至于它的作用，将在后面介绍到），它记录了X的行数、X中各行的最大值与最小值等信息。这里：
PS =
name: 'mapminmax'
xrows: 6
xmax: [6x1 double]
xmin: [6x1 double]
xrange: [6x1 double]
yrows: 6
ymax: 1
ymin: 0
yrange: 1
no_change: 0
gain: [6x1 double]
xoffset: [6x1 double]
(2) [Y,PS] = mapminmax(X,FP) ——将YMIN和YMAX组成的结构体FP作为映射参数(FP.ymin和FP.ymax.)对进行标准化处理。
【例2】Matlab命令窗口输入：XX=12+8*randn(6,8); FP.ymin=-2; FP.ymax=2; [YY,PSS] = mapminmax(XX,FP)，则将随机数矩阵X按行逐行标准化到区间[-2,2]内，并返回标准矩阵YY和结构体PSS。
(3) Y = mapminmax('apply',X,PS) ——根据已有给定的数据标准化处理映射PS，将给定的数据X标准化为Y。
【例3】在例1的基础上，Matlab命令窗口输入：XXX=23+11*randn(6,8); YYY= mapminmax('apply',XXX,PS)，则根据例1的标准化映射，将XXX标准化（结果可能不全在先前设置的[YMIN,YMAX]内，这取决于XXX中数据相对于X中数据的最大值与最小值的比较情况）。注意：此时，XXX的行数必须与X的行数（PS中已记录）相等，否则无法进行；列数可不等。
(4) X = mapminmax('reverse',Y,PS) ——根据已有给定的数据标准化处理映射PS，将给定的标准化数据Y反标准化。
【例4】在例1的基础上，Matlab命令窗口输入：YYYY=rand(6,8); XXXX = mapminmax('reverse', YYYY,PS)，则根据例1的标准化映射，将YYYY反标准化。注意：此时，YYYY的行数必须与X的行数（PS中已记录）相等，否则无法进行；列数可不等。
(5) dx_dy = mapminmax('dx_dy',X,Y,PS) ——根据给定的矩阵X、标准化矩阵Y及映射PS，获取逆向导数(reverse derivative)。如果给定的X和Y是m行n列的矩阵，那么其结果dx_dy是一个1×n结构体数组，其每个元素又是一个m×n的对角矩阵。这种用法不常用，这里不再举例。
对于另一个问题：使用sim函数来得到输出，一般来说会有误差，不可能与预计输出完全相等的。
F. 利用pytorch CNN手写字母识别神经网络模型识别多手写字母（A-Z）
往期的文章，我们分享了手写字母的训练与识别
使用EMNIST数据集训练第一个pytorch CNN手写字母识别神经网络
利用pytorch CNN手写字母识别神经网络模型识别手写字母
哪里的文章，我们只是分享了单个字母的识别，如何进行多个字母的识别，其思路与多数字识别类似，首先对图片进行识别，并进行每个字母的轮廓识别，然后进行字母的识别，识别完成后，直接在图片上进行多个字母识别结果的备注
Pytorch利用CNN卷积神经网络进行多数字（0-9）识别
根据上期文章的分享，我们搭建一个手写字母识别的神经网络
第一层，我们输入Eminist的数据集，Eminist的数据图片是一维 28*28的图片，所以第一层的输入（1，28，28），高度为1，设置输出16通道，使用5*5的卷积核对图片进行卷积运算，每步移动一格，为了避免图片尺寸变化，设置pading为2，则经过第一层卷积就输出（16，28，28）数据格式
再经过relu与maxpooling （使用2*2卷积核）数据输出（16，14，14）
第二层卷积层是简化写法nn.Conv2d(16, 32, 5, 1, 2)的第一个参数为输入通道数in_channels=16，其第二个参数是输出通道数out_channels=32, # n_filters（输出通道数），第三个参数为卷积核大小，第四个参数为卷积步数，最后一个为pading,此参数为保证输入输出图片的尺寸大小一致
全连接层，最后使用nn.linear()全连接层进行数据的全连接数据结构（32*7*7,37）以上便是整个卷积神经网络的结构，
大致为：input-卷积-Relu-pooling-卷积
-Relu-pooling-linear-output
卷积神经网络建完后，使用forward（）前向传播神经网络进行输入图片的识别
这里我们使用腐蚀，膨胀操作对图片进行一下预处理操作，方便神经网络的识别，当然，我们往期的字母数字识别也可以添加此预处理操作，方便神经网络进行预测，提高精度
getContours函数主要是进行图片中数字区域的区分，把每个数字的坐标检测出来，这样就可以 把每个字母进行CNN卷积神经网络的识别，进而实现多个字母识别的目的
首先，输入一张需要检测的图片，通过preProccessing图片预处理与getContours函数获取图片中的每个字母的轮廓位置
transforms.Compose此函数可以 把输入图片进行pytorch相关的图片操作，包括转换到torch，灰度空间转换，resize，缩放等等操作
然后加载我们前期训练好的模型
由于神经网络识别完成后，反馈给程序的是字母的 UTF-8编码，我们通过查表来找到对应的字母
字符编码表（UTF-8）
通过上面的操作，我们已经识别出了图片中包括的字母轮廓，我们遍历每个字母轮廓，获取单个字母图片数据，这里需要特殊提醒一下 ：我们知道EMNIST数据库左右翻转图片后，又进行了图片的逆时针旋转90度
这里我们使用cv2.flip(imgRes,1)函数，进行图片的镜像，并使用getRotationMatrix2D函数与warpAffine函数配合来进行图片的旋转操作，这里就没有PIL来的方便些
然后，我们对图片数据进行torch转换train_transform(imgRes)，并传递给神经网络进行识别
待识别完成后，就可以把结果备注在原始图片上
G. BP神经网络做手写数字识别误差较大
CNN卷积神经网络是一种深度模型。它其实老早就已经可以成功训练并且应用了（最近可能deep learning太火了，CNNs也往这里面靠。虽然CNNs也属于多层神经网络架构，但把它置身于DL家族，还是有不少人保留自己的理解的）。
H. 全连接神经网络参数个数怎么计算
对n-1层和n层而言
n-1层的任意一个节点，都和第n层所有节点有连接。即第n层的每个节点在进行计算的时候，激活函数的输入是n-1层所有节点的加权。
全连接是一种不错的模式，但是网络很大的时候，训练速度回很慢。部分连接就是认为的切断某两个节点直接的连接，这样训练时计算量大大减小
I. BP神经网络进行数字识别训练过程的原理
这段程序的流程就是1.随机产生一些带噪声的样本；2.用这些样本对神经网络进行训练；3.训练完成。训练好的网络就具有了数字识别的功能，你用一个带噪声的样本去检验它，其输出就是识别结果。给你提供一个车牌智能识别的matlab代码，你可以参考一下。