零基礎入門深度學習：感知器

無論即將到來的是大數據時代還是人工智能時代，亦或是傳統行業使用人工智能在云上處理大數據的時代，作為一個有理想有追求的程序員，不懂深度學習（Deep Learning）這個超熱的技術，會不會感覺馬上就out了？

現在救命稻草來了，《零基礎入門深度學習》系列文章旨在講幫助愛編程的你從零基礎達到入門級水平。零基礎意味著你不需要太多的數學知識，只要會寫程序就行了，沒錯，這是專門為程序員寫的文章。

深度學習是啥

在人工智能領域，有一個方法叫機器學習。在機器學習這個方法里，有一類算法叫神經網絡。神經網絡如下圖所示：

上圖中每個圓圈都是一個神經元，每條線表示神經元之間的連接。

我們可以看到，上面的神經元被分成了多層，層與層之間的神經元有連接，而層內之間的神經元沒有連接。

最左邊的層叫做 輸入層 ，這層負責接收輸入數據；最右邊的層叫 輸出層 ，我們可以從這層獲取神經網絡輸出數據。輸入層和輸出層之間的層叫做 隱藏層 。

隱藏層比較多（大于2）的神經網絡叫做深度神經網絡。

而深度學習，就是使用深層架構（比如，深度神經網絡）的機器學習方法。

那么深層網絡和淺層網絡相比有什么優勢呢？簡單來說深層網絡的表達力更強。

事實上，一個僅有一個隱藏層的神經網絡就能擬合任何一個函數，但是它需要很多很多的神經元。而深層網絡用少得多的神經元就能擬合同樣的函數。也就是為了擬合一個函數，要么使用一個淺而寬的網絡，要么使用一個深而窄的網絡。而后者往往更節約資源。

深層網絡也有劣勢，就是它不太容易訓練。簡單的說，你需要大量的數據，很多的技巧才能訓練好一個深層網絡。這是個手藝活。

感知器

看到這里，如果你還是一頭霧水，那也是很正常的。為了理解神經網絡，我們應該先理解神經網絡的組成單元—— 神經元 。神經元也叫做 感知器 。

感知器算法在上個世紀50-70年代很流行，也成功解決了很多問題。并且，感知器算法也是非常簡單的。

感知器的定義

下圖是一個感知器：

可以看到，一個感知器有如下組成部分：

• 輸入權值   一個感知器可以接收多個輸入 ( , ,..., ∣ ∈ R ) ， 每個輸入上有一個 權值 w i ∈ R ， 此外還有一個 偏置項 b ∈ R ， 就是上圖中的 w 0 。

• 激活函數   感知器的激活函數可以有很多選擇，比如我們可以選擇下面這個階躍函數f來作為激活函數:

• 

• 輸出  感知器的輸出由下面這個公式來計算

• 

如果看完上面的公式一下子就暈了，不要緊，我們用一個簡單的例子來幫助理解。

例子：用感知器實現 and 函數

我們設計一個感知器，讓它來實現and運算。程序員都知道，and是一個二元函數（帶有兩個參數個參數 x1 和 x2 ），下面是它的真 值表：

為了計算方便，我們用0表示false，用1表示true。這沒什么難理解的，對于C語言程序員來說，這是天經地義的。

我們令

而激活函數 就是前面寫出來的 階躍函數 ，這時，感知器就相當于 and 函數

不明白？我們驗算一下：

輸入上面真值表的第一行，即 x1=0;x2=0 ，那么根據公式( 1)，計算輸出：

也就是當 x1 x2 都為 0 的時候，為 0 ， 這就是 真值表 的第一行。讀者可以自行驗證上述真值表的第二、三、四行。

例子：用感知器實現 or 函數

同樣，我們也可以用感知器來實現 or 運算。僅僅需要把偏置項 b 的值設置為-0.3就可以了。我們驗算一下，下面是 or 運算的 真值表 ：

我們來驗算第二行，這時的輸入是 x 1 = 0 ; x 2 = 1 ，帶入公式 (1) ：

也就是當 x 1 x 2 都為 0 的時候， y 為 0， 這就是 真值表 的第一行。讀者可以自行驗證上述真值表的第二、三、四行。

感知器還能做什么

事實上，感知器不僅僅能實現簡單的布爾運算。它可以擬合任何的線性函數，任何 線性分類 或 線性回歸 問題都可以用感知器來解決。前面的布爾運算可以看作是 二分類 問題，即給定一個輸入，輸出0（屬于分類0）或1（屬于分類1）。如下面所示， and 運算是一個線性分類問題，即可以用一條直線把分類0（false，紅叉表示）和分類1（true，綠點表示）分開。

然而，感知器卻不能實現異或運算，如下圖所示，異或運算不是線性的，你無法用一條直線把分類0和分類1分開。

感知器的訓練

現在，你可能困惑前面的權重項和偏置項的值是如何獲得的呢？這就要用到感知器訓練算法：將權重項和偏置項初始化為0，然后，利用下面的 感知器規則 迭代的修改 w i 和 b ，直到訓練完成。

其中

wi 是與輸入 xi 對應的權重項， b 是偏置項。事實上，可以把 b看作是值永遠為1的輸入 xb 所對應的權重。 t 是訓練樣本的實際值，一般稱之為label。而 y 是感知器的輸出值，它是根據公式(1)計算得出。 α 是一個稱為學習速率的常數，其作用是控制每一步調整權的幅度。

編程實戰：實現感知器

對于程序員來說，沒有什么比親自動手實現學得更快了，而且，很多時候一行代碼抵得上千言萬語。接下來我們就將實現一個感知器。

下面是一些說明：

• 使用python語言。python在機器學習領域用的很廣泛，而且，寫python程序真的很輕松。

• 面向對象編程。面向對象是特別好的管理復雜度的工具，應對復雜問題時，用面向對象設計方法很容易將復雜問題拆解為多個簡單問題，從而解救我們的大腦。

• 沒有使用numpy。numpy實現了很多基礎算法，對于實現機器學習算法來說是個必備的工具。但為了降低讀者理解的難度，下面的代碼只用到了基本的python（省去您去學習numpy的時間）。

下面是感知器類的實現，非常簡單。去掉注釋只有27行，而且還包括為了美觀（每行不超過60個字符）而增加的很多換行。

class Perceptron(object):
    # 初始化感知器，設置輸入參數的個數，以及激活函數。
    # 激活函數的類型為double -> double
    def __init__(self, input_num, activator):
        self.activator = activator        # 權重向量初始化為0
        self.weights = map(lambda _: 0.0, range(input_num))
        # 偏置項初始化為0
        self.bias = 0.0

    # 打印學習到的權重、偏置項
    def __str__(self):
        return 'weights\t:%s\nbias\t:%f' % (self.weights, self.bias)

    # 輸入向量，輸出感知器的計算結果
    def predict(self, input_vec):
        # 把input_vec[x1,x2,x3...]和weights[w1,w2,w3,...]打包在一起
        # 變成[(x1,w1),(x2,w2),(x3,w3),...]
        # 然后利用map函數計算[x1*w1, x2*w2, x3*w3]
        # 最后利用reduce求和
        return self.activator(
            reduce(lambda a, b: a + b,
                   map(lambda (x, w): x * w,  
                       zip(input_vec, self.weights))
                 , 0.0) + self.bias)

    # 輸入訓練數據：一組向量、與每個向量對應的label；以及訓練輪數、學習率
    def train(self, input_vecs, labels, iteration, rate):
        for i in range(iteration):
            self._one_iteration(input_vecs, labels, rate)

    # 一次迭代，把所有的訓練數據過一遍
    def _one_iteration(self, input_vecs, labels, rate):
        # 把輸入和輸出打包在一起，成為樣本的列表[(input_vec, label), ...]
        # 而每個訓練樣本是(input_vec, label)
        samples = zip(input_vecs, labels)
        # 對每個樣本，按照感知器規則更新權重
        for (input_vec, label) in samples:
            # 計算感知器在當前權重下的輸出
            output = self.predict(input_vec)
            # 更新權重
            self._update_weights(input_vec, output, label, rate)

    # 按照感知器規則更新權重
    def _update_weights(self, input_vec, output, label, rate):
        # 把input_vec[x1,x2,x3,...]和weights[w1,w2,w3,...]打包在一起
        # 變成[(x1,w1),(x2,w2),(x3,w3),...]
        # 然后利用感知器規則更新權重
        delta = label - output
        self.weights = map(
            lambda (x, w): w + rate * delta * x,
            zip(input_vec, self.weights))
        # 更新bias
        self.bias += rate * delta

接下來，我們利用這個感知器類去實現 and 函數。

#定義激活函數fdef f(x):
    return 1 if x > 0 else 0# 基于and真值表構建訓練數據
def get_training_dataset():
    # 構建訓練數據
    # 輸入向量列表
    input_vecs = [[1,1], [0,0], [1,0], [0,1]]
    # 期望的輸出列表，注意要與輸入一一對應
    # [1,1] -> 1, [0,0] -> 0, [1,0] -> 0, [0,1] -> 0
    labels = [1, 0, 0, 0]
    return input_vecs, labels    # 使用and真值表訓練感知器def train_and_perceptron():
    # 創建感知器，輸入參數個數為2（因為and是二元函數），激活函數為f
    p = Perceptron(2, f)
    # 訓練，迭代10輪, 學習速率為0.1
    input_vecs, labels = get_training_dataset()
    p.train(input_vecs, labels, 10, 0.1)
    #返回訓練好的感知器
    return pif __name__ == '__main__': 
    # 訓練and感知器
    and_perception = train_and_perceptron()
    # 打印訓練獲得的權重
    print and_perception    # 測試
    print '1 and 1 = %d' % and_perception.predict([1, 1])
    print '0 and 0 = %d' % and_perception.predict([0, 0])
    print '1 and 0 = %d' % and_perception.predict([1, 0])
    print '0 and 1 = %d' % and_perception.predict([0, 1])

將上述程序保存為perceptron.py文件，通過命令行執行這個程序，其運行結果為：

神奇吧！感知器竟然完全實現了 and 函數。讀者可以嘗試一下利用感知器實現其它函數。

小結

終于看（寫）到小結了...，大家都累了哈哈哈。

對于零基礎的你來說，走到這里應該已經很燒腦了吧。沒關系，休息一下。值得高興的是，你終于已經走出了深度學習入門的第一步，這是巨大的進步；壞消息是，這僅僅是最簡單的部分，后面還有無數艱難險阻等著你。

不過，你學的困難往往意味著別人學的也困難，掌握一門高門檻的技藝，進可糊口退可裝逼，是很值得的。

預告一下，在我的下篇文章中，我們將討論另外一種感知器： 線性單元 ，并由此引出一種可能是最最重要的優化算法： 梯度下降 算法。敬請期待！

參考資料

1. Tom M. Mitchell, "機器學習", 曾華軍等譯, 機械工業出版社

 

 

來自：http://mp.weixin.qq.com/s/cQE7KE_XbyT4joLcxywnDA