① 神經網路，訓練樣本過多，怎樣先用一組數據訓練後再用另一組數據訓練（在上組數據訓練結果的基礎上）
繼承權重啊。
但是這樣的話新訓練的權重對於舊的數據是無效的。
② 數據模型需要多少訓練數據
數據模型需要多少訓練數據
毫無疑問機器學習是大數據分析不可或缺的一部分，在使用機器學習技術的時候工程師除了要選擇合適的演算法之外還需要選擇合適的樣本數據。那麼工程師到底應該選擇哪些樣本數據、選擇多少樣本數據才最合適呢?來自於Google的軟體工程師Malay Haldar最近發表了一篇題為《數據模型需要多少訓練數據》的文章對此進行了介紹。
訓練數據的質量和數量通常是決定一個模型性能的最關鍵因素。一旦訓練數據准備好，其他的事情就順理成章了。但是到底應該准備多少訓練數據呢?答案是這取決於要執行的任務，要滿足的性能，所擁有的輸入特徵、訓練數據中的噪音、提取特徵中的噪音以及模型的復雜程度等因素。而找出這些變數之間相互關系的方法就是在不同數據量的訓練數據上訓練模型並繪制學習曲線。但是這僅僅適合於已經有一定數量的訓練數據的情況，如果是最開始的時候，或者說只有很少一點訓練數據的情況，那應該怎麼辦呢?
與死板地給出所謂精確的「正確」答案相比，更靠譜的方法是通過估算和具體的經驗法則。例如本文將要介紹的實證方法：首先自動生成很多邏輯回歸問題。然後對生成的每一個問題，研究訓練數據的數量與訓練模型的性能之間的關系。最後通過觀察這兩者在這一系列問題上的關系總結出一個簡單的規則。
生成一系列邏輯回歸問題並研究不同數據量的訓練數據所造成的影響的代碼可以從GitHub上獲取。相關代碼是基於Tensorflow實現的，運行這些代碼不需要任何特殊的軟體或者硬體，用戶可以在自己的筆記本上運行整個實驗。代碼運行之後生成的圖表如下：
其中，X軸是訓練樣本的數量與模型參數數量的比率。Y軸是訓練模型的得分(f-score)。不同顏色的曲線表示不同參數數量的模型。例如，紅色曲線代表模型有128個參數，曲線的軌跡表明了隨著訓練樣本從128 x 1到 128 x 2並不斷增長的過程中該模型的得分變化。
通過該圖表，我們能夠發現模型得分並不會隨著參數規模的變化而變化。但是這是針對線性模型而言，對於一些隱藏的非線性模型並不適合。當然，更大的模型需要更多的訓練數據，但是對於一個給定的訓練模型數量與模型參數數量比率其性能是一樣的。該圖表還顯示，當訓練樣本的數量與模型參數數量的比率達到10:1之後，模型得分基本穩定在0.85，該比率便可以作為良好性能模型的一種定義。根據該圖表我們可以總結出10X規則，也就是說一個優秀的性能模型需要訓練數據的數量10倍於該模型中參數的數量。
10X規則將估計訓練數據數量的問題轉換成了需要知道模型參數數量的問題。對於邏輯回歸這樣的線性模型，參數的數量與輸入特徵的數量相等，因為模型會為每一個特徵分派一個相關的參數。但是這樣做可能會有一些問題：
特徵可能是稀疏的，因而可能會無法直接計算出特徵的數量。
由於正則化和特徵選擇技術，很多特徵可能會被拋棄，因而與原始的特徵數相比，真正輸入到模型中的特徵數會非常少。
避免這些問題的一種方法是：必須認識到估算特徵的數量時並不是必須使用標記的數據，通過未標記的樣本數據也能夠實現目標。例如，對於一個給定的大文本語料庫，可以在標記數據進行訓練之前通過生成單詞頻率的歷史圖表來理解特徵空間，通過歷史圖表廢棄長尾單詞進而估計真正的特徵數，然後應用10X規則來估算模型需要的訓練數據的數據量。
需要注意的是，神經網路構成的問題集與邏輯回歸這樣的線性模型並不相同。為了估算神經網路所需要的參數數量，你需要：
如果輸入是稀疏的，那麼需要計算嵌套層使用的參數的數量。參照word2vec的Tensorflow教程示例。
計算神經網路中邊的數量
由於神經網路中參數之間的關系並不是線性的，所以本文基於邏輯回歸所做的實證研究並不適合神經網路。但是在這種情況下，可以將10X規則作為訓練數據所需數據量的下限。
盡管有上面的問題，根據Malay Haldar的經驗，10X規則對於大部分問題還是適用的，包括淺神經網路。如果有疑問，可以在Tensorflow的代碼中插入自己的模型和假設，然後運行代碼進行驗證研究。
③ 神經網路模型需要多少條數據
輸入指標是什麼意思。輸入維數嗎？數據一是這些數據有意義是一類的，或者說是有內部規律。數量上多一點好一點。訓練樣本個預測樣本2比1左右就好。學習過程要注意的是你的學習速率，這影響最優解的尋找。
④ 神經網路處理數據組有1000個維數需要多少輸入節點
這需要看你的實際需求了，一般使用二次型就行，這樣的話輸入節點1000！個，維度這么大我想應該有很大數據是冗餘的，可以先用PCA降低下維度1000維度（通道）有點誇張，還是說只是單維度下，有連續1000個輸入作為一組樣本
⑤ tensorflow 訓練一個神經網路 需要多長時間
基本使用
使用 TensorFlow, 你必須明白 TensorFlow:
使用圖 (graph) 來表示計算任務.
在被稱之為 會話 (Session) 的上下文 (context) 中執行圖.
使用 tensor 表示數據.
通過 變數 (Variable) 維護狀態.
使用 feed 和 fetch 可以為任意的操作(arbitrary operation) 賦值或者從其中獲取數據.
綜述
TensorFlow 是一個編程系統, 使用圖來表示計算任務. 圖中的節點被稱之為 op
(operation 的縮寫). 一個 op 獲得 0 個或多個 Tensor, 執行計算,
產生 0 個或多個 Tensor. 每個 Tensor 是一個類型化的多維數組.
例如, 你可以將一小組圖像集表示為一個四維浮點數數組,
這四個維度分別是 [batch, height, width, channels].
一個 TensorFlow 圖描述了計算的過程. 為了進行計算, 圖必須在 會話 里被啟動.
會話 將圖的 op 分發到諸如 CPU 或 GPU 之類的 設備 上, 同時提供執行 op 的方法.
這些方法執行後, 將產生的 tensor 返回. 在 Python 語言中, 返回的 tensor 是
numpy ndarray 對象; 在 C 和 C++ 語言中, 返回的 tensor 是
tensorflow::Tensor 實例.
計算圖
TensorFlow 程序通常被組織成一個構建階段和一個執行階段. 在構建階段, op 的執行步驟
被描述成一個圖. 在執行階段, 使用會話執行執行圖中的 op.
例如, 通常在構建階段創建一個圖來表示和訓練神經網路, 然後在執行階段反復執行圖中的訓練 op.
TensorFlow 支持 C, C++, Python 編程語言. 目前, TensorFlow 的 Python 庫更加易用,
它提供了大量的輔助函數來簡化構建圖的工作, 這些函數尚未被 C 和 C++ 庫支持.
三種語言的會話庫 (session libraries) 是一致的.
構建圖
構建圖的第一步, 是創建源 op (source op). 源 op 不需要任何輸入, 例如 常量 (Constant). 源 op 的輸出被傳遞給其它 op 做運算.
Python 庫中, op 構造器的返回值代表被構造出的 op 的輸出, 這些返回值可以傳遞給其它
op 構造器作為輸入.
TensorFlow Python 庫有一個默認圖 (default graph), op 構造器可以為其增加節點. 這個默認圖對
許多程序來說已經足夠用了. 閱讀 Graph 類 文檔
來了解如何管理多個圖.
import tensorflow as tf
# 創建一個常量 op, 產生一個 1x2 矩陣. 這個 op 被作為一個節點
# 加到默認圖中.
#
# 構造器的返回值代表該常量 op 的返回值.
matrix1 = tf.constant([[3., 3.]])
# 創建另外一個常量 op, 產生一個 2x1 矩陣.
matrix2 = tf.constant([[2.],[2.]])
# 創建一個矩陣乘法 matmul op , 把 'matrix1' 和 'matrix2' 作為輸入.
# 返回值 'proct' 代表矩陣乘法的結果.
proct = tf.matmul(matrix1, matrix2)
默認圖現在有三個節點, 兩個 constant() op, 和一個matmul() op. 為了真正進行矩陣相乘運算, 並得到矩陣乘法的
結果, 你必須在會話里啟動這個圖.
在一個會話中啟動圖
構造階段完成後, 才能啟動圖. 啟動圖的第一步是創建一個 Session 對象, 如果無任何創建參數,
會話構造器將啟動默認圖.
欲了解完整的會話 API, 請閱讀Session 類.
# 啟動默認圖.
sess = tf.Session()
# 調用 sess 的 'run()' 方法來執行矩陣乘法 op, 傳入 'proct' 作為該方法的參數.
# 上面提到, 'proct' 代表了矩陣乘法 op 的輸出, 傳入它是向方法表明, 我們希望取回
# 矩陣乘法 op 的輸出.
#
# 整個執行過程是自動化的, 會話負責傳遞 op 所需的全部輸入. op 通常是並發執行的.
#
# 函數調用 'run(proct)' 觸發了圖中三個 op (兩個常量 op 和一個矩陣乘法 op) 的執行.
#
# 返回值 'result' 是一個 numpy `ndarray` 對象.
result = sess.run(proct)
print result
# ==> [[ 12.]]
# 任務完成, 關閉會話.
sess.close()
Session 對象在使用完後需要關閉以釋放資源. 除了顯式調用 close 外, 也可以使用 "with" 代碼塊
來自動完成關閉動作.
with tf.Session() as sess:
result = sess.run([proct])
print result
在實現上, TensorFlow 將圖形定義轉換成分布式執行的操作, 以充分利用可用的計算資源(如 CPU
或 GPU). 一般你不需要顯式指定使用 CPU 還是 GPU, TensorFlow 能自動檢測. 如果檢測到 GPU, TensorFlow
會盡可能地利用找到的第一個 GPU 來執行操作.
如果機器上有超過一個可用的 GPU, 除第一個外的其它 GPU 默認是不參與計算的. 為了讓 TensorFlow
使用這些 GPU, 你必須將 op 明確指派給它們執行. with...Device 語句用來指派特定的 CPU 或 GPU
執行操作:
with tf.Session() as sess:
with tf.device("/gpu:1"):
matrix1 = tf.constant([[3., 3.]])
matrix2 = tf.constant([[2.],[2.]])
proct = tf.matmul(matrix1, matrix2)
...
設備用字元串進行標識. 目前支持的設備包括:
"/cpu:0": 機器的 CPU.
"/gpu:0": 機器的第一個 GPU, 如果有的話.
"/gpu:1": 機器的第二個 GPU, 以此類推.
閱讀使用GPU章節, 了解 TensorFlow GPU 使用的更多信息.
互動式使用
文檔中的 Python 示例使用一個會話 Session 來
啟動圖, 並調用 Session.run() 方法執行操作.
為了便於使用諸如 IPython 之類的 Python 交互環境, 可以使用
InteractiveSession 代替
Session 類, 使用 Tensor.eval()
和 Operation.run() 方法代替
Session.run(). 這樣可以避免使用一個變數來持有會話.
# 進入一個互動式 TensorFlow 會話.
import tensorflow as tf
sess = tf.InteractiveSession()
x = tf.Variable([1.0, 2.0])
a = tf.constant([3.0, 3.0])
# 使用初始化器 initializer op 的 run() 方法初始化 'x'
x.initializer.run()
# 增加一個減法 sub op, 從 'x' 減去 'a'. 運行減法 op, 輸出結果
sub = tf.sub(x, a)
print sub.eval()
# ==> [-2. -1.]
Tensor
TensorFlow 程序使用 tensor 數據結構來代表所有的數據, 計算圖中, 操作間傳遞的數據都是 tensor.
你可以把 TensorFlow tensor 看作是一個 n 維的數組或列表. 一個 tensor 包含一個靜態類型 rank, 和
一個 shape. 想了解 TensorFlow 是如何處理這些概念的, 參見
Rank, Shape, 和 Type.
變數
Variables for more details.
變數維護圖執行過程中的狀態信息. 下面的例子演示了如何使用變數實現一個簡單的計數器. 參見
變數 章節了解更多細節.
# 創建一個變數, 初始化為標量 0.
state = tf.Variable(0, name="counter")
# 創建一個 op, 其作用是使 state 增加 1
one = tf.constant(1)
new_value = tf.add(state, one)
update = tf.assign(state, new_value)
# 啟動圖後, 變數必須先經過`初始化` (init) op 初始化,
# 首先必須增加一個`初始化` op 到圖中.
init_op = tf.initialize_all_variables()
# 啟動圖, 運行 op
with tf.Session() as sess:
# 運行 'init' op
sess.run(init_op)
# 列印 'state' 的初始值
print sess.run(state)
# 運行 op, 更新 'state', 並列印 'state'
for _ in range(3):
sess.run(update)
print sess.run(state)
# 輸出:
# 0
# 1
# 2
# 3
代碼中 assign() 操作是圖所描繪的表達式的一部分, 正如 add() 操作一樣. 所以在調用 run()
執行表達式之前, 它並不會真正執行賦值操作.
通常會將一個統計模型中的參數表示為一組變數. 例如, 你可以將一個神經網路的權重作為某個變數存儲在一個 tensor 中.
在訓練過程中, 通過重復運行訓練圖, 更新這個 tensor.
Fetch
為了取回操作的輸出內容, 可以在使用 Session 對象的 run() 調用 執行圖時, 傳入一些 tensor,
這些 tensor 會幫助你取回結果. 在之前的例子里, 我們只取回了單個節點 state, 但是你也可以取回多個
tensor:
input1 = tf.constant(3.0)
input2 = tf.constant(2.0)
input3 = tf.constant(5.0)
intermed = tf.add(input2, input3)
mul = tf.mul(input1, intermed)
with tf.Session() as sess:
result = sess.run([mul, intermed])
print result
# 輸出:
# [array([ 21.], dtype=float32), array([ 7.], dtype=float32)]
需要獲取的多個 tensor 值，在 op 的一次運行中一起獲得（而不是逐個去獲取 tensor）。
Feed
上述示例在計算圖中引入了 tensor, 以常量或變數的形式存儲. TensorFlow 還提供了 feed 機制, 該機制
可以臨時替代圖中的任意操作中的 tensor 可以對圖中任何操作提交補丁, 直接插入一個 tensor.
feed 使用一個 tensor 值臨時替換一個操作的輸出結果. 你可以提供 feed 數據作為 run() 調用的參數.
feed 只在調用它的方法內有效, 方法結束, feed 就會消失. 最常見的用例是將某些特殊的操作指定為 "feed" 操作,
標記的方法是使用 tf.placeholder() 為這些操作創建佔位符.
input1 = tf.placeholder(tf.float32)
input2 = tf.placeholder(tf.float32)
output = tf.mul(input1, input2)
with tf.Session() as sess:
print sess.run([output], feed_dict={input1:[7.], input2:[2.]})
# 輸出:
# [array([ 14.], dtype=float32)]
for a larger-scale example of feeds.
如果沒有正確提供 feed, placeholder() 操作將會產生錯誤.
MNIST 全連通 feed 教程
(source code)
給出了一個更大規模的使用 feed 的例子.
⑥ rbf神經網路的訓練樣本要多大
因課題而異。
1、樣本最關鍵在於正確性和准確性。你所選擇的樣本首先要能正確反映該系統過程的內在規律。我們從生產現場採得的樣本數據中有不少可能是壞樣本，例如由於測量儀器故障導致測量數據誤差較大等，這樣的樣本會干擾你的神經網路訓練。通常我們認為壞樣本只是個別現象，所以我們希望通過盡可能大的樣本規模來抵抗壞樣本造成的負面影響。
2、其次是樣本數據分布的均衡性。你所選擇的樣本最好能涉及到該系統過程可能發生的各種情況。例如某化工生產中某反應爐的溫度主要分布在350度—400度，且出現在380度的情況較多，那麼你的樣本數據最好也是在350-400度各種情況都有，並且也是在380度左右的樣本較多些，這樣可以極大可能的照顧到系統在各個情況下的規律特徵。通常我們對系統的內在規律不是很了解，所以我們希望通過盡可能大的樣本規模來「地毯式」覆蓋對象系統的方方面面。
3、再次就是樣本數據的規模，也就是你要問的問題。在確保樣本數據質量和分布均衡的情況下，樣本數據的規模決定你神經網路訓練結果的精度。樣本數據量越大，精度越高。還用剛才的例子，假如反應爐的溫度主要均勻分布在375-385度之間，那麼你用100個均衡分布在375-385度的訓練樣本去訓練，經過無限次或者說是足夠多次迭代之後，理論上你的神經網路的精度就是0.1度。如果你覺得0.1度足夠細膩了，那麼樣本規模為100也就可以接受了。由於樣本規模直接影響計算機的運算時間，所以在精度符合要求的情況下，我們不需要過多的樣本數據，否則我們要等待很久的訓練時間。
補充說明一下，不論是徑向基（rbf）神經網路還是經典的bp神經網路，都只是具體的訓練方法，對於足夠多次的迭代，訓練結果的准確度是趨於一致的，方法隻影響計算的收斂速度（運算時間），和樣本規模沒有直接關系。
⑦ 用MATLAB與BP神經網路法處理15組數據,共60個數據,需要多長時間
訓練時長取決於訓練演算法、訓練目標、樣本數量和網路規模。你的樣本只有15組，數量較少，一般幾秒鍾就能訓練完成。
若從速度的角度出發，人腦神經元之間傳遞信息的速度要遠低於計算機，前者為毫秒量級，而後者的頻率往往可達幾百兆赫。但是，由於人腦是一個大規模並行與串列組合處理系統，因而，在許多問題上可以作出快速判斷、決策和處理，其速度則遠高於串列結構的普通計算機。人工神經網路的基本結構模仿人腦，具有並行處理特徵，可以大大提高工作速度。
⑧ matlab神經網路訓練一般需要多少數據
只要你覺得這些數據能把握住你要解決的問題了，夠這個問題的學習了，就夠了。幾十到上百萬都是有可能的。一般數據多一些更有利於精度。
⑨ 網路訓練
利用train（net，pn）函數訓練網路，net為設計的網路，pn為樣本數據，共23組。通過「net.trainParam.epochs＝300；net＝init（net）」設置網路訓練次數，並繪圖查看其權值聚類效果，最終選擇網路訓練次數為1000。訓練結束後神經元的聚類效果如圖9.14所示，訓練後網路權值如表9.3所示。
⑩ 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));
}
}