前言： ???????

??????? 幾乎每一次神經網絡的再流行，都會出現：推進人工智能的夢想之說。不過感覺，神經網絡的成功是對人的已有經驗的覆蓋。自然狀態是一個DFA，而總結規律的過程則是根據經驗的正確性把幾何狀態轉化為抽象代數運算，這就是規則。ANN以我們難以理解的網絡參數來表示規則，是個不明所以的黑箱。

????????DNN的流行因其多層模型，以其強大的表征能力可擬合形狀詭異的樣本流形分布，可以使用多層少量參數的組合來代替淺層網絡的海量參數。

??????? 本文有大量修改，如有疑問，請拜訪原文， 原文鏈接：http://www.cnblogs.com/xiaowanyer/p/3701944.html?????????

????? ? 關于DNN的對比介紹：最接近人腦的智能學習器-深度學習及并行化實現???????????????????????????????????

??????? 另外參考：DL深度學習原理與實現??? DL原理步進：http://blog.csdn.net/zouxy09/article/details/8781396

目錄：

1.感知器：線性分類器

2.多層網：前饋神經網絡

3.解決方案：逐層初始化—自編碼器

4.隨機可視化：全連接玻爾茲曼機

5.自學習：深度信念網絡

一. 感知器??????

?????? 智慧分解為元素是識別和決策，代表人對環境的輸入和輸出。而識別和決策可以坍塌為一種邏輯表示：分類，即感知器對輸入的分類和觸發器對思維結果的分類。其中最簡單的是兩類問題，即布爾邏輯運算問題。

感知機結構

　　感知機是監督式訓練算法，是神經網絡構建的基礎。神經網絡的學習過程最終是發生在神經元之間的突觸部位，突觸的聯結強度隨著突觸前后神經元的活動而變化，變化的量與兩個神經元的活性之和成正比。 1957年，Frank Rosenblatt用數學的方法描述這個過程，即為感知器模型。????

?????? 此處參考資料：神經網絡從被人忽悠好忽悠人??????????????????

??????

?????? 數學模型：

???????????????????

應用場景例子分解：

????? 假如平面中存在?n?個點，并被分別標記為“0”和“1”。此時加入一個新的點，如果我們想知道這個點的標記是什么（和之前提到的小狗圖片的辨別同理），我們要怎么做呢？

　　一種很簡單的方法是查找離這個點最近的點是什么，然后返回和這個點一樣的標記。而一種稍微“智能”的辦法則是去找出平面上的一條線來將不同標記的數據點分開，并用這條線作為“分類器”來區分新數據點的標記。

??????

　　在本例中，每一個輸入數據都可以表示為一個向量?x?= (x_1, x_2) ，而我們的函數則是要實現“如果線以下，輸出0；線以上，輸出1”。這歸結為一個簡單的線性分類問題。

　　數學描述：用數學方法表示，定義一個表示權重的向量?w?和一個垂直偏移量?b。然后，我們將輸入、權重和偏移結合可以得到如下傳遞函數：

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ??

??????????????? 或者離散描述這種形式：

?????????????????????????

　　這個傳遞函數的結果將被輸入到一個激活函數中以產生標記。在上面的例子中，我們的激活函數是一個門限截止函數（即大于某個閾值后輸出1）：

? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ? ?

　　整個步驟連接起來就是一個感知器模型，由此實現線性分類。

模型識別過程代碼實現：

bool slp_calculate_output( const double * inputs, const double * weights, int nInputs,int & output ) { if( NULL ==inputs || NULL == weights ) return false; //1.權值相加，累計double sum =0.0; for (int i = 0 ; i < nInputs ; ++i){ sum += (weights[i] * inputs[i] ); } //2.激活函數：這里我們對乘積和的處理：如果大于0，則輸出值為1；其他情況，輸出值為-1 if(sum >0.0) output = 1; else output = -1; return true; } 簡單模型代碼：感知器模型實現了一個簡單的感知器算法，此外可以生成一個感知器結構，用以規整化輸入輸出，對應結構圖中的描述。

學習/訓練過程

　　感知機的訓練包括多訓練樣本的輸入及計算每個樣本的輸出。在每一次計算以后，權重?w?都要調整以最小化輸出誤差，這個誤差由輸入樣本的標記值與實際計算得出值的差得出。還有其它的誤差計算方法，如均方差等，但基本的原則是一樣的。

????? 感知器學習算法步驟如下：

對權系數置初值。

輸入一樣(X1…Xn)本以及它的期望輸出d。
期望輸出值d在樣本的類屬不同時取值不同。如果是A類，則取d＝1,如果是B類，則取-1。期望輸出d也即是教師信號。

計算實際輸出值。

根據實際輸出求誤差e。
?? E = d-Y(t)

用誤差e去修改權系數。
??

轉到第2點，一直執行到一切樣本均穩定為止。

學習有效性

??????? 模型的可收斂性能：通過上述的學習算法，模型一定收斂到一個穩定模型嗎？

? ? ? ? 此處參考：Rosenblatt感知器詳解????? 詳細看原文章，下面轉載兩個圖，感知器算法模型訓練收斂性證明的上界和下界。

???????

??????????????????????????????????????? 上界證明過程????????????????????????????????????????????????????????????????????????????? ? ? ? ? ?? 下界證明過程

感知器算法缺陷

　　這種簡單的感知機有一個明顯缺陷：只能對線性可分樣本集合分類。

?????? 這個缺陷重要嗎？比如?XOR，這么簡單的函數，都不能被線性分類器分類（如下圖所示，分隔兩類點失敗）：

??????

?????? 為了解決這個問題，我們要使用一種多層感知機，也就是——多層前饋神經網絡：事實上，我們將要組合一群這樣的感知機來創建出一個更強大的學習機器。多層分段線性函數的組合可以模擬任意復雜的非線性函數，也即使理論上多層感知機網絡可以?對任意分類面復雜的?樣本集合進行正確分類。

二. 多層前饋神經網絡

　　神經網絡實際上就是將大量之前講到的感知機進行組合，用不同的方法進行連接并作用在不同的激活函數上。

? ? ??

　　我們簡單介紹下前向神經網絡，其具有以下屬性：

• 一個輸入層，一個輸出層，一個或多個隱含層。上圖所示的神經網絡中有一個三神經元的輸入層、一個四神經元的隱含層、一個二神經元的輸出層。
• 每一個神經元都是一個上文提到的感知機。
• 輸入層的神經元作為隱含層的輸入，同時隱含層的神經元也是輸出層神經元的輸入。
• 每條建立在神經元之間的連接都有一個權重?w?（與感知機中提到的權重類似）。
• 在?t?層的每個神經元通常與前一層（?t - 1層）中的每個神經元都有連接（但你可以通過將這條連接的權重設為0來斷開這條連接）。
• 為了處理輸入數據，將輸入向量賦到輸入層中。在上例中，這個網絡可以計算一個3維輸入向量（由于只有3個輸入層神經元）。假如輸入向量是?[7, 1, 2]，你將第一個輸入神經元輸入7，中間的輸入1，第三個輸入2。這些值將被傳播到隱含層，通過加權傳遞函數傳給每一個隱含層神經元（這就是前向傳播），隱含層神經元再計算輸出（激活函數）。
• 輸出層和隱含層一樣進行計算，輸出層的計算結果就是整個神經網絡的輸出。

非線性

　　如果每一個感知機都只能使用一個線性激活函數會怎么樣？整個網絡的最終輸出也仍然是將輸入數據通過一些線性函數計算過一遍，只是用一些在網絡中收集的不同權值調整了一下。換名話說，再多線性函數的組合還是線性函數。如果我們限定只能使用線性激活函數的話，前饋神經網絡其實比一個感知機強大不到哪里去，無論網絡有多少層。

　　正是這個原因，大多數神經網絡都是使用的非線性激活函數，如對數函數、雙曲正切函數、階躍函數、整流函數等。不用這些非線性函數的神經網絡只能學習輸入數據的線性組合。

訓練過程

大多數常見的應用在多層感知機的監督式訓練的算法都是反向傳播算法。基本的流程如下：

　　1、將訓練樣本通過神經網絡進行前向傳播計算。

　　2、計算輸出誤差，常用均方差：

? ? ? ? ?

　　　其中?t?是目標值，?y?是實際的神經網絡計算輸出。其它的誤差計算方法也可以，但MSE（均方差）通常是一種較好的選擇。

? ? ? ? ? ? ? ? ?

　　3、網絡誤差通過 隨機梯度下降/梯度下降法 的方法來最小化。

　　梯度下降很常用，但在神經網絡中，輸入參數是一個訓練誤差的曲線。每個權重的最佳值應該是誤差曲線中的全局最小值（上圖中的?global minimum）。在訓練過程中，權重以非常小的步幅改變（在每個樣本或每小組樣本訓練完成后）以找到全局最小值，但這可不容易，訓練通常會結束在局部最小值上（上圖中的local minima）。如例子中的，如果當前權重值為0.6，那么要向0.4方向移動。

　　這個圖表示的是最簡單的情況，誤差只依賴于單個參數。但是，網絡誤差依賴于每一個網絡權重，誤差函數非常、非常復雜。

　　好消息是反向傳播算法提供了一種通過利用輸出誤差來修正兩個神經元之間權重的方法。關系本身十分復雜，但對于一個給定結點的權重修正按如下方法（簡單）：

　　　　　　

　　其中?E?是輸出誤差，?w_i?是輸入?i?的權重。

　　實質上這么做的目的是利用權重?i 來修正梯度的方向。關鍵的地方在于誤差的導數的使用，這可不一定好計算：你怎么樣能給一個大型網絡中隨機一個結點中的隨機一個權重求導數呢？

　　答案是：通過反向傳播。誤差的首次計算很簡單（只要對預期值和實際值做差即可），然后通過一種巧妙的方法反向傳回網絡，讓我們有效的在訓練過程中修正權重并（期望）達到一個最小值。

隱含層

　　隱含層十分有趣。根據普適逼近原理，一個具有有限數目神經元的隱含層可以被訓練成可逼近任意隨機函數。換句話說，一層隱含層就強大到可以學習任何函數了。這說明我們在多隱含層（如深度網絡）的實踐中可以得到更好的結果。

　　隱含層存儲了訓練數據的內在抽象表示，和人類大腦（簡化的類比）保存有對真實世界的抽象一樣。接下來，我們將用各種方法來搞一下這個隱含層。

一個網絡的例子

　　可以看一下這個通過?testMLPSigmoidBP?方法用Java實現的簡單(4-2-3)前饋神經網絡，它將?IRIS?數據集進行了分類。這個數據集中包含了三類鳶尾屬植物，特征包括花萼長度，花瓣長度等等。每一類提供50個樣本給這個神經網絡訓練。特征被賦給輸入神經元，每一個輸出神經元代表一類數據集（“1/0/0” 表示這個植物是Setosa，“0/1/0”表示?Versicolour，而“0/0/1”表示 Virginica）。分類的錯誤率是2/150（即每分類150個，錯2個）。

大規模網絡中的難題

　　神經網絡中可以有多個隱含層：這樣，在更高的隱含層里可以對其之前的隱含層構建新的抽象。而且像之前也提到的，這樣可以更好的學習大規模網絡。增加隱含層的層數通常會導致兩個問題：

　　　　1、梯度消失：隨著我們添加越來越多的隱含層，反向傳播傳遞給較低層的信息會越來越少。實際上，由于信息向前反饋，不同層次間的梯度開始消失，對網絡中權重的影響也會變小。

　　　　2、過度擬合：也許這是機器學習的核心難題。簡要來說，過度擬合指的是對訓練數據有著過于好的識別效果，這時導至模型非常復雜。這樣的結果會導致對訓練數據有非常好的識別較果，而對真實樣本的識別效果非常差。

下面我們來看看一些深度學習的算法是如何面對這些難題的。

三. 自編碼器--逐層哈希

　　大多數的機器學習入門課程都會讓你放棄前饋神經網絡。但是實際上這里面大有可為——請接著看。

　　自編碼器就是一個典型的前饋神經網絡，它的目標就是學習一種對數據集的壓縮且分布式的表示方法（編碼思想）。

　　

　　從概念上講，神經網絡的目的是要訓練去“重新建立”輸入數據，好像輸入和目標輸出數據是一樣的。換句話說：你正在讓神經網絡的輸出與輸入是同一樣東西，只是經過了壓縮（或者說是所謂的降維.....）。這還是不好理解，先來看一個例子。

壓縮輸入數據：灰度圖像

　　這里有一個由28x28像素的灰度圖像組成的訓練集，且每一個像素的值都作為一個輸入層神經元的輸入（這時輸入層就會有784個神經元）。輸出層神經元要有相同的數目（784），且每一個輸出神經元的輸出值和輸入圖像的對應像素灰度值相同。

　　在這樣的算法架構背后，神經網絡學習到的實際上并不是一個訓練數據到標記的“映射”，而是去學習數據本身的內在結構和特征（也正是因為這，隱含層也被稱作特征探測器(feature detector)）。通常隱含層中的神經元數目要比輸入/輸入層的少，這是為了使神經網絡只去學習最重要的特征并實現特征的降維。

　　我們想在中間層用很少的結點去在概念層上學習數據、產生一個緊致的表示方法。

流行感冒例子

　　為了更好的描述自編碼器，再看一個應用。

　　這次我們使用一個簡單的數據集，其中包括一些感冒的癥狀。如果感興趣，這個例子的源碼發布在這里。

　　數據結構如下：

• • 輸入數據一共六個二進制位
  • 前三位是病的證狀。例如，1 0 0 0 0 0?代表病人發燒；0 1 0 0 0 0?代表咳嗽；1 1 0 0 0 0?代表即咳嗽又發燒等等。
  • 后三位表示抵抗能力，如果一個病人有這個，代表他/她不太可能患此病。例如，0 0 0 1 0 0?代表病人接種過流感疫苗。一個可能的組合是：0 1 0 1 0 0?，這代表著一個接種過流感疫苗的咳嗽病人，等等。

　　當一個病人同時擁用前三位中的兩位時，我們認為他生病了；如果至少擁用后三位中的兩位，那么他是健康的，如：

• • 111000, 101000, 110000, 011000, 011100?= 生病
  • 000111, 001110, 000101, 000011, 000110?= 健康

　　我們來訓練一個自編碼器（使用反向傳播），六個輸入、六個輸出神經元，而只有兩個隱含神經元。

　　在經過幾百次迭代以后，我們發現，每當一個“生病”的樣本輸入時，兩個隱含層神經元中的一個（對于生病的樣本總是這個）總是顯示出更高的激活值。而如果輸入一個“健康”樣本時，另一個隱含層則會顯示更高的激活值。

再看學習

　　本質上來說，這兩個隱含神經元從數據集中學習到了流感癥狀的一種緊致表示方法。為了檢驗它是不是真的實現了學習，我們再看下過度擬合的問題。通過訓練我們的神經網絡學習到的是一個緊致的簡單的，而不是一個高度復雜且對數據集過度擬合的表示方法。

　　某種程度上來講，與其說在找一種簡單的表示方法，我們更是在嘗試從“感覺”上去學習數據。

四. 受限波爾茲曼機

　　下一步來看下受限波爾茲曼機（Restricted Boltzmann machines?RBM），一種可以在輸入數據集上學習概率分布的生成隨機神經網絡。

　　

　　RBM由隱含層、可見層、偏置層組成。和前饋神經網絡不同，可見層和隱含層之間的連接是無方向性（值可以從可見層->隱含層或隱含層->可見層任意傳輸）且全連接的（每一個當前層的神經元與下一層的每個神經元都有連接——如果允許任意層的任意神經元連接到任意層去，我們就得到了一個波爾茲曼機（非受限的））。

　　標準的RBM中，隱含和可見層的神經元都是二態的（即神經元的激活值只能是服從伯努力分布的0或1），不過也存在其它非線性的變種。

　　雖然學者們已經研究RBM很長時間了，最近出現的對比差異無監督訓練算法使這個領域復興。

對比差異

　　單步對比差異算法原理：

　　1、正向過程：

• • 輸入樣本?v?輸入至輸入層中。
  • v?通過一種與前饋網絡相似的方法傳播到隱含層中，隱含層的激活值為?h。

　　2、反向過程：

• • 將?h?傳回可見層得到?v’?（可見層和隱含層的連接是無方向的，可以這樣傳）。
  • 再將?v’?傳到隱含層中，得到?h’。

　　3、權重更新：

　　　　　　

　　　　??????? 其中?a?是學習速率，?v,?v’,?h,?h’?和?w?都是向量。

　　算法的思想就是在正向過程中影響了網絡的內部對于真實數據的表示。同時，反向過程中嘗試通過這個被影響過的表示方法重建數據。主要目的是可以使生成的數據與原數據盡可能相似，這個差異影響了權重更新。

　　換句話說，這樣的網絡具有了感知對輸入數據表示的程度的能力，而且嘗試通過這個感知能力重建數據。如果重建出來的數據與原數據差異很大，那么進行調整并再次重建。

再看流行感冒的例子

　　為了說明對比差異，我們使用與上例相同的流感癥狀的數據集。測試網絡是一個包含6個可見層神經元、2個隱含層神經元的RBM。我們用對比差異的方法對網絡進行訓練，將癥狀?v?賦到可見層中。在測試中，這些癥狀值被重新傳到可見層；然后再被傳到隱含層。隱含層的神經元表示健康/生病的狀態，與自編碼器相似。

　　在進行過幾百次迭代后，我們得到了與自編碼器相同的結果：輸入一個生病樣本，其中一個隱含層神經元具有更高激活值；輸入健康的樣本，則另一個神經元更興奮。

　　例子的代碼在這里。

深度網絡

　　到現在為止，我們已經學習了隱含層中強大的特征探測器——自編碼器和RBM，但現在還沒有辦法有效的去利用這些功能。實際上，上面所用到的這些數據集都是特定的。而我們要找到一些方法來間接的使用這些探測出的特征。

　　好消息是，已經發現這些結構可以通過棧式疊加來實現深度網絡。這些網絡可以通過貪心法的思想訓練，每次訓練一層，以克服之前提到在反向傳播中梯度消失及過度擬合的問題。

　　這樣的算法架構十分強大，可以產生很好的結果。如Google著名的“貓”識別，在實驗中通過使用特定的深度自編碼器，在無標記的圖片庫中學習到人和貓臉的識別。

　　下面我們將更深入。

棧式自編碼器

　　和名字一樣，這種網絡由多個棧式結合的自編碼器組成。

　　

　　自編碼器的隱含層?t?會作為?t + 1?層的輸入層。第一個輸入層就是整個網絡的輸入層。利用貪心法訓練每一層的步驟如下：

　　　　1、通過反向傳播的方法利用所有數據對第一層的自編碼器進行訓練（t=1，上圖中的紅色連接部分）。

　　　　2、訓練第二層的自編碼器?t=2?（綠色連接部分）。由于?t=2?的輸入層是?t=1?的隱含層，我們已經不再關心?t=1?的輸入層，可以從整個網絡中移除。整個訓練開始于將輸入樣本數據賦到?t=1?的輸入層，通過前向傳播至 t = 2 的輸出層。下面t = 2的權重（輸入->隱含和隱含->輸出）使用反向傳播的方法進行更新。t = 2的層和 t=1 的層一樣，都要通過所有樣本的訓練。

　　　　3、對所有層重復步驟1-2（即移除前面自編碼器的輸出層，用另一個自編碼器替代，再用反向傳播進行訓練）。

　　　　4、步驟1-3被稱為預訓練，這將網絡里的權重值初始化至一個合適的位置。但是通過這個訓練并沒有得到一個輸入數據到輸出標記的映射。例如，一個網絡的目標是被訓練用來識別手寫數字，經過這樣的訓練后還不能將最后的特征探測器的輸出（即隱含層中最后的自編碼器）對應到圖片的標記上去。這樣，一個通常的辦法是在網絡的最后一層（即藍色連接部分）后面再加一個或多個全連接層。整個網絡可以被看作是一個多層的感知機，并使用反向傳播的方法進行訓練（這步也被稱為微調）。

　　棧式自編碼器，提供了一種有效的預訓練方法來初始化網絡的權重，這樣你得到了一個可以用來訓練的復雜、多層的感知機。

DBN與RBM：

???? 全部用RBM形成的深層模型為深度玻爾茲曼機（Deep?Boltzmann?Machine，DBM）。如果將靠近輸入層的部分替換為貝葉斯信念網絡，即有向圖模型，而在遠離輸入層的部分仍然使用RBM，則稱為深度信念網絡?（Deep?Belief?Networks，DBN）。

插入：

RBM-受限波爾茲曼機

? ?? 假設有一個二部圖，每一層的節點之間沒有鏈接，一層是可視層，即輸入數據層（v)，一層是隱藏層(h)，如果假設所有的節點都是隨機二值變量節點（只能取0或者1值），同時假設全概率分布p(v,h)滿足Boltzmann 分布，我們稱這個模型是Restricted BoltzmannMachine (RBM)。

???????

? ?? 下面我們來看看為什么它是Deep Learning方法。首先，這個模型因為是二部圖，所以在已知v的情況下，所有的隱藏節點之間是條件獨立的（因為節點之間不存在連接），即p(h|v)=p(h₁|v)…p(h_n|v)。同理，在已知隱藏層h的情況下，所有的可視節點都是條件獨立的。同時又由于所有的v和h滿足Boltzmann 分布，因此，當輸入v的時候，通過p(h|v) 可以得到隱藏層h，而得到隱藏層h之后，通過p(v|h)又能得到可視層，通過調整參數，我們就是要使得從隱藏層得到的可視層v1與原來的可視層v如果一樣，那么得到的隱藏層就是可視層另外一種表達，因此隱藏層可以作為可視層輸入數據的特征，所以它就是一種Deep Learning方法。

??????

? ?? 如何訓練呢？也就是可視層節點和隱節點間的權值怎么確定呢？我們需要做一些數學分析。也就是模型了。

???????

能量最小化

? ? ? ? 聯合組態（jointconfiguration）的能量可以表示為：

???????

? ? ? ? 而某個組態的聯合概率分布可以通過Boltzmann 分布（和這個組態的能量）來確定：

??????

? ? ? 因為隱藏節點之間是條件獨立的（因為節點之間不存在連接），即：

???????

? ? ? 然后我們可以比較容易（對上式進行因子分解Factorizes）得到在給定可視層v的基礎上，隱層第j個節點為1或者為0的概率：

?????

? ? ? ?同理，在給定隱層h的基礎上，可視層第i個節點為1或者為0的概率也可以容易得到：

??????

? ? ? ?給定一個滿足獨立同分布的樣本集：D={v⁽¹⁾, v⁽²⁾,…, v^(N)}，我們需要學習參數θ={W,a,b}。

? ? ? ?我們最大化以下對數似然函數（最大似然估計：對于某個概率模型，我們需要選擇一個參數，讓我們當前的觀測樣本的概率最大）：

?????

? ? ? ? 也就是對最大對數似然函數求導，就可以得到L最大時對應的參數W了。

??????

? ? ? ?如果，我們把隱藏層的層數增加，我們可以得到Deep Boltzmann Machine(DBM)；如果我們在靠近可視層的部分使用貝葉斯信念網絡（即有向圖模型，當然這里依然限制層中節點之間沒有鏈接），而在最遠離可視層的部分使用Restricted Boltzmann Machine，我們可以得到DeepBelief Net（DBN）。

????????????????????????

訓練過程和代碼：

?????? 對于二者都使用同一個算法來訓練，看起來毫無區別，但是DBM有一個優勢，由于RBM是無向的，這就決定了無論給定可視節點還是隱藏節點，各個節點都是獨立的，可由圖模型的馬爾科夫性看出。

?????? 作為無向圖的DBM天生具有一些優秀的基因，比如當人看到一個外觀性質，知道它是什么物體，同樣你告訴他物體名字，他可以知道物體的外觀應該是什么樣子。這種互相推理的關系正好可以用無向圖來表示。這種優勢也順理成章的延伸出了autoencoder（大家所謂的自編碼神經網絡）和棧式神經網絡，最終輸出的少量節點是可以推理（重建）出原來樣本，也起到了降維的作用，無形中也找到了特征（編碼），autoencoder的效果如圖二所示。但是DBN中有些層是有向的，就不具有這種優勢。

? ? ?? 二者逐層預訓練后，結合樣本標簽，使用BP算法進行權重微調，說白了就是在預訓練后的權重基礎上使用BP算法進行訓練，這樣得出的權重更好些。。。

下面貼出部分DBN代碼，大家可以看出總體思路是按照構建DBN網絡（剛構建后的每層的權重是隨機生成的，從代碼也能看出），貪心層層預訓練，權重微調，預測（識別）這個步驟來的。

????? 另外代碼中softmax其實是多變量的邏輯回歸函數，注意我發的下面的代碼中權重微調使用的是邏輯回歸，不是BP：

????? 多維邏輯回歸使用的優化方法依然是最小二乘，二不是BP.

#include <iostream> #include <math.h> #include "HiddenLayer.h" #include "RBM.h" #include "LogisticRegression.h" #include "DBN.h" #include "FirstRBM.h"using namespace std; double uniform(double min, double max) { return rand() / (RAND_MAX 1.0) * (max - min) min; } int binomial(int n, double p) { if(p < 0 || p > 1) return 0; int c = 0; double r; for(int i=0; i<n; i ) { r = rand() / (RAND_MAX 1.0); if (r < p) c ; } return c; } double sigmoid(double x) { return 1.0 / (1.0 exp(-x)); } // DBN DBN::DBN(int size, int n_i, int *hls, int n_o, int n_l) { int input_size; N = size; n_ins = n_i; hidden_layer_sizes = hls; n_outs = n_o; n_layers = n_l; sigmoid_layers = new HiddenLayer*[n_layers]; rbm_layers = new RBM*[n_layers]; // construct multi-layer for(int i=0; i<n_layers; i ) { if(i == 0) { input_size = n_ins; } else { input_size = hidden_layer_sizes[i-1]; } // construct sigmoid_layer sigmoid_layers[i] = new HiddenLayer(N, input_size, hidden_layer_sizes[i], NULL, NULL); // construct rbm_layer rbm_layers[i] = new RBM(N, input_size, hidden_layer_sizes[i],\ sigmoid_layers[i]->W, sigmoid_layers[i]->b, NULL); } // layer for output using LogisticRegression log_layer = new LogisticRegression(N, hidden_layer_sizes[n_layers-1], n_outs); } DBN::~DBN() { delete log_layer; for(int i=0; i<n_layers; i ) { delete sigmoid_layers[i]; delete rbm_layers[i]; } delete[] sigmoid_layers; delete[] rbm_layers; } void DBN::pretrain(int *input, double lr, int k, int epochs) { int *layer_input; int prev_layer_input_size; int *prev_layer_input; int *train_X = new int[n_ins]; for(int i=0; i<n_layers; i ) { // layer-wise for(int epoch=0; epoch<epochs; epoch ) { // training epochs for(int n=0; n<N; n ) { // input x1...xN // initial input for(int m=0; m<n_ins; m ) train_X[m] = input[n * n_ins m]; // layer input for(int l=0; l<=i; l ) { if(l == 0) { layer_input = new int[n_ins]; for(int j=0; j<n_ins; j ) layer_input[j] = train_X[j]; } else { if(l == 1) prev_layer_input_size = n_ins; else prev_layer_input_size = hidden_layer_sizes[l-2]; prev_layer_input = new int[prev_layer_input_size]; for(int j=0; j<prev_layer_input_size; j ) prev_layer_input[j] = layer_input[j]; delete[] layer_input; layer_input = new int[hidden_layer_sizes[l-1]]; sigmoid_layers[l-1]->sample_h_given_v(prev_layer_input, layer_input); delete[] prev_layer_input; } } rbm_layers[i]->contrastive_divergence(layer_input, lr, k); } } } delete[] train_X; delete[] layer_input; } void DBN::finetune(int *input, int *label, double lr, int epochs) { int *layer_input; // int prev_layer_input_size; int *prev_layer_input; int *train_X = new int[n_ins]; int *train_Y = new int[n_outs]; for(int epoch=0; epoch<epochs; epoch ) { for(int n=0; n<N; n ) { // input x1...xN // initial input for(int m=0; m<n_ins; m ) train_X[m] = input[n * n_ins m]; for(int m=0; m<n_outs; m ) train_Y[m] = label[n * n_outs m]; // layer input for(int i=0; i<n_layers; i ) { if(i == 0) { prev_layer_input = new int[n_ins]; for(int j=0; j<n_ins; j ) prev_layer_input[j] = train_X[j]; } else { prev_layer_input = new int[hidden_layer_sizes[i-1]]; for(int j=0; j<hidden_layer_sizes[i-1]; j ) prev_layer_input[j] = layer_input[j]; delete[] layer_input; } layer_input = new int[hidden_layer_sizes[i]]; sigmoid_layers[i]->sample_h_given_v(prev_layer_input, layer_input); delete[] prev_layer_input; } log_layer->train(layer_input, train_Y, lr); } // lr *= 0.95; } delete[] layer_input; delete[] train_X; delete[] train_Y; } void DBN::predict(int *x, double *y) { double *layer_input; // int prev_layer_input_size; double *prev_layer_input; double linear_output; prev_layer_input = new double[n_ins]; for(int j=0; j<n_ins; j ) prev_layer_input[j] = x[j]; // layer activation for(int i=0; i<n_layers; i ) { layer_input = new double[sigmoid_layers[i]->n_out]; for(int k=0; k<sigmoid_layers[i]->n_out; k ) { // linear_output = 0.0; //原代碼中刪除此句 for(int j=0; j<sigmoid_layers[i]->n_in; j ) { linear_output = 0.0; //原代碼中添加此句 linear_output = sigmoid_layers[i]->W[k][j] * prev_layer_input[j]; } linear_output = sigmoid_layers[i]->b[k]; layer_input[k] = sigmoid(linear_output); } delete[] prev_layer_input; if(i < n_layers-1) { prev_layer_input = new double[sigmoid_layers[i]->n_out]; for(int j=0; j<sigmoid_layers[i]->n_out; j ) prev_layer_input[j] = layer_input[j]; delete[] layer_input; } } for(int i=0; i<log_layer->n_out; i ) { y[i] = 0; for(int j=0; j<log_layer->n_in; j ) { y[i] = log_layer->W[i][j] * layer_input[j]; } y[i] = log_layer->b[i]; } log_layer->softmax(y); delete[] layer_input; } // HiddenLayer HiddenLayer::HiddenLayer(int size, int in, int out, double **w, double *bp) { N = size; n_in = in; n_out = out; if(w == NULL) { W = new double*[n_out]; for(int i=0; i<n_out; i ) W[i] = new double[n_in]; double a = 1.0 / n_in; for(int i=0; i<n_out; i ) { for(int j=0; j<n_in; j ) { W[i][j] = uniform(-a, a); } } } else { W = w; } if(bp == NULL) { b = new double[n_out]; } else { b = bp; } } HiddenLayer::~HiddenLayer() { for(int i=0; i<n_out; i ) delete W[i]; delete[] W; delete[] b; } double HiddenLayer::output(int *input, double *w, double b) { double linear_output = 0.0; for(int j=0; j<n_in; j ) { linear_output = w[j] * input[j]; } linear_output = b; return sigmoid(linear_output); } void HiddenLayer::sample_h_given_v(int *input, int *sample) { for(int i=0; i<n_out; i ) { sample[i] = binomial(1, output(input, W[i], b[i])); } } // RBM RBM::RBM(){} RBM::RBM(int size, int n_v, int n_h, double **w, double *hb, double *vb) { N = size; n_visible = n_v; n_hidden = n_h; if(w == NULL) { W = new double*[n_hidden]; for(int i=0; i<n_hidden; i ) W[i] = new double[n_visible]; double a = 1.0 / n_visible; for(int i=0; i<n_hidden; i ) { for(int j=0; j<n_visible; j ) { W[i][j] = uniform(-a, a); } } } else { W = w; } if(hb == NULL) { hbias = new double[n_hidden]; for(int i=0; i<n_hidden; i ) hbias[i] = 0; } else { hbias = hb; } if(vb == NULL) { vbias = new double[n_visible]; for(int i=0; i<n_visible; i ) vbias[i] = 0; } else { vbias = vb; } } RBM::~RBM() { // for(int i=0; i<n_hidden; i ) delete[] W[i]; // delete[] W; // delete[] hbias; delete[] vbias; } void RBM::contrastive_divergence(int *input, double lr, int k) { double *ph_mean = new double[n_hidden]; int *ph_sample = new int[n_hidden]; double *nv_means = new double[n_visible]; int *nv_samples = new int[n_visible]; double *nh_means = new double[n_hidden]; int *nh_samples = new int[n_hidden]; /* CD-k */ sample_h_given_v(input, ph_mean, ph_sample); for(int step=0; step<k; step ) { if(step == 0) { gibbs_hvh(ph_sample, nv_means, nv_samples, nh_means, nh_samples); } else { gibbs_hvh(nh_samples, nv_means, nv_samples, nh_means, nh_samples); } } for(int i=0; i<n_hidden; i ) { for(int j=0; j<n_visible; j ) { W[i][j] = lr * (ph_sample[i] * input[j] - nh_means[i] * nv_samples[j]) / N; } hbias[i] = lr * (ph_sample[i] - nh_means[i]) / N; } for(int i=0; i<n_visible; i ) { vbias[i] = lr * (input[i] - nv_samples[i]) / N; } delete[] ph_mean; delete[] ph_sample; delete[] nv_means; delete[] nv_samples; delete[] nh_means; delete[] nh_samples; } void RBM::sample_h_given_v(int *v0_sample, double *mean, int *sample) { for(int i=0; i<n_hidden; i ) { mean[i] = propup(v0_sample, W[i], hbias[i]); sample[i] = binomial(1, mean[i]); } } void RBM::sample_v_given_h(int *h0_sample, double *mean, int *sample) { for(int i=0; i<n_visible; i ) { mean[i] = propdown(h0_sample, i, vbias[i]); sample[i] = binomial(1, mean[i]); } } double RBM::propup(int *v, double *w, double b) { double pre_sigmoid_activation = 0.0; for(int j=0; j<n_visible; j ) { pre_sigmoid_activation = w[j] * v[j]; } pre_sigmoid_activation = b; return sigmoid(pre_sigmoid_activation); } double RBM::propdown(int *h, int i, double b) { double pre_sigmoid_activation = 0.0; for(int j=0; j<n_hidden; j ) { pre_sigmoid_activation = W[j][i] * h[j]; } pre_sigmoid_activation = b; return sigmoid(pre_sigmoid_activation); } void RBM::gibbs_hvh(int *h0_sample, double *nv_means, int *nv_samples,double *nh_means, int *nh_samples) { sample_v_given_h(h0_sample, nv_means, nv_samples); sample_h_given_v(nv_samples, nh_means, nh_samples); } void RBM::reconstruct(int *v, double *reconstructed_v) { double *h = new double[n_hidden]; double pre_sigmoid_activation; for(int i=0; i<n_hidden; i ) { h[i] = propup(v, W[i], hbias[i]); } for(int i=0; i<n_visible; i ) { pre_sigmoid_activation = 0.0; for(int j=0; j<n_hidden; j ) { pre_sigmoid_activation = W[j][i] * h[j]; } pre_sigmoid_activation = vbias[i]; reconstructed_v[i] = sigmoid(pre_sigmoid_activation); } delete[] h; } // LogisticRegression LogisticRegression::LogisticRegression(int size, int in, int out) { N = size; n_in = in; n_out = out; W = new double*[n_out]; for(int i=0; i<n_out; i ) W[i] = new double[n_in]; b = new double[n_out]; for(int i=0; i<n_out; i ) { for(int j=0; j<n_in; j ) { W[i][j] = 0; } b[i] = 0; } } LogisticRegression::~LogisticRegression() { for(int i=0; i<n_out; i ) delete[] W[i]; delete[] W; delete[] b; } void LogisticRegression::train(int *x, int *y, double lr) { double *p_y_given_x = new double[n_out]; double *dy = new double[n_out]; for(int i=0; i<n_out; i ) { p_y_given_x[i] = 0; for(int j=0; j<n_in; j ) { p_y_given_x[i] = W[i][j] * x[j]; } p_y_given_x[i] = b[i]; } softmax(p_y_given_x); for(int i=0; i<n_out; i ) { dy[i] = y[i] - p_y_given_x[i]; for(int j=0; j<n_in; j ) { W[i][j] = lr * dy[i] * x[j] / N; } b[i] = lr * dy[i] / N; } delete[] p_y_given_x; delete[] dy; } void LogisticRegression::softmax(double *x) { double max = 0.0; double sum = 0.0; for(int i=0; i<n_out; i ) if(max < x[i]) max = x[i]; for(int i=0; i<n_out; i ) { x[i] = exp(x[i] - max); sum = x[i]; } for(int i=0; i<n_out; i ) x[i] /= sum; } void LogisticRegression::predict(int *x, double *y) { for(int i=0; i<n_out; i ) { y[i] = 0; for(int j=0; j<n_in; j ) { y[i] = W[i][j] * x[j]; } y[i] = b[i]; } softmax(y); } void test_dbn() { srand(0); double pretrain_lr = 0.1; int pretraining_epochs = 1000; int k = 1; double finetune_lr = 0.1; int finetune_epochs = 500; int train_N = 6; int test_N = 3; int n_ins = 6; int n_outs = 2; int hidden_layer_sizes[] = {3, 3}; int n_layers = sizeof(hidden_layer_sizes) / sizeof(hidden_layer_sizes[0]); // training data int train_X[6][6] = { {1, 1, 1, 0, 0, 0}, {1, 0, 1, 0, 0, 0}, {1, 1, 1, 0, 0, 0}, {0, 0, 1, 1, 1, 0}, {0, 0, 1, 1, 0, 0}, {0, 0, 1, 1, 1, 0} }; int train_Y[6][2] = { {1, 0}, {1, 0}, {1, 0}, {0, 1}, {0, 1}, {0, 1} }; // construct DBN DBN dbn(train_N, n_ins, hidden_layer_sizes, n_outs, n_layers); // pretrain dbn.pretrain(*train_X, pretrain_lr, k, pretraining_epochs); // finetune dbn.finetune(*train_X, *train_Y, finetune_lr, finetune_epochs); // test data int test_X[3][6] = { {1, 1, 0, 0, 0, 0}, {0, 0, 0, 1, 1, 0}, {1, 1, 1, 1, 1, 0} }; double test_Y[3][2]; // test for(int i=0; i<test_N; i ) { dbn.predict(test_X[i], test_Y[i]); for(int j=0; j<n_outs; j ) { cout << test_Y[i][j] << " "; } cout << endl; } } int main() { test_dbn(); return 0; }

程序輸出：

<pre></pre> <p>程序運行結果，是個二維的回歸值：</p> <p>0.493724 0.5062760.493724 0.5062760.493724 0.506276</p>

深度念網絡

　　和自編碼器一樣，我也可以將波爾茲曼機進行棧式疊加來構建深度信度網絡（DBN）。

　　　　　　

　　

　　在本例中，隱含層?RBM?t?可以看作是?RBM?t+1?的可見層。第一個RBM的輸入層即是整個網絡的輸入層，層間貪心式的預訓練的工作模式如下：

　　　　1. 通過對比差異法對所有訓練樣本訓練第一個RBM?t=1?

　　　　2. 訓練第二個RBM?t=1。由于?t=2?的可見層是?t=1?的隱含層，訓練開始于將數據賦至?t=1?的可見層，通過前向傳播的方法傳至?t=1?的隱含層。然后作為?t=2?的對比差異訓練的初始數據。

　　　　3. 對所有層重復前面的過程。

　　　　4. 和棧式自編碼器一樣，通過預訓練后，網絡可以通過連接到一個或多個層間全連接的?RBM 隱含層進行擴展。這構成了一個可以通過反向傳僠進行微調的多層感知機。

　　本過程和棧式自編碼器很相似，只是用RBM將自編碼器進行替換，并用對比差異算法將反向傳播進行替換。

　　(注: 例中的源碼可以從?此處獲得.)

五. Deep Belief Networks-深度信念網絡

? ? ? DBNs是一個概率生成模型，與傳統的判別模型的神經網絡相對，生成模型是建立一個觀察數據和標簽之間的聯合分布，對P(Observation|Label)和 P(Label|Observation)都做了評估，而判別模型僅僅而已評估了后者，也就是P(Label|Observation)。對于在深度神經網絡應用傳統的BP算法的時候，DBNs遇到了以下問題：

（1）需要為訓練提供一個有標簽的樣本集；

（2）學習過程較慢；

（3）不適當的參數選擇會導致學習收斂于局部最優解。

??????

? ? ? ?DBNs由多個限制玻爾茲曼機（Restricted Boltzmann Machines）層組成，一個典型的神經網絡類型如圖三所示。這些網絡被“限制”為一個可視層和一個隱層，層間存在連接，但層內的單元間不存在連接。隱層單元被訓練去捕捉在可視層表現出來的高階數據的相關性。

訓練過程

? ? ? ?首先，先不考慮最頂構成一個聯想記憶（associative memory）的兩層，一個DBN的連接是通過自頂向下的生成權值來指導確定的，RBMs就像一個建筑塊一樣，相比傳統和深度分層的sigmoid信念網絡，它能易于連接權值的學習。

? ? ? ?最開始的時候，通過一個非監督貪婪逐層方法去預訓練獲得生成模型的權值，非監督貪婪逐層方法被Hinton證明是有效的，并被其稱為對比分歧（contrastive divergence）。

? ? ? ?在這個訓練階段，在可視層會產生一個向量v，通過它將值傳遞到隱層。反過來，可視層的輸入會被隨機的選擇，以嘗試去重構原始的輸入信號。最后，這些新的可視的神經元激活單元將前向傳遞重構隱層激活單元，獲得 h（在訓練過程中，首先將 可視向量值 映射給隱單元；然后 可視單元 由隱層單元重建； 這些新可視單元 再次映射給隱單元，這樣就 獲取新的隱單元。執行這種反復步驟叫做吉布斯采樣）。這些后退和前進的步驟就是我們熟悉的Gibbs采樣，而隱層激活單元和可視層輸入之間的相關性差別就作為權值更新的主要依據。

? ? ? ?訓練時間會顯著的減少，因為只需要單個步驟就可以接近最大似然學習。增加進網絡的每一層都會改進訓練數據的對數概率，我們可以理解為越來越接近能量的真實表達。這個有意義的拓展，和無標簽數據的使用，是任何一個深度學習應用的決定性的因素。

?????

? ?? 在最高兩層，權值被連接到一起，這樣更低層的輸出將會提供一個參考的線索或者關聯給頂層，這樣頂層就會將其聯系到它的記憶內容。而我們最關心的，最后想得到的就是判別性能，例如分類任務里面。

? ? ? ?在預訓練后，DBN可以通過利用帶標簽數據用BP算法去對判別性能做調整。在這里，一個標簽集將被附加到頂層（推廣聯想記憶），通過一個自下向上的，學習到的識別權值獲得一個網絡的分類面。這個性能會比單純的BP算法訓練的網絡好。這可以很直觀的解釋，DBNs的BP算法只需要對權值參數空間進行一個局部的搜索，這相比前向神經網絡來說，訓練是要快的，而且收斂的時間也少。

? ? ? ?DBNs的靈活性使得它的拓展比較容易。一個拓展就是卷積DBNs（Convolutional Deep Belief Networks(CDBNs)）。DBNs并沒有考慮到圖像的2維結構信息，因為輸入是簡單的從一個圖像矩陣一維向量化的。而 CDBNs 就是考慮到了這個問題，它利用鄰域像素的空域關系，通過一個稱為卷積RBMs的模型區達到生成模型的變換不變性，而且可以容易得變換到高維圖像。DBNs并沒有明確地處理對觀察變量的時間聯系的學習上，雖然目前已經有這方面的研究，例如堆疊時間RBMs，以此為推廣，有序列學習的dubbed temporal convolutionmachines，這種序列學習的應用，給語音信號處理問題帶來了一個讓人激動的未來研究方向。

? ? ? ?目前，和DBNs有關的研究包括堆疊自動編碼器，它是通過用堆疊自動編碼器來替換傳統DBNs里面的RBMs。這就使得可以通過同樣的規則來訓練產生深度多層神經網絡架構，但它缺少層的參數化的嚴格要求。與DBNs不同，自動編碼器使用判別模型，這樣這個結構就很難采樣輸入采樣空間，這就使得網絡更難捕捉它的內部表達。但是，降噪自動編碼器卻能很好的避免這個問題，并且比傳統的DBNs更優。它通過在訓練過程添加隨機的污染并堆疊產生場泛化性能。訓練單一的降噪自動編碼器的過程和RBMs訓練生成模型的過程一樣。

卷積神經網絡（圖像識別）

　　 這個是本文最后一個軟件架構——卷積網絡，一類特殊的對圖像識別非常有效的前饋網絡。

　??

　　在我們深入看實際的卷積網絡之臆，我們先定義一個圖像濾波器，或者稱為一個賦有相關權重的方陣。一個濾波器可以應用到整個圖片上，通常可以應用多個濾波器。比如，你可以應用四個6x6的濾波器在一張圖片上。然后，輸出中坐標（1,1）的像素值就是輸入圖像左上角一個6x6區域的加權和，其它像素也是如此。

　　有了上面的基礎，我們來介紹定義出卷積網絡的屬性：

• 卷積層??對輸入數據應用若干濾波器。比如圖像的第一卷積層使用4個6x6濾波器。對圖像應用一個濾波器之后的得到的結果被稱為特征圖譜（feature map, FM），特征圖譜的數目和濾波器的數目相等。如果前驅層也是一個卷積層，那么濾波器應用在FM上，相當于輸入一個FM，輸出另外一個FM。從直覺上來講，如果將一個權重分布到整個圖像上后，那么這個特征就和位置無關了，同時多個濾波器可以分別探測出不同的特征。
• 下采樣層?縮減輸入數據的規模。例如輸入一個32x32的圖像，并且通過一個2x2的下采樣，那么可以得到一個16x16的輸出圖像，這意味著原圖像上的四個像素合并成為輸出圖像中的一個像素。實現下采樣的方法有很多種，最常見的是最大值合并、平均值合并以及隨機合并。
• 最后一個下采樣層（或卷積層）通常連接到一個或多個全連層，全連層的輸出就是最終的輸出。
• 訓練過程通過改進的反向傳播實現，將下采樣層作為考慮的因素并基于所有值來更新卷積濾波器的權重。

　　可以在這看幾個應用在?MNIST?數據集上的卷積網絡的例子，在這還有一個用JavaScript實現的一個可視的類似網絡。

............................................

實現

　　目前為止，我們已經學會了常見神經網絡中最主要的元素了，但是我只寫了很少的在實現過程中所遇到的挑戰。

　　概括來講，我的目標是實現一個深度學習的庫，即一個基于神經網絡且滿足如下條件的框架：　　　　

• • 一個可以表示多種模型的通用架構（比如所有上文提到的神經網絡中的元素）
  • 可以使用多種訓練算法（反向傳播，對比差異等等）。
  • 體面的性能

　　為了滿足這些要求，我在軟件的設計中使用了分層的思想。

結構

　　我們從如下的基礎部分開始：

• • NeuralNetworkImpl?是所有神經網絡模型實現的基類。
  • 每個網絡都包含有一個?layer?的集合。
  • 每一層中有一個?connections?的鏈表，?connection 指的是兩個層之間的連接，將整個網絡構成一個有向無環圖。

　　這個結構對于經典的反饋網絡、RBM?及更復雜的如?ImageNet?都已經足夠靈活。

　　這個結構也允許一個 layer 成為多個網絡的元素。比如，在?Deep Belief Network（深度信度網絡）中的layer也可以用在其?RBM 中。

　　另外，通過這個架構可以將DBN的預訓練階段顯示為一個棧式RBM的列表，微調階段顯示為一個前饋網絡，這些都非常直觀而且程序實現的很好。

數據流

下個部分介紹網絡中的數據流，一個兩步過程:

定義出層間的序列。例如，為了得到一個多層感知機的結果，輸入數據被賦到輸入層（因此，這也是首先被計算的層），然后再將數據通過不同的方法流向輸出層。為了在反向傳播中更新權重，輸出的誤差通過廣度優先的方法從輸出層傳回每一層。這部分通過?LayerOrderStrategy?進行實現，應用到了網絡圖結構的優勢，使用了不同的圖遍歷方法。其中一些樣例包含了?廣度優先策略?和?定位到一個指定的層。層的序列實際上由層間的連接進行決定，所以策略部分都是返回一個連接的有序列表。

計算激活值。每一層都有一個關聯的?ConnectionCalculator，包含有連接的列表（從上一步得來）和輸入值（從其它層得到）并計算得到結果的激活值。例如，在一個簡單的S形前饋網絡中，隱含層的??ConnectionCalculator?接受輸入層和偏置層的值（分別為輸入值和一個值全為1的數組）和神經元之間的權重值（如果是全連接層，權重值實際上以一個矩陣的形式存儲在一個?FullyConnected?結構中，計算加權和，然后將結果傳給S函數。ConnectionCalculator?中實現了一些轉移函數（如加權求和、卷積）和激活函數（如對應多層感知機的對數函數和雙曲正切函數，對應RBM的二態函數）。其中的大部分都可以通過?Aparapi?在GPU上進行計算，可以利用迷你批次訓練。

通過?Aparapi 進行 GPU 計算

　　像我之前提到的，神經網絡在近些年復興的一個重要原因是其訓練的方法可以高度并行化，允許我們通過GPGPU高效的加速訓練。本文中，我選擇?Aparapi?庫來進行GPU的支持。

　　Aparapi 在連接計算上強加了一些重要的限制：

• 只允許使用原始數據類型的一維數組（變量）。
• 在GPU上運行的程序只能調用 Aparapi?Kernel?類本身的成員函數。

　　這樣，大部分的數據（權重、輸入和輸出數據）都要保存在?Matrix?實例里面，其內部是一個一維浮點數組。所有Aparapi 連接計算都是使用?AparapiWeightedSum?（應用在全連接層和加權求和函數上）、?AparapiSubsampling2D?（應用在下采樣層）或?AparapiConv2D?（應用在卷積層）。這些限制可以通過?Heterogeneous System Architecture　里介紹的內容解決一些。而且Aparapi 允許相同的代碼運行在CPU和GPU上。

訓練

　　training?的模塊實現了多種訓練算法。這個模塊依賴于上文提到的兩個模塊。比如，BackPropagationTrainer?（所有的訓練算法都以?Trainer?為基類）在前饋階段使用前饋層計算，在誤差傳播和權重更新時使用特殊的廣度優先層計算。

　　我最新的工作是在Java8環境下開發，其它一些更新的功能可以在這個branch?下獲得，這部分的工作很快會merge到主干上。

結論

　　本文的目標是提供一個深度學習算法領域的一個簡明介紹，由最基本的組成元素開始（感知機）并逐漸深入到多種當前流行且有效的架構上，比如受限波爾茲曼機。

　　神經網絡的思想已經出現了很長時間，但是今天，你如果身處機器學習領域而不知道深度學習或其它相關知識是不應該的。不應該過度宣傳，但不可否認隨著GPGPU提供的計算能力、包括Geoffrey Hinton, Yoshua Bengio, Yann LeCun and Andrew Ng在內的研究學者們提出的高效算法，這個領域已經表現出了很大的希望。現在正是最佳的時間深入這些方面的學習。

附錄：相關資源

　　如果你想更深入的學習，下面的這些資源在我的工作當中都起過重要的作用：

• DeepLearning.net: 深度學習所有方面知識的一個門戶。里面有完善的手冊、軟件庫?和一個非常好的?閱讀列表。
• 活躍的?Google+社區.
• 兩個很好的課程:?Machine Learning?and?Neural Networks for Machine Learning, 都在Coursera上。
• The?Stanford neural networks tutorial，斯坦福神經網絡指南。
• 
  

后記：

?????? 很期待作者的庫，在這里轉載一下，省的作者有一天刪除了........

總結

以上是生活随笔為你收集整理的ANN:神经网络堆叠/进化故事（ 从感知机到DRBN ）的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。