原文地址：https://zybuluo.com/hanbingtao/note/581764

轉載在此的目的是自己做個筆記，日後好複習，如侵權請聯絡我！！

深度學習是什麼？

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

　　上圖的每個圓圈都是一個神經元，每條線表示神經元之間的連線。我們可以看到，上面的神經元被分成了多層，層與層之間的神經元有連線，而層內之間的神經元沒有連線。最左邊的層叫輸入層，這層負責接收輸入資料；最右邊的層叫做輸出層，我們可以從這層獲取神經網路輸出資料。輸入層和輸出層之間的層叫做隱藏層。

　　隱藏層比較多（大於2）的神經網路叫做深度神經網路。而深度學習，就是使用深度架構（比如，深度神經網路）的機器學習方法。

　　那麼深層網路和淺層網路相比有什麼優勢呢？簡單來說深度網路能夠表達力更強。事實上，一個僅有一個隱藏層的神經網路就能擬合任何一個函式，但是它需要很多很多的神經元。而深層網路用少得多的神經元就能擬合同樣的函式。也就是為了擬合一個函式，要麼使用一個淺而寬的網路，要麼使用一個深而窄的網路。而後者往往更節約資源。

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

感知器

下圖是一個感知器：

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

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

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

　　為了計算方便，我們用0表示false，用1表示true。

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

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

感知器還能做什麼？

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

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

感知器的訓練

　　每次從訓練資料中取出一個樣本的輸入向量x，使用感知器計算其輸出y，再根據上面的規則來調整權重。每處理一個樣本就調整一次權重。經過多輪迭代後（即全部的訓練資料被反覆處理多輪），就可以訓練處感知器的權重了，使之實現目標函式。

程式設計實戰：實現感知器

完整程式碼實現請參考：

# -*- coding: UTF-8 -*-

class Perceptron(object):
    def __init__(self, input_num, activator):
        '''
        初始化感知器，設定輸入引數的個數，以及啟用函式。
        啟用函式的型別為double -> double
        '''
        self.activator = activator
        # 權重向量初始化為0
        self.weights = [0.0 for _ in range(input_num)]
        # 偏置項初始化為0
        self.bias = 0.0

    def __str__(self):
        '''
        列印學習到的權重、偏置項
        '''
        return 'weights\t:%s\nbias\t:%f\n' % (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)
 
    def train(self, input_vecs, labels, iteration, rate):
        '''
        輸入訓練資料：一組向量、與每個向量對應的label；以及訓練輪數、學習率
        '''
        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


def f(x):
    '''
    定義啟用函式f
    '''
    return 1 if x > 0 else 0


def get_training_dataset():
    '''
    基於and真值表構建訓練資料
    '''
    # 構建訓練資料
    # 輸入向量列表
    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    


def train_and_perceptron():
    '''
    使用and真值表訓練感知器
    '''
    # 建立感知器，輸入引數個數為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 p


if __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])

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

下面是一些說明：

• 使用python語言。python在機器學習領域用的很廣泛，而且，寫python程式真的很輕鬆。
• 面向物件程式設計。面向物件是特別好的管理複雜度的工具，應對複雜問題時，用面向物件設計方法很容易將複雜問題拆解為多個簡單問題，從而解救我們的大腦。
• 沒有使用numpy。numpy實現了很多基礎演算法，對於實現機器學習演算法來說是個必備的工具。但為了降低讀者理解的難度，下面的程式碼只用到了基本的python（省去您去學習numpy的時間）。

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

class Perceptron(object):
    def __init__(self, input_num, activator):
        '''
        初始化感知器，設定輸入引數的個數，以及啟用函式。
        啟用函式的型別為double -> double
        '''
        self.activator = activator
        # 權重向量初始化為0
        self.weights = [0.0 for _ in range(input_num)]
        # 偏置項初始化為0
        self.bias = 0.0
    def __str__(self):
        '''
        列印學習到的權重、偏置項
        '''
        return 'weights\t:%s\nbias\t:%f\n' % (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)
    def train(self, input_vecs, labels, iteration, rate):
        '''
        輸入訓練資料：一組向量、與每個向量對應的label；以及訓練輪數、學習率
        '''
        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函式。

def f(x):
    '''
    定義啟用函式f
    '''
    return 1 if x > 0 else 0
def get_training_dataset():
    '''
    基於and真值表構建訓練資料
    '''
    # 構建訓練資料
    # 輸入向量列表
    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    
def train_and_perceptron():
    '''
    使用and真值表訓練感知器
    '''
    # 建立感知器，輸入引數個數為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 p
if __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函式，大家可以嘗試一下利用感知器去實現其它函式。

小結

　　終於看（寫）到小結了...，大家都累了。對於零基礎的你來說，走到這裡應該已經很燒腦了吧。沒關係，休息一下。值得高興的是，你終於已經走出了深度學習入門的第一步，這是巨大的進步；壞訊息是，這僅僅是最簡單的部分，後面還有無數艱難險阻等著你。不過，你學的困難往往意味著別人學的也困難，掌握一門高門檻的技藝，進可餬口退可裝逼，是很值得的。