『壹』 BP紲炵粡緗戠粶鐨勬瘡涓涓鏍鋒湰鍙浠ユ槸涓涓鐭╅樀鍚楋紵濡備綍杈撳叆錛熻阿璋錛
姣忎釜鏍鋒湰瀵瑰簲涓緇勫彉閲忓礆紝浣嗘槸BP紲炵粡緗戠粶浣跨敤鏃朵竴鑸涓嶄嬌鐢1涓鏍鋒湰鍘昏緇冿紝閮芥槸浣跨敤鑻ュ共緇勬牱鏈錛岃繖鏍蜂粬鐨勮嫢騫茬粍鏍鋒湰灝辨槸鐭╅樀浜嗐
鐩存帴瀹氫箟
P=[
1 2 1 3;%榪欐槸涓緇勬牱鏈
1 2 1 4;%榪欐槸絎浜岀粍鏍鋒湰
...
];
榪欐牱灝卞畾涔変簡杈撳叆鐭╅樀銆
杈撳嚭鐭╅樀涔熸槸鍚屾牱鐨勫畾涔夈
杈撳叆鐭╅樀涓庤緭鍑虹煩闃電殑琛屾暟錛堟牱鏈涓鏁幫級蹇呴』涓鑷淬
net(....);
train(net....);
濡傛灉鎶ラ敊錛屽氨鎶奝鍜孴鍚屾椂杞緗錛圥=P';T=T';錛変竴涓嬨
『貳』 bp神經網路只有一類樣本怎麼分類
神經網路一列為一個樣本，所以對於matlab 而言，要求輸入和輸出的列數必須一樣的
經常有人問起的問題：
Error using ==> network/train
Targets are incorrectly sized for network.
Matrix must have 1 rows.
解決：要求P T 的列數一樣 ，如果不一樣 P=p』 t=t』 轉置一下
2.
歸一
澄清一個對歸一的錯誤理解1
樣本矩陣為9行4列。9組樣本，4個變數。現在歸一化：
x=[68.7 66.6 5610 19.2;
89.9 90.8 4500 11.8;
120.8 120.6 6800 20.6;
169 40.4 6160 40.6;
180.8 69.8 7330 33.4;
190.3 130.2 7320 31.6;
109.8 151.1 5754 86.1;
33.2 61.4 8255 22.6;
111.7 126.6 7040 13.6;]
寫法一：
for i=1:9
x1(i,:)=(x(i,:)-min(x(i,:)))/(max(x(i,:))-min(x(i,:)))
end
結果：
0.0089 0.0085 1.0000 0
0.0174 0.0176 1.0000 0
0.0148 0.0148 1.0000 0
0.0210 0 1.0000 0.0000
0.0202 0.0050 1.0000 0
0.0218 0.0135 1.00 00 0
0.0042 0.0115 1.0000 0
0.0013 0.0047 1.0000 0
0.0140 0.0161 1.0000 0
寫法二：
x=x'
for i=1:4
x1(i,:)=(x(i,:)-min(x(i,:)))/(max(x(i,:))-min(x(i,:)))
end
結果：
Columns 1 through 8
0.2260 0.3609 0.5576 0.8644 0.9395 1.0000 0.4876 0
0.2367 0.4553 0.7245 0 0.2656 0.8112 1.0000 0.1897
0.2956 0 0.6125 0.4421 0.7537 0.7510 0.3340 1.0000
0.0996 0 0.1184 0.3876 0.2907 0.2665 1.0000 0.1454
Column 9
0.4997
0.7787
0.6764
0.0242
注意：寫法2為正確的歸一化
對歸一的錯誤理解2
將數據集分為訓練集和測試集，對訓練集和測試集分別做歸一處理
所以就會有人問 如果我的測試集只有一個數據 如何歸一呀
最大最小值從那裡找呀
正確的理解是：
訓練集和測試集的歸一標準是一樣的
建議：
如果訓練集和測試集是一起歸一的 可以自己編程實現歸一
如果是訓練集和測試集是分開的，最好是使用matlab自帶的premnmx、postmnmx、tramnmx 函數
如果是自己編程的話 ，請注意訓練集和測試集的歸一標准需要一樣
premnmx、postmnmx、tramnmx 函數
的使用例子如下：
Example
Here is the code to normalize a given data set so
that the inputs and targets will fall in the
range [-1,1], using PREMNMX, and the code to train a network
with the normalized data.
p = [-10 -7.5 -5 -2.5 0 2.5 5 7.5 10];
t = [0 7.07 -10 -7.07 0 7.07 10 7.07 0];
[pn,minp,maxp,tn,mint,maxt] = premnmx(p,t);
net = newff(minmax(pn),[5 1],{'tansig' 'purelin'},'trainlm');
net = train(net,pn,tn);
If we then receive new inputs to apply to the trained
network, we will use TRAMNMX to transform them
first. Then the transformed inputs can be used
to simulate the previously trained network. The
network output must also be unnormalized using
POSTMNMX.
p2 = [4 -7];
[p2n] = tramnmx(p2,minp,maxp);
an = sim(net,pn);
[a] = postmnmx(an,mint,maxt);
這個是歸一到-1 和 1 之間 那我要歸一到0 1 之間怎麼辦
有人說可以使用加絕對值就歸一到 0 1之間了
我覺得加絕對值可能會有些問題
比較好的方式是變換
P 在-1 1 之間
Pp=(p+1)/2 就可以歸一到0 1之間
至於要歸一到0.1- 0.9 之間 選取合適的變換就可以做到了
二、神經網路(BP)系列(2)(初學者系列)每次結果不一樣解析
這個系列主要針對使用matlab 神經網路工具箱，對一些初學者容易理解錯誤的地方進行解析。
神經網路每次結果不同解析
神經網路每次結果不同是因為初始化的權值和閾值是隨機的
因為每次的結果不一樣，才有可能找到比較理想的結果啊
找到比較好的結果後，用命令save filename net;保存網路，
可使預測的結果不會變化，調用時用命令load filename net;
取p_test=[ ];
t_test=[ ];
t=sim(net,p_test);
err=t_test-t;
plot(p_test,err);
選擇誤差小的保存網路
save filename net
以後調用時
load filename net
p_test=[ ];
t_test=[ ];
t=sim(net,p_test);
err=t_test-t;
plot(p_test,err):
因為每次初始化網路時都是隨機的，而且訓練終止時的誤差也不完全相同，結果訓練後的權植和閥也不完全相同（大致是一樣的），所以每次訓練後的結果也略有不同
舉個例子，這樣初始化就能使網路的輸出結果是一樣的，另外也可以給網路特定的權值，一種方法是把預測結果後的效果比較好的權值做為初值
p=[0.8726 0.9441 0;0 0 0.7093;0.7378 0.7093 0.3795;0.6416 0.3795 0.7031;1 0.7031 0.4241;0.7774 0.4241 0.9559;0.9559 0.5012 0.7052;...
0.8209 0.7052 0.4983;0.6011 0.4983 1;]';
t=[0 0.7378 0.6416 1 0.7774 0.5012 0.8209 0.6011 0.9350];
rand('state',0);
net=newff(minmax(p),[6,1],{'tansig','logsig'},'trainlm');
net.trainParam.epochs=2000;
net.trainParam.goal=0.001;
net=train(net,p,t);
y=sim(net,p);
error=y-t;
res=norm(error);
p_test=[0.9350 1 0.6236;]';
t_test=[ 0.8027]
a=sim(net,p_test)
rand('state',0);
這個的作用是每次初始化一樣
0是種子數,如果換成其他數,就可以產生不同的隨機值
注: rand('state',0);的使用有點為結果相同而相同，至於這樣的結果網路性能是否達到好的要求則沒有考慮，建議還是不要用這種方法使每次結果相同
用保存網路的方法吧
消除初值影響可以考慮的另一個方法是簡單集成神經網路
原理
由於選擇不同的權值所得結果不同，使最終神經網路泛化能力體現出一定的隨機性。利用這個特性也可以改善神經網路的泛化能力，神經網路集成便是利用這種思路的體現，即先訓練一組只有初始權值不同的子網，然後通過各子網「表決（Voting）」 的形式（如加權和）得到學習系統的輸出。
當神經網路集成用於分類器時，集成的輸出通常由個體網路的輸出投票產生。通常利用絕對多數投票法（某分類成為最終結果當且僅當輸出結果為該分類的神經網路的數目最多）。理論分析和大量實驗表明，後者優於前者。因此，在對分類器進行集成時，目前大多採用相對多數投票法。
當神經網路集成用於回歸估計時，集成的輸出通常由各網路的輸出通過簡單平均或加權平均產生。Perrone等人認為，採用加權平均可以得到比簡單平均更好的泛化能力。
三、神經網路(BP)系列(3)(初學者請看)分類實例
分類實例
輸入輸出設計：
對某一問題分析，影響網路性能的輸入主要有5個指標，輸出則分為8類。8類的話可以用三位二進製表示。
0 0 0
0 0 1
0 1 0
0 1 1
1 0 0
1 0 1
1 1 0
1 1 1
神經網路的輸入為5維的向量，輸出為三維的向量。輸入的數據具有不同的單位和量級，所以在輸入在輸入神經網路之前應該首先進行歸一化處理，將樣本數據歸一到0 1之間。
樣本總共有328組數據
將樣本集分為訓練集和測試集
隨機抽取70取做為測試測試集
其餘的作為訓練集
網路設計
採用tansig(x)和logsig(x)函數作為傳輸函數，tansig(x)如下式：
tansig=2/(1+exp(-2x))-1
logsig(x) 如下式：
logsig(x) = 1 / (1 + exp(-n))
對於有限個輸入到輸出的映射，並不需要無限個隱層節點，這就涉及到如何選擇隱層節點數的問題，而這一問題的復雜性，使得至今為止尚未找到一個很好的解析 式，隱層節點數往往根據前人設計所得的經驗和自己進行試驗來確定。設計網路時我採用的方法是通過神經網路訓練來確定隱含層的個數，首先確定隱含層中節點數目的范圍，設計一個隱含層神經元數目可變的BP網路，通過誤差對比，確定最佳的隱含層神經元的個數。最後確定的隱含層的個數為12。所以網路結構為 5-12-3的三層結構。
load('CSHuju1.mat');
p=CC1(:,[1,3:6])';
T=[0 0 0;
1 1 1;
1 1 0;
1 0 1;
1 0 0;
0 1 1;
0 1 0;
0 0 1];
t=repmat(T,41,1)';
pp=p;
%%%%%%歸一到 0 1 之間
for i=1:5
p(i,:)=(p(i,:)-min(p(i,:)))/(max(p(i,:))-min(p(i,:)));
end
AllSamNum=328;%總樣本數
TrainSamNum=258;%訓練樣本數
TestSamNum=AllSamNum-TrainSamNum;%測試樣本數
PerPos=randperm(AllSamNum);
TrainDataIn=p(:,1:TrainSamNum)
TrainDataOut=t(:,1:TrainSamNum)
TestDataIn=p(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
TestDataOut=t(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
MaxMin=[0 1; 0 1; 0 1; 0 1;0 1];
net=newff(MaxMin,[12,3],{'tansig','logsig'},'trainlm');
%訓練參數設置
net.trainParam.epochs=1000;
%訓練次數
net.trainParam.goal=0.0001;
%訓練結束的目標
LP.lr=0.1;
%學習率
net.trainParam.show=20;
net=train(net,TrainDataIn,TrainDataOut);
out=sim(net,TestDataIn)
訓練結果：
TRAINLM, Epoch 0/1000, MSE 0.296308/0.0001, Gradient 83.9307/1e-010
TRAINLM, Epoch 20/1000, MSE 0.0224641/0.0001, Gradient 6.7605/1e-010
TRAINLM, Epoch 40/1000, MSE 0.00563627/0.0001, Gradient 3.27027/1e-010
TRAINLM, Epoch 60/1000, MSE 0.00348587/0.0001, Gradient 1.49868/1e-010
TRAINLM, Epoch 80/1000, MSE 0.00247714/0.0001, Gradient 0.459233/1e-010
TRAINLM, Epoch 100/1000, MSE 0.0018843/0.0001, Gradient 0.289155/1e-010
TRAINLM, Epoch 120/1000, MSE 0.00148204/0.0001, Gradient 0.392871/1e-010
TRAINLM, Epoch 140/1000, MSE 0.00119585/0.0001, Gradient 0.340864/1e-010
TRAINLM, Epoch 160/1000, MSE 0.000980448/0.0001, Gradient 0.391987/1e-010
TRAINLM, Epoch 180/1000, MSE 0.000779059/0.0001, Gradient 0.389835/1e-010
TRAINLM, Epoch 200/1000, MSE 0.000606974/0.0001, Gradient 0.310202/1e-010
TRAINLM, Epoch 220/1000, MSE 0.000388926/0.0001, Gradient 0.331632/1e-010
TRAINLM, Epoch 240/1000, MSE 0.000143563/0.0001, Gradient 0.0403953/1e-010
TRAINLM, Epoch 248/1000, MSE 9.87756e-005/0.0001, Gradient 0.174263/1e-010
TRAINLM, Performance goal met.
訓練好的權值、閾值的輸出方法是：
輸入到隱層權值：w1=net.iw{1,1}
隱層閾值：theta1=net.b{1}
隱層到輸出層權值：w2=net.lw{2,1};
輸出層閾值：theta2=net.b{2}
>>w1=net.iw{1,1}
w1 =
1.7663 -2.8022 -0.7142 -2.1099 -2.4011
3.6614 -2.5297 -4.4295 5.0508 8.1899
4.4007 7.6775 -6.0282 6.1567 1.8775
4.5009 -9.9915 5.9737 5.0234 3.3931
0.2703 -2.8850 0.4482 -2.9153 1.3648
2.3769 3.3151 0.8745 3.1900 1.2608
-2.2815 -6.6847 1.8738 2.4093 -2.9033
-5.3332 6.1506 -8.4386 -6.7979 3.1428
-0.0135 -10.8942 -9.6333 7.2311 12.0693
2.3130 5.2211 0.0155 2.9431 0.3135
-6.4017 -0.8987 0.1976 3.2527 0.1444
-3.6517 -1.6339 3.5505 2.4813 1.7880
>> theta1=net.b{1}
theta1 =
0.5955
-5.4876
-9.8986
-4.4731
3.6523
-4.0371
5.6187
5.7426
0.9147
-8.5523
-2.3632
-5.6106
>> w2=net.lw{2,1}
w2 =
Columns 1 through 8
-0.2751 -3.5658 -2.3689 -6.4192 -1.1209 1.5711 -1.7615 7.6202
-1.2874 -9.1588 -14.4533 7.5064 3.7074 0.9019 8.7033 -5.0031
3.3536 -0.8844 7.8887 0.9336 0.8410 -2.4905 1.0627 -9.3513
Columns 9 through 12
-2.5894 -1.9950 -3.0132 -4.7009
13.3490 -9.8521 -4.6680 -4.2037
-5.9251 2.9388 -1.6797 -2.1077
>> theta2=net.b{2}
theta2 =
-2.4762
0.5692
0.6694
輸出：
out =
Columns 1 through 8
1.0000 1.0000 0.0020 0.0000 1.0000 1.0000 0.0000 0.0000
1.0000 0.0000 0.0041 1.0000 1.0000 1.0000 1.0000 1.0000
0.9991 0.0000 0.0036 0.0015 0.9992 0.9985 0.0055 0.0036
Columns 9 through 16
1.0000 0.0000 0.0019 1.0000 0.0000 0.0000 0.0000 0.9996
1.0000 1.0000 0.9901 1.0000 1.0000 1.0000 1.0000 0.0000
0.9977 0.9999 0.9996 0.9994 0.0046 0.0023 0.0014 1.0000
Columns 17 through 24
0.0020 0.9925 0.0020 0.0000 0.0020 1.0000 0.0002 1.0000
0.0041 0.0284 0.0041 0.0284 0.0041 1.0000 0.9983 1.0000
0.0036 0.9955 0.0036 1.0000 0.0036 0.9989 0.9999 0.9990
Columns 25 through 32
1.0000 0.9938 1.0000 0.0000 1.0000 0.9999 0.0000 1.0000
1.0000 0.0177 0.0000 0.0021 1.0000 0.0006 1.0000 1.0000
0.0000 0.9971 0.0000 1.0000 0.0000 0.0004 0.9999 0.0000
Columns 33 through 40
0.9954 1.0000 0.0000 0.0000 0.9951 0.0020 0.0000 0.9997
0.0065 1.0000 1.0000 0.0025 0.0178 0.0041 1.0000 0.0000
0.9986 0.9990 0.9999 1.0000 0.0101 0.0036 0.0013 1.0000
Columns 41 through 48
0.0000 1.0000 0.9983 0.0000 0.0020 1.0000 0.0000 0.9873
0.0020 1.0000 0.0000 0.0037 0.0041 1.0000 0.0328 0.0637
1.0000 0.0000 0.9999 1.0000 0.0036 0.9982 1.0000 0.9884
Columns 49 through 56
0.0000 0.0001 1.0000 1.0000 1.0000 0.0000 0.0004 1.0000
0.0164 0.9992 0.9982 1.0000 1.0000 1.0000 0.9965 0.9998
1.0000 0.9999 0.9948 0.9991 0.9989 0.0024 0.9998 0.9968
Columns 57 through 64
1.0000 1.0000 0.0000 0.0020 0.0020 0.0001 0.0001 0.0000
0.9763 1.0000 0.0134 0.0041 0.0041 0.9990 0.0395 0.0017
0.0202 0.9988 1.0000 0.0036 0.0036 0.9999 0.9999 1.0000
Columns 65 through 70
0.9993 0.0000 0.0000 0.9978 1.0000 1.0000
0.0000 0.0018 0.0110 0.0001 1.0000 0.9998
1.0000 1.0000 1.0000 0.9999 0.9987 0.0007
每次結果因為初始化不同會不一樣，可以選取一個性能比較好的網路
保持起來
save myBpNet net
save myShu.mat TestDataIn TestDataOut
測試數據也保存起來
(TestDataIn TestDataOut 為測試數據的輸入向量和目標向量)
以後調用時
load myshu.mat
load myBpNet net
out=sim(net,TestDataIn)
基本框架程序：（前面的樣本數據自己根據實際情況設計）
load('CSHuju1.mat');
p=CC1(:,[1,3:6])';
T=[0 0 0;
1 1 1;
1 1 0;
1 0 1;
1 0 0;
0 1 1;
0 1 0;
0 0 1];
t=repmat(T,41,1)';
pp=p;
%%%%%%歸一到 0 1 之間
for i=1:5
p(i,:)=(p(i,:)-min(p(i,:)))/(max(p(i,:))-min(p(i,:)));
end
AllSamNum=328;%總樣本數
TrainSamNum=258;%訓練樣本數
TestSamNum=AllSamNum-TrainSamNum;%測試樣本數
PerPos=randperm(AllSamNum);
TrainDataIn=p(:,1:TrainSamNum)
TrainDataOut=t(:,1:TrainSamNum)
TestDataIn=p(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
TestDataOut=t(:,PerPos(:,TrainSamNum+1:TrainSamNum+TestSamNum))
MaxMin=[0 1; 0 1; 0 1; 0 1;0 1];
net=newff(MaxMin,[12,3],{'tansig','logsig'},'trainlm');
net.trainParam.epochs=1000;
%訓練次數
net.trainParam.goal=0.0001;
%訓練結束的目標
LP.lr=0.1;
%學習率
net.trainParam.show=20;
net=train(net,TrainDataIn,TrainDataOut);
out=sim(net,TestDataIn)
『叄』 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));
}
}
『肆』 BP神經網路數據400組少嗎
少。
如果你的數據具有非常復雜的對應關系，比如現在你分類到博彩類，用神經網路理論上講是可以預測的的，很多人發了論文，講怎麼用神經網路預測雙色球什麼的。實際上效果並不是非常理想。因為內在規律太復雜，有限的數據無法透徹的歸納出來到底數據怎麼變化。這種情況下，縱使你又幾千個數據也不行。比較保險的辦法還是用逆向工程方法建立一個一個的子模型，然後整理成一個大模型再做預測。往往會比因為數據量不夠引起的神經網路預測誤差要小得多。
『伍』 神經網路，訓練樣本500條，為什麼比訓練樣本6000條，訓練完，500條預測比6000條樣本好！
並非訓練樣本越多越好，因課題而異。 1、樣本最關鍵在於正確性和准確性。你所選擇的樣本首先要能正確反映該系統過程的內在規律。我們從生產現場採得的樣本數據中有不少可能是壞樣本，這樣的樣本會干擾你的神經網路訓練。通常我們認為壞樣本只是個別現象，所以我們希望通過盡可能大的樣本規模來抵抗壞樣本造成的負面影響。 2、其次是樣本數據分布的均衡性。你所選擇的樣本最好能涉及到該系統過程可能發生的各種情況，這樣可以極大可能的照顧到系統在各個情況下的規律特徵。通常我們對系統的內在規律不是很了解，所以我們希望通過盡可能大的樣本規模來「地毯式」覆蓋對象系統的方方面面。 3、再次就是樣本數據的規模，也就是你要問的問題。在確保樣本數據質量和分布均衡的情況下，樣本數據的規模決定你神經網路訓練結果的精度。樣本數據量越大，精度越高。由於樣本規模直接影響計算機的運算時間，所以在精度符合要求的情況下，我們不需要過多的樣本數據，否則我們要等待很久的訓練時間。 補充說明一下，不論是徑向基（rbf）神經網路還是經典的bp神經網路，都只是具體的訓練方法，對於足夠多次的迭代，訓練結果的准確度是趨於一致的，方法隻影響計算的收斂速度（運算時間），和樣本規模沒有直接關系。
如何確定何時訓練集的大小是「足夠大」的？
神經網路的泛化能力主要取決於3個因素：
1.訓練集的大小
2.網路的架構
3.問題的復雜程度
一旦網路的架構確定了以後，泛化能力取決於是否有充足的訓練集。合適的訓練樣本數量可以使用Widrow的拇指規則來估計。 拇指規則指出，為了得到一個較好的泛化能力，我們需要滿足以下條件（Widrow and Stearns，1985；Haykin，2008）： N = nw / e 其中，N為訓練樣本數量，nw是網路中突觸權重的數量，e是測試允許的網路誤差。 因此，假如我們允許10%的誤差，我們需要的訓練樣本的數量大約是網路中權重數量的10倍。
『陸』 用MATLAB與BP神經網路法處理15組數據,共60個數據,需要多長時間
訓練時長取決於訓練演算法、訓練目標、樣本數量和網路規模。你的樣本只有15組，數量較少，一般幾秒鍾就能訓練完成。
若從速度的角度出發，人腦神經元之間傳遞信息的速度要遠低於計算機，前者為毫秒量級，而後者的頻率往往可達幾百兆赫。但是，由於人腦是一個大規模並行與串列組合處理系統，因而，在許多問題上可以作出快速判斷、決策和處理，其速度則遠高於串列結構的普通計算機。人工神經網路的基本結構模仿人腦，具有並行處理特徵，可以大大提高工作速度。
『柒』 閫氳繃matlab杞浠跺仛bp紲炵粡緗戠粶棰勬祴濂跺埗鍝佷環鏍礆紝奼傚ぇ紲炲府蹇
涓昏佹槸鏍鋒湰緇勭粐錛屾妸杈撳叆鍜岃緭鍑烘牱鏈閮界『瀹氥傚彲浠ョ敤鍓12涓鏈堢殑鏁版嵁棰勬祴涓嬩竴涓鏈堢殑鏁版嵁錛屽嵆絎琻涓鏁版嵁鑷硜+11鍏12涓鏁版嵁浣滀負杈撳叆錛宯+12浣滀負杈撳嚭緇勭粐鏍鋒湰銆
浠ラ檮浠剁殑紼嬪簭浣滃弬鑰冿紝灝哖銆乀鎹涓轟綘鐨勬牱鏈鍗沖彲銆
BP錛圔ack Propagation錛夌炵粡緗戠粶鏄86騫寸敱Rumelhart鍜孧cCelland涓洪栫殑縐戝﹀跺皬緇勬彁鍑猴紝鏄涓縐嶆寜璇宸閫嗕紶鎾綆楁硶璁緇冪殑澶氬眰鍓嶉堢綉緇滐紝鏄鐩鍓嶅簲鐢ㄦ渶騫挎硾鐨勭炵粡緗戠粶妯″瀷涔嬩竴銆侭P緗戠粶鑳藉︿範鍜屽瓨璐澶ч噺鐨勮緭鍏-杈撳嚭妯″紡鏄犲皠鍏崇郴錛岃屾棤闇浜嬪墠鎻紺烘弿榪拌繖縐嶆槧灝勫叧緋葷殑鏁板︽柟紼嬨傚畠鐨勫︿範瑙勫垯鏄浣跨敤鏈閫熶笅闄嶆硶錛岄氳繃鍙嶅悜浼犳挱鏉ヤ笉鏂璋冩暣緗戠粶鐨勬潈鍊煎拰闃堝礆紝浣跨綉緇滅殑璇宸騫蟲柟鍜屾渶灝忋侭P紲炵粡緗戠粶妯″瀷鎷撴墤緇撴瀯鍖呮嫭杈撳叆灞傦紙input錛夈侀殣灞(hidden layer)鍜岃緭鍑哄眰(output layer)銆