摘要：要想入門以及往下理解深度學(xué)習(xí)，其中一些概念可能是無法避免地需要你理解一番，比如什么是感知器什么是神經(jīng)網(wǎng)絡(luò)張量以及運算微分梯度下降帶著問題出發(fā)在開始之前希望你有一點機器學(xué)習(xí)方面的知識，解決問題的前提是提出問題，我們提出這樣一個問題，對數(shù)據(jù)集進

要想入門以及往下理解深度學(xué)習(xí)，其中一些概念可能是無法避免地需要你理解一番，比如：

什么是感知器

什么是神經(jīng)網(wǎng)絡(luò)

張量以及運算

微分

梯度下降

在開始之前希望你有一點機器學(xué)習(xí)方面的知識，解決問題的前提是提出問題，我們提出這樣一個問題，對MNIST數(shù)據(jù)集進行分析，然后在解決問題的過程中一步一步地來捋清楚其中涉及到的概念

MNIST數(shù)據(jù)集是一份手寫字訓(xùn)練集，出自MNIST，相信你對它不會陌生，它是機器學(xué)習(xí)領(lǐng)域的一個經(jīng)典數(shù)據(jù)集，感覺任意一個教程都拿它來說事，不過這也側(cè)面證明了這個數(shù)據(jù)集的經(jīng)典，這里簡單介紹一下：

擁有60,000個示例的訓(xùn)練集，以及10,000個示例的測試集

圖片都由一個28 ×28 的矩陣表示，每張圖片都由一個784 維的向量表示

圖片分為10類， 分別對應(yīng)從0～9，共10個阿拉伯?dāng)?shù)字

壓縮包內(nèi)容如下：

train-images-idx3-ubyte.gz: training set images (9912422 bytes)

train-labels-idx1-ubyte.gz: training set labels (28881 bytes)

t10k-images-idx3-ubyte.gz: test set images (1648877 bytes)

t10k-labels-idx1-ubyte.gz: test set labels (4542 bytes)

上圖：

圖片生成代碼如下：

%matplotlib inline

import matplotlib
import matplotlib.pyplot as plt
import numpy as np

from keras.datasets import mnist

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

def plot_digits(instances, images_per_row=10, **options):
    size = 28
    images_per_row = min(len(instances), images_per_row)
    images = instances
    n_rows = (len(instances) - 1) // images_per_row + 1
    row_images = []
    n_empty = n_rows * images_per_row - len(instances)
    images.append(np.zeros((size, size * n_empty)))
    for row in range(n_rows):
        rimages = images[row * images_per_row : (row + 1) * images_per_row]
        row_images.append(np.concatenate(rimages, axis=1))
    image = np.concatenate(row_images, axis=0)
    plt.imshow(image, cmap = matplotlib.cm.binary, **options)
    plt.axis("off")

plt.figure(figsize=(9,9))
plot_digits(train_images[:100], images_per_row=10)
plt.show()

不過你不用急著嘗試，接下來我們可以一步一步慢慢來分析手寫字訓(xùn)練集

看這一行代碼：

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

MNIST數(shù)據(jù)集通過keras.datasets加載，其中train_images和train_labels構(gòu)成了訓(xùn)練集，另外兩個則是測試集：

train_images.shape: (60000, 28, 28)

train_labels.shape: (60000,)

我們要做的事情很簡單，將訓(xùn)練集丟到神經(jīng)網(wǎng)絡(luò)里面去，訓(xùn)練后生成了我們期望的神經(jīng)網(wǎng)絡(luò)模型，然后模型再對測試集進行預(yù)測，我們只需要判斷預(yù)測的數(shù)字是不是正確的即可

在用代碼構(gòu)建一個神經(jīng)網(wǎng)絡(luò)之前，我先簡單介紹一下到底什么是神經(jīng)網(wǎng)絡(luò)，讓我們從感知器開始

感知器是Frank Rosenblatt提出的一個由兩層神經(jīng)元組成的人工神經(jīng)網(wǎng)絡(luò)，它的出現(xiàn)在當(dāng)時可是引起了轟動，因為感知器是首個可以學(xué)習(xí)的神經(jīng)網(wǎng)絡(luò)

感知器的工作方式如下所示：

左側(cè)三個變量分別表示三個不同的二進制輸入，output則是一個二進制輸出，對于多種輸入，可能有的輸入成立有的不成立，在這么多輸入的影響下，該如何判斷輸出output呢？Rosenblatt引入了權(quán)重來表示相應(yīng)輸入的重要性

此時，output可以表示為：

上面右側(cè)的式子是一個階躍函數(shù)，就是和Sigmoid、Relu一樣作用的激活函數(shù)，然后我們就可以自己實現(xiàn)一個感知器：

import numpy as np


class Perceptron:
    """
    代碼實現(xiàn) Frank Rosenblatt 提出的感知器的與非門，加深對感知器的理解
    blog: https://www.howie6879.cn/post/33/
    """

    def __init__(self, act_func, input_nums=2):
        """
        實例化一些基本參數(shù)
        :param act_func: 激活函數(shù)
        """
        # 激活函數(shù)
        self.act_func = act_func
        # 權(quán)重 已經(jīng)確定只會有兩個二進制輸入
        self.w = np.zeros(input_nums)
        # 偏置項
        self.b = 0.0

    def fit(self, input_vectors, labels, learn_nums=10, rate=0.1):
        """
        訓(xùn)練出合適的 w 和 b
        :param input_vectors: 樣本訓(xùn)練數(shù)據(jù)集
        :param labels: 標(biāo)記值
        :param learn_nums: 學(xué)習(xí)多少次
        :param rate: 學(xué)習(xí)率
        """
        for i in range(learn_nums):
            for index, input_vector in enumerate(input_vectors):
                label = labels[index]
                output = self.predict(input_vector)
                delta = label - output
                self.w += input_vector * rate * delta
                self.b += rate * delta
        print("此時感知器權(quán)重為{0}，偏置項為{1}".format(self.w, self.b))
        return self

    def predict(self, input_vector):
        if isinstance(input_vector, list):
            input_vector = np.array(input_vector)
        return self.act_func(sum(self.w * input_vector) + self.b)


def f(z):
    """
    激活函數(shù)
    :param z: (w1*x1+w2*x2+...+wj*xj) + b
    :return: 1 or 0
    """
    return 1 if z > 0 else 0

def get_and_gate_training_data():
    """
    AND 訓(xùn)練數(shù)據(jù)集
    """
    input_vectors = np.array([[1, 1], [1, 0], [0, 1], [0, 0]])
    labels = np.array([1, 0, 0, 0])
    return input_vectors, labels


if __name__ == "__main__":
    """
    輸出如下：
        此時感知器權(quán)重為[ 0.1  0.2]，偏置項為-0.2 與門
        1 and 1 = 1
        1 and 0 = 0
        0 and 1 = 0
        0 and 0 = 0
    """
    # 獲取樣本數(shù)據(jù)
    and_input_vectors, and_labels = get_and_gate_training_data()
    # 實例化感知器模型
    p = Perceptron(f)
    # 開始學(xué)習(xí) AND
    p_and = p.fit(and_input_vectors, and_labels)
    # 開始預(yù)測 AND
    print("1 and 1 = %d" % p_and.predict([1, 1]))
    print("1 and 0 = %d" % p_and.predict([1, 0]))
    print("0 and 1 = %d" % p_and.predict([0, 1]))
    print("0 and 0 = %d" % p_and.predict([0, 0]))

神經(jīng)元和感知器本質(zhì)上是一樣的，他們的區(qū)別在于激活函數(shù)不同，比如躍遷函數(shù)改為Sigmoid函數(shù)

神經(jīng)網(wǎng)絡(luò)可以通過樣本的學(xué)習(xí)來調(diào)整人工神經(jīng)元的權(quán)重和偏置，從而使輸出的結(jié)果更加準(zhǔn)確，那么怎樣給?個神經(jīng)?絡(luò)設(shè)計這樣的算法呢？

以數(shù)字識別為例，假設(shè)?絡(luò)錯誤地把?個9的圖像分類為8，我們可以讓權(quán)重和偏置做些?的改動，從而達到我們需要的結(jié)果9，這就是學(xué)習(xí)。對于感知器，我們知道，其返還的結(jié)果不是0就是1，很可能出現(xiàn)這樣一個情況，我們好不容易將一個目標(biāo)，比如把9的圖像分類為8調(diào)整回原來正確的分類，可此時的閾值和偏置會造成其他樣本的判斷失誤，這樣的調(diào)整不是一個好的方案

所以，我們需要S型神經(jīng)元，因為S型神經(jīng)元返回的是[0,1]之間的任何實數(shù)，這樣的話權(quán)重和偏置的微?改動只會引起輸出的微?變化，此時的output可以表示為σ(w?x+b)，而σ就是S型函數(shù)，S型函數(shù)中S指的是Sigmoid函數(shù)，定義如下：

神經(jīng)網(wǎng)絡(luò)其實就是按照一定規(guī)則連接起來的多個神經(jīng)元，一個神經(jīng)網(wǎng)絡(luò)由以下組件構(gòu)成：

輸入層：接受傳遞數(shù)據(jù)，這里應(yīng)該是 784 個神經(jīng)元

隱藏層：發(fā)掘出特征

各層之間的權(quán)重：自動學(xué)習(xí)出來

每個隱藏層都會有一個精心設(shè)計的激活函數(shù)，比如Sigmoid、Relu激活函數(shù)

輸出層，10個輸出

上?層的輸出作為下?層的輸?，信息總是向前傳播，從不反向回饋：前饋神經(jīng)網(wǎng)絡(luò)

有回路，其中反饋環(huán)路是可?的：遞歸神經(jīng)網(wǎng)絡(luò)

從輸入層傳入手寫字訓(xùn)練集，然后通過隱藏層向前傳遞訓(xùn)練集數(shù)據(jù)，最后輸出層會輸出10個概率值，總和為1?，F(xiàn)在，我們可以看看Keras代碼:

第一步，對數(shù)據(jù)進行預(yù)處理，我們知道，原本數(shù)據(jù)形狀是(60000, 28, 28)，取值區(qū)間為[0, 255]，現(xiàn)在改為[0, 1]：

train_images = train_images.reshape((60000, 28 * 28)) 
train_images = train_images.astype("float32") / 255

test_images = test_images.reshape((10000, 28 * 28)) 
test_images = test_images.astype("float32") / 255

然后對標(biāo)簽進行分類編碼：

from keras.utils import to_categorical

train_labels = to_categorical(train_labels) 
test_labels = to_categorical(test_labels)

第二步，編寫模型：

from keras import models 
from keras import layers

network = models.Sequential() 
network.add(layers.Dense(512, activation="relu", input_shape=(28 * 28,))) 
network.add(layers.Dense(10, activation="softmax")
            
network.compile(optimizer="rmsprop",loss="categorical_crossentropy", metrics=["accuracy"])
network.fit(train_images, train_labels, epochs=5, batch_size=128)

一個隱藏層，激活函數(shù)選用relu，輸出層使用softmax返回一個由10個概率值（總和為 1）組成的數(shù)組

訓(xùn)練過程中顯示了兩個數(shù)字：一個是網(wǎng)絡(luò)在訓(xùn)練數(shù)據(jù)上的損失loss，另一個是網(wǎng)絡(luò)在 訓(xùn)練數(shù)據(jù)上的精度acc

很簡單，我們構(gòu)建和訓(xùn)練一個神經(jīng)網(wǎng)絡(luò)，就這么幾行代碼，之所以寫的這么剪短，是因為keras接接口封裝地比較好用，但是里面的理論知識我們還是需要好好研究下

TensorFlow里面的Tensor是張量的意思，上面例子里面存儲在多維Numpy數(shù)組中的數(shù)據(jù)就是張量：張量是數(shù)據(jù)容器，矩陣就是二維張量，張量是矩陣向任意維度的推廣，張量的維度稱為軸

包含一個數(shù)字的張量叫做標(biāo)量（0D張量），如下：

x = np.array(12)
print(x, x.ndim)
# 12, 0

張量軸的個數(shù)也叫做階(rank)

數(shù)字組成的數(shù)組叫做向量（1D張量），如下：

x = np.array([12, 3, 6, 14, 7])
print(x, x.ndim)
# [12  3  6 14  7] 1

向量組成的數(shù)組叫做矩陣（2D張量），如下：

x = np.array([[5, 78, 2, 34, 0], [6, 79, 3, 35, 1], [7, 80, 4, 36, 2]])
print(x, x.ndim)
# [[ 5 78  2 34  0]
# [ 6 79  3 35  1]
# [ 7 80  4 36  2]] 2

將多個矩陣組合成一個新的數(shù)組就是一個3D張量，如下：

x = np.array([[[5, 78, 2, 34, 0], [6, 79, 3, 35, 1]], [[5, 78, 2, 34, 0], [6, 79, 3, 35, 1]], [[5, 78, 2, 34, 0], [6, 79, 3, 35, 1]]])
print(x, x.ndim)
# (array([[[ 5, 78,  2, 34,  0],
#          [ 6, 79,  3, 35,  1]],
#  
#         [[ 5, 78,  2, 34,  0],
#          [ 6, 79,  3, 35,  1]],
#  
#         [[ 5, 78,  2, 34,  0],
#          [ 6, 79,  3, 35,  1]]]), 3)

將多個3D張量組合成一個數(shù)組，可以創(chuàng)建一個4D張量

張量是由以下三個關(guān)鍵屬性來定義：

軸的個數(shù)：3D張量三個軸，矩陣兩個軸

形狀：是一個整數(shù)元祖，比如前面矩陣為(3, 5)，向量(5,)，3D張量為(3, 2, 5)

數(shù)據(jù)類型

以前面加載的train_images為：

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

比如進行切片選擇10~100個數(shù)字：

train_images[10:100].shape
# (90, 28, 28)

深度學(xué)習(xí)模型會將數(shù)據(jù)集隨機分割成小批量進行處理，比如：

batch = train_images[:128]
batch.shape
# (128, 28, 28)

下面將介紹下現(xiàn)實世界中數(shù)據(jù)的形狀：

向量數(shù)據(jù)：2D張量，(samples, features)

時間序列數(shù)據(jù)或者序列數(shù)據(jù)：3D張量，(samples, timesteps, features)

圖像：4D張量，(samples, height, width, channels) 或 (samples, channels, height, width)

視頻：5D張量，(samples, frames, height, width, channels) 或 (samples, frames, channels, height, width)

類似于計算機程序的計算可以轉(zhuǎn)化為二進制計算，深度學(xué)習(xí)計算可以轉(zhuǎn)化為數(shù)值數(shù)據(jù)張量上的一些張量運算(tensor operation)

上面模型的隱藏層代碼如下：

keras.layers.Dense(512, activation="relu")

這一層可以理解為一個函數(shù)，輸入一個2D張量，輸出一個2D張量，就如同上面感知機那一節(jié)最后輸出的計算函數(shù)：

output = relu(dot(W, input) + b)

Relu 和加法運算都是逐元素的運算，比如：

# 輸入示例
input_x = np.array([[2], [3], [1]])
# 權(quán)重
W = np.array([[5, 6, 1], [7, 8, 1]])
# 計算輸出 z
z = np.dot(W, input_x)

# 實現(xiàn)激活函數(shù)
def naive_relu(x):
    assert len(x.shape) == 2
    x = x.copy()
    for i in range(x.shape[0]):
        for j in range(x.shape[1]):
            x[i, j] = max(x[i, j], 0) 
    return x

# 激活函數(shù)對應(yīng)的輸出
output = naive_relu(z)
output

張量運算那節(jié)中，有這樣一段代碼：

output = relu(dot(W, input) + b)

dot(W, input)是2D張量，b是向量，兩個形狀不同的張量相加，會發(fā)生什么？

如果沒有歧義的話，較小的張量會被廣播，用來匹配較大張量的形狀：

input_x = np.array([[1], [3]])
# 權(quán)重
W = np.array([[5, 6], [7, 8]])
b = np.array([1])
# 計算輸出 z
z = np.dot(W, input_x) + b
# array([[24],
#        [32]])

點積運算，也叫張量積，如：

import numpy as np

# 輸入示例
input_x = np.array([[2], [3], [1]])
# 權(quán)重
W = np.array([[5, 6, 1], [7, 8, 1]])
np.dot(W, input_x)

兩個向量之間的點積是一個標(biāo)量：

def naive_vector_dot(x, y):
    assert len(x.shape) == 1
    assert len(y.shape) == 1 
    assert x.shape[0] == y.shape[0]
    z = 0.
    for i in range(x.shape[0]):
        z += x[i] * y[i] 
    return z

x = np.array([1,2])
y = np.array([1,2])

naive_vector_dot(x, y)

# 5.0

矩陣和向量點積后是一個向量：

np.dot(W, [1, 2, 3])
# array([20, 26])

前面對數(shù)據(jù)進行預(yù)處理的時候：

train_images = train_images.reshape((60000, 28 * 28)) 
train_images = train_images.astype("float32") / 255

上面的例子將輸入數(shù)據(jù)的shape變成了(60000, 784)，張量變形指的就是改變張量的行和列，得到想要的形狀，前后數(shù)據(jù)集個數(shù)不變，經(jīng)常遇到一個特殊的張量變形是轉(zhuǎn)置(transposition)，如下：

x = np.zeros((300, 20))
x = np.transpose(x)
x.shape
# (20, 300)

針對每個輸入，神經(jīng)網(wǎng)絡(luò)都會通過下面的函數(shù)對輸入數(shù)據(jù)進行變換：

output = relu(dot(W, input_x) + b)

其中：

relu：激活函數(shù)

W：是一個張量，表示權(quán)重，第一步可以取較小的隨機值進行隨機初始化

b：是一個張量，表示偏置

現(xiàn)在我們需要一個算法來讓我們找到權(quán)重和偏置，從而使得y=y(x)可以擬合樣本輸入的x

感知器學(xué)習(xí)的過程就是其中權(quán)重和偏置不斷調(diào)優(yōu)更新的過程，其中的偏置可以理解成輸入為1的權(quán)重值，那么權(quán)重是怎么更新的呢？

首先，介紹一個概念，損失函數(shù)，引用李航老師統(tǒng)計學(xué)習(xí)方法書中的一個解釋：

監(jiān)督學(xué)習(xí)問題是在假設(shè)空間中選取模型f作為決策函數(shù)，對于給定的輸入X，由f(X)給出相應(yīng)的輸出Y，這個輸出的預(yù)測值f(X)與真實值Y可能一致也可能不一致，用一個損失函數(shù)（loss function）或代價函數(shù)（cost function）來度量預(yù)測錯誤的程度，損失函數(shù)是f(X)和Y的非負實值函數(shù)，記作L(Y,f(X))

其中模型f(X)關(guān)于訓(xùn)練數(shù)據(jù)集的平均損失，我們稱之為：經(jīng)驗風(fēng)險（empirical risk），上述的權(quán)重調(diào)整，就是在不斷地讓經(jīng)驗風(fēng)險最小，求出最好的模型f(X)，我們暫時不考慮正則化，此時我們經(jīng)驗風(fēng)險的最優(yōu)化的目標(biāo)函數(shù)就是：

求解出此目標(biāo)函數(shù)最小時對應(yīng)的權(quán)重值，就是我們感知器里面對應(yīng)的權(quán)重值，在推導(dǎo)之前，我們還得明白兩個概念：

什么是導(dǎo)數(shù)

什么是梯度

假設(shè)有一個連續(xù)的光滑函數(shù)f(x) = y，什么是函數(shù)連續(xù)性？指的是x的微小變化只能導(dǎo)致y的微小變化。

假設(shè)f(x)上的兩點a,b足夠接近，那么a,b可以近似為一個線性函數(shù)，此時他們斜率為k，那么可以說斜率k是f在b點的導(dǎo)數(shù)

總之，導(dǎo)數(shù)描述了改變x后f(x)會如何變化，如果你希望減小f(x)的值，只需要將x沿著導(dǎo)數(shù)的反方向移動一小步即可，反之亦然

梯度是張量運算的導(dǎo)數(shù)，是導(dǎo)數(shù)這一概念向多元函數(shù)導(dǎo)數(shù)的推廣，它指向函數(shù)值上升最快的方向，函數(shù)值下降最快的方向自然就是梯度的反方向

推導(dǎo)過程如下：

感知器代碼里面的這段:

self.w += input_vector * rate * delta

就對應(yīng)上面式子里面推導(dǎo)出來的規(guī)則

再來看看全部的手寫字識別模型代碼：

from keras import models 
from keras import layers
from keras.utils import to_categorical

(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

train_images = train_images.reshape((60000, 28 * 28)) 
train_images = train_images.astype("float32") / 255

test_images = test_images.reshape((10000, 28 * 28)) 
test_images = test_images.astype("float32") / 255

train_labels = to_categorical(train_labels) 
test_labels = to_categorical(test_labels)


network = models.Sequential() 
network.add(layers.Dense(512, activation="relu", input_shape=(28 * 28,))) 
network.add(layers.Dense(10, activation="softmax"))

network.compile(optimizer="rmsprop",loss="categorical_crossentropy", metrics=["accuracy"])
network.fit(train_images, train_labels, epochs=5, batch_size=128)

test_loss, test_acc = network.evaluate(test_images, test_labels)
print("test_acc:", test_acc)

輸入數(shù)據(jù)保存在float32格式的Numpy張量中，形狀分別是(60000, 784)和(10000, 784)

神經(jīng)網(wǎng)絡(luò)結(jié)構(gòu)為：1個輸入層、一個隱藏層、一個輸出層

categorical_crossentropy是針對分類模型的損失函數(shù)

每批128個樣本，共迭代5次，一共更新(469 * 5) = 2345次

對本文有影響的書籍文章如下，感謝他們的付出：

[統(tǒng)計學(xué)習(xí)方法] 第一章

Neural Networks and Deep Learning 第一章

Deep Learning with Python 第二章

hands_on_Ml_with_Sklearn_and_TF

hanbt零基礎(chǔ)入門深度學(xué)習(xí)系列