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代碼，你可以參考一下。