本文首發(fā)于微信公眾號 AIMaster。

在這一系列文章中奠宜，你將學到深度學習的一些基本概念以及TensorFlow的使用包颁，并完成手寫體數字識別、圖像分類压真、遷移學習娩嚼、Deep Dream、風格遷移和強化學習等項目滴肿。 github上的Python NoteBook也可以很方便的調試代碼岳悟。

總而言之， 一份很贊的入門教程泼差。歡迎分享/關注/訂閱贵少。

by Magnus Erik Hvass Pedersen / GitHub / Videos on YouTube
中文翻譯 thrillerist /Github

如有轉載，請附上本文鏈接堆缘。

介紹

這份教程示范了在TensorFlow中使用一個簡單線性模型的工作流程滔灶。在載入稱為MNIST的手寫數字圖片數據集后，我們在TensorFlow中定義并優(yōu)化了一個數學模型吼肥。（我們）會畫出結果并展開討論录平。

你應該熟悉基本的線性代數麻车，Python和Jupyter Notebook編輯器。如果你對機器學習和分類有基本的理解也很有幫助斗这。

導入

%matplotlib inline
import matplotlib.pyplot as plt
import tensorflow as tf
import numpy as np
from sklearn.metrics import confusion_matrix

使用Python3.5.2（Anaconda）開發(fā)动猬，TensorFlow版本是：

tf.__version__

'0.12.0-rc1'

載入數據

MNIST數據集大約有12MB，如果給定的地址里沒有文件表箭，它將自動下載赁咙。

from tensorflow.examples.tutorials.mnist import input_data
data = input_data.read_data_sets("data/MNIST/", one_hot=True)

Extracting data/MNIST/train-images-idx3-ubyte.gz
Extracting data/MNIST/train-labels-idx1-ubyte.gz
Extracting data/MNIST/t10k-images-idx3-ubyte.gz
Extracting data/MNIST/t10k-labels-idx1-ubyte.gz

現(xiàn)在已經載入了MNIST數據集，它由70,000張圖像和對應的標簽（比如圖像的類別）組成燃逻。數據集分成三份互相獨立的子集序目。我們在教程中只用訓練集和測試集。

print("Size of:")
print("- Training-set:\t\t{}".format(len(data.train.labels)))
print("- Test-set:\t\t{}".format(len(data.test.labels)))
print("- Validation-set:\t{}".format(len(data.validation.labels)))

Size of:

• Training-set: 55000
• Test-set: 10000
• Validation-set: 5000

One-Hot 編碼

數據集以一種稱為One-Hot編碼的方式載入伯襟。這意味著標簽從一個單獨的數字轉換成一個長度等于所有可能類別數量的向量猿涨。向量中除了第$i$個元素是1，其他元素都是0姆怪，這代表著它的類別是$i$'叛赚。比如，前面五張圖像標簽的One-Hot編碼為：

data.test.labels[0:5, :]

array([[ 0., 0., 0., 0., 0., 0., 0., 1., 0., 0.],
[ 0., 0., 1., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 1., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 1., 0., 0., 0., 0., 0., 0., 0., 0., 0.],
[ 0., 0., 0., 0., 1., 0., 0., 0., 0., 0.]])

在不同的比較和度量性能時稽揭，我們也需要用單獨的數字表示類別俺附，因此我們通過取最大元素的索引，將One-Hot編碼的向量轉換成一個單獨的數字溪掀。需注意的是'class'在Python中是一個關鍵字事镣，所以我們用'cls'代替它。

data.test.cls = np.array([label.argmax() for label in data.test.labels])

現(xiàn)在我們可以看到測試集中前面五張圖像的類別揪胃。將這些與上面的One-Hot編碼的向量進行比較璃哟。例如，第一張圖像的類別是7喊递，對應的在One-Hot編碼向量中随闪，除了第7個元素其他都為零。

data.test.cls[0:5]

array([7, 2, 1, 0, 4])

數據維度

在下面的源碼中骚勘，有很多地方用到了數據維度铐伴。在計算機編程中，通常來說最好使用變量和常量俏讹，而不是在每次使用數值時寫硬代碼当宴。這意味著數字只需要在一個地方改動就行。這些最好能從讀取的數據中獲取泽疆，但這里我們直接寫上數值即供。

# We know that MNIST images are 28 pixels in each dimension.
img_size = 28

# Images are stored in one-dimensional arrays of this length.
img_size_flat = img_size * img_size

# Tuple with height and width of images used to reshape arrays.
img_shape = (img_size, img_size)

# Number of classes, one class for each of 10 digits.
num_classes = 10

用來繪制圖像的幫助函數

這個函數用來在3x3的柵格中畫9張圖像，然后在每張圖像下面寫出真實的和預測的類別于微。

def plot_images(images, cls_true, cls_pred=None):
    assert len(images) == len(cls_true) == 9
    
    # Create figure with 3x3 sub-plots.
    fig, axes = plt.subplots(3, 3)
    fig.subplots_adjust(hspace=0.3, wspace=0.3)

    for i, ax in enumerate(axes.flat):
        # Plot image.
        ax.imshow(images[i].reshape(img_shape), cmap='binary')

        # Show true and predicted classes.
        if cls_pred is None:
            xlabel = "True: {0}".format(cls_true[i])
        else:
            xlabel = "True: {0}, Pred: {1}".format(cls_true[i], cls_pred[i])

        ax.set_xlabel(xlabel)
        
        # Remove ticks from the plot.
        ax.set_xticks([])
        ax.set_yticks([])

繪制幾張圖像來看看數據是否正確

# Get the first images from the test-set.
images = data.test.images[0:9]

# Get the true classes for those images.
cls_true = data.test.cls[0:9]

# Plot the images and labels using our helper-function above.
plot_images(images=images, cls_true=cls_true)

TensorFlow圖

TensorFlow的全部目的就是使用一個稱之為計算圖（computational graph）的東西逗嫡，它會比直接在Python中進行相同計算量要高效得多青自。TensorFlow比Numpy更高效，因為TensorFlow了解整個需要運行的計算圖驱证，然而Numpy只知道某個時間點上唯一的數學運算延窜。

TensorFlow也能夠自動地計算需要優(yōu)化的變量的梯度，使得模型有更好的表現(xiàn)抹锄。這是由于Graph是簡單數學表達式的結合逆瑞，因此整個圖的梯度可以用鏈式法則推導出來。

TensorFlow還能利用多核CPU和GPU伙单，Google也為TensorFlow制造了稱為TPUs（Tensor Processing Units）的特殊芯片获高，它比GPU更快。

一個TensorFlow圖由下面幾個部分組成吻育，后面會詳細描述：

• 占位符變量（Placeholder）用來改變圖的輸入念秧。
• 模型變量（Model）將會被優(yōu)化，使得模型表現(xiàn)得更好布疼。
• 模型本質上就是一些數學函數摊趾，它根據Placeholder和模型的輸入變量來計算一些輸出。
• 一個cost度量用來指導變量的優(yōu)化游两。
• 一個優(yōu)化策略會更新模型的變量砾层。

另外，TensorFlow圖也包含了一些調試狀態(tài)贱案，比如用TensorBoard打印log數據肛炮，本教程不涉及這些。

占位符 （Placeholder）變量

Placeholder是作為圖的輸入宝踪，每次我們運行圖的時候都可能會改變它們侨糟。將這個過程稱為feeding placeholder變量，后面將會描述它肴沫。

首先我們?yōu)檩斎雸D像定義placeholder變量粟害。這讓我們可以改變輸入到TensorFlow圖中的圖像蕴忆。這也是一個張量（tensor）颤芬，代表一個多維向量或矩陣。數據類型設置為float32套鹅，形狀設為[None, img_size_flat]站蝠，None代表tensor可能保存著任意數量的圖像，每張圖象是一個長度為img_size_flat的向量卓鹿。

x = tf.placeholder(tf.float32, [None, img_size_flat])

接下來我們?yōu)檩斎胱兞?code>x中的圖像所對應的真實標簽定義placeholder變量菱魔。變量的形狀是[None, num_classes]，這代表著它保存了任意數量的標簽吟孙，每個標簽是長度為num_classes的向量澜倦，本例中長度為10聚蝶。

y_true = tf.placeholder(tf.float32, [None, num_classes])

最后我們?yōu)樽兞?code>x中圖像的真實類別定義placeholder變量。它們是整形藻治，并且這個變量的維度設為[None]碘勉，代表placeholder變量是任意長的一維向量。

y_true_cls = tf.placeholder(tf.int64, [None])

需要優(yōu)化的變量

除了上面定義的那些給模型輸入數據的變量之外桩卵，TensorFlow還需要改變一些模型變量验靡，使得訓練數據的表現(xiàn)更好。

第一個需要優(yōu)化的變量稱為權重weight雏节，TensorFlow變量需要被初始化為零胜嗓，它的形狀是[img_size_flat, num_classes]，因此它是一個img_size_flat行钩乍、num_classes列的二維張量（或矩陣）辞州。

weights = tf.Variable(tf.zeros([img_size_flat, num_classes]))

第二個需要優(yōu)化的是偏差變量biases，它被定義成一個長度為num_classes的1維張量（或向量）件蚕。

biases = tf.Variable(tf.zeros([num_classes]))

模型

這個最基本的數學模型將placeholder變量x中的圖像與權重weight相乘孙技，然后加上偏差biases。

結果是大小為[num_images, num_classes]的一個矩陣排作，由于x的形狀是[num_images, img_size_flat] 并且 weights的形狀是[img_size_flat, num_classes]牵啦，因此兩個矩陣乘積的形狀是[num_images, num_classes]，然后將biases向量添加到矩陣每一行中妄痪。

logits = tf.matmul(x, weights) + biases

現(xiàn)在logits是一個 num_images 行num_classes列的矩陣哈雏，第$i$行第$j$列的那個元素代表著第$i$張輸入圖像有多大可能性是第$j$個類別。

然而衫生，這是很粗略的估計并且很難解釋裳瘪，因為數值可能很小或很大，因此我們想要對它們做歸一化罪针，使得logits矩陣的每一行相加為1彭羹，每個元素限制在0到1之間。這是用一個稱為softmax的函數來計算的泪酱，結果保存在y_pred中派殷。

y_pred = tf.nn.softmax(logits)

可以從y_pred矩陣中取每行最大元素的索引值，來得到預測的類別墓阀。

y_pred_cls = tf.argmax(y_pred, dimension=1)

優(yōu)化損失函數

為了使模型更好地對輸入圖像進行分類毡惜，我們必須改變weights和biases變量。首先我們需要比較模型的預測輸出y_pred和期望輸出y_true斯撮，來了解目前模型的性能如何经伙。

交叉熵（cross-entropy）是一個在分類中使用的性能度量。交叉熵是一個常為正值的連續(xù)函數勿锅，如果模型的預測值精準地符合期望的輸出帕膜，它就等于零枣氧。因此，優(yōu)化的目的就是最小化交叉熵垮刹，通過改變模型中weights和biases的值作瞄，使交叉熵越接近零越好。

TensorFlow有一個內置的計算交叉熵的函數危纫。需要注意的是它使用logits的值宗挥，因為在它內部也計算了softmax。

cross_entropy = tf.nn.softmax_cross_entropy_with_logits(logits=logits,
                                                        labels=y_true)

現(xiàn)在种蝶，我們已經為每個圖像分類計算了交叉熵契耿，所以有一個當前模型在每張圖上的性能度量。但是為了用交叉熵來指導模型變量的優(yōu)化螃征，我們需要一個額外的標量值搪桂，因此我們簡單地利用所有圖像分類交叉熵的均值。

cost = tf.reduce_mean(cross_entropy)

優(yōu)化方法

現(xiàn)在盯滚，我們有一個需要被最小化的損失度量踢械，接著我們可以創(chuàng)建優(yōu)化器。在這種情況中魄藕，用的是梯度下降的基本形式内列，步長設為0.5。

優(yōu)化過程并不是在這里執(zhí)行背率。實際上话瞧，還沒計算任何東西，我們只是往TensorFlow圖中添加了優(yōu)化器寝姿，以便之后的操作交排。

optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.5).minimize(cost)

性能度量

我們需要另外一些性能度量，來向用戶展示這個過程饵筑。

這是一個布爾值向量埃篓，代表預測類型是否等于每張圖片的真實類型。

correct_prediction = tf.equal(y_pred_cls, y_true_cls)

上面先將布爾值向量類型轉換成浮點型向量根资，這樣子False就變成0架专，True變成1，然后計算這些值的平均數嫂冻，以此來計算分類的準確度胶征。

accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))

運行TensorFlow

創(chuàng)建TensorFlow會話（session）

一旦創(chuàng)建了TensorFlow圖塞椎，我們需要創(chuàng)建一個TensorFlow session桨仿，用來運行圖。

session = tf.Session()

初始化變量

我們需要在開始優(yōu)化weights和biases變量之前對它們進行初始化案狠。

session.run(tf.global_variables_initializer())

用來優(yōu)化迭代的幫助函數

在訓練集中有50,000張圖服傍。用這些圖像計算模型的梯度會花很多時間钱雷。因此我們利用隨機梯度下降的方法，它在優(yōu)化器的每次迭代里只用到了一小部分的圖像吹零。

batch_size = 100

函數執(zhí)行了多次的優(yōu)化迭代來逐步地提升模型的weights和biases罩抗。在每次迭代中，從訓練集中選擇一批新的數據灿椅，然后TensorFlow用這些訓練樣本來執(zhí)行優(yōu)化器套蒂。

def optimize(num_iterations):
    for i in range(num_iterations):
        # Get a batch of training examples.
        # x_batch now holds a batch of images and
        # y_true_batch are the true labels for those images.
        x_batch, y_true_batch = data.train.next_batch(batch_size)
        
        # Put the batch into a dict with the proper names
        # for placeholder variables in the TensorFlow graph.
        # Note that the placeholder for y_true_cls is not set
        # because it is not used during training.
        feed_dict_train = {x: x_batch,
                           y_true: y_true_batch}

        # Run the optimizer using this batch of training data.
        # TensorFlow assigns the variables in feed_dict_train
        # to the placeholder variables and then runs the optimizer.
        session.run(optimizer, feed_dict=feed_dict_train)

展示性能的幫助函數

測試集數據字典被當做TensorFlow圖的輸入。注意茫蛹，在TensorFlow圖中操刀，placeholder變量必須使用正確的名字。

feed_dict_test = {x: data.test.images,
                  y_true: data.test.labels,
                  y_true_cls: data.test.cls}

用來打印測試集分類準確度的函數婴洼。

def print_accuracy():
    # Use TensorFlow to compute the accuracy.
    acc = session.run(accuracy, feed_dict=feed_dict_test)
    
    # Print the accuracy.
    print("Accuracy on test-set: {0:.1%}".format(acc))

函數用scikit-learn打印并繪制混淆矩陣骨坑。

def print_confusion_matrix():
    # Get the true classifications for the test-set.
    cls_true = data.test.cls
    
    # Get the predicted classifications for the test-set.
    cls_pred = session.run(y_pred_cls, feed_dict=feed_dict_test)

    # Get the confusion matrix using sklearn.
    cm = confusion_matrix(y_true=cls_true,
                          y_pred=cls_pred)

    # Print the confusion matrix as text.
    print(cm)

    # Plot the confusion matrix as an image.
    plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)

    # Make various adjustments to the plot.
    plt.tight_layout()
    plt.colorbar()
    tick_marks = np.arange(num_classes)
    plt.xticks(tick_marks, range(num_classes))
    plt.yticks(tick_marks, range(num_classes))
    plt.xlabel('Predicted')
    plt.ylabel('True')

繪制測試集中誤分類圖像的函數。

def plot_example_errors():
    # Use TensorFlow to get a list of boolean values
    # whether each test-image has been correctly classified,
    # and a list for the predicted class of each image.
    correct, cls_pred = session.run([correct_prediction, y_pred_cls],
                                    feed_dict=feed_dict_test)

    # Negate the boolean array.
    incorrect = (correct == False)
    
    # Get the images from the test-set that have been
    # incorrectly classified.
    images = data.test.images[incorrect]
    
    # Get the predicted classes for those images.
    cls_pred = cls_pred[incorrect]

    # Get the true classes for those images.
    cls_true = data.test.cls[incorrect]
    
    # Plot the first 9 images.
    plot_images(images=images[0:9],
                cls_true=cls_true[0:9],
                cls_pred=cls_pred[0:9])

繪制模型權重的幫助函數

這個函數用來繪制模型的權重weights柬采。畫了10張圖像欢唾，訓練模型所識別出的每個數字對應著一張圖。

def plot_weights():
    # Get the values for the weights from the TensorFlow variable.
    w = session.run(weights)
    
    # Get the lowest and highest values for the weights.
    # This is used to correct the colour intensity across
    # the images so they can be compared with each other.
    w_min = np.min(w)
    w_max = np.max(w)

    # Create figure with 3x4 sub-plots,
    # where the last 2 sub-plots are unused.
    fig, axes = plt.subplots(3, 4)
    fig.subplots_adjust(hspace=0.3, wspace=0.3)

    for i, ax in enumerate(axes.flat):
        # Only use the weights for the first 10 sub-plots.
        if i<10:
            # Get the weights for the i'th digit and reshape it.
            # Note that w.shape == (img_size_flat, 10)
            image = w[:, i].reshape(img_shape)

            # Set the label for the sub-plot.
            ax.set_xlabel("Weights: {0}".format(i))

            # Plot the image.
            ax.imshow(image, vmin=w_min, vmax=w_max, cmap='seismic')

        # Remove ticks from each sub-plot.
        ax.set_xticks([])
        ax.set_yticks([])

優(yōu)化之前的性能

測試集上的準確度是9.8%粉捻。這是由于模型只做了初始化礁遣，并沒做任何優(yōu)化，所以它通常將圖像預測成數字零肩刃，正如下面繪制的圖像那樣亡脸，剛好測試集中9.8%的圖像是數字零。

print_accuracy()

Accuracy on test-set: 9.8%

plot_example_errors()

1次迭代優(yōu)化后的性能

在完成一次迭代優(yōu)化之后树酪，模型在測試集上的準確率從9.8%提高到了40.7%浅碾。這意味著它大約10次里面會誤分類6次，正如下面所顯示的续语。

optimize(num_iterations=1)

print_accuracy()

Accuracy on test-set: 40.7%

plot_example_errors()

下面繪制的是權重垂谢。正值為紅色，負值為藍色疮茄。這些權重可以直觀地理解為圖像濾波器滥朱。

例如，權重用來確定一張數字零的圖像對圓形圖像有正反應（紅色）力试，對圓形圖像的中間部分有負反應（藍色）徙邻。

類似的，權重也用來確定一張數字一的圖像對圖像中心垂直線段有正反應（紅色）畸裳，對線段周圍有負反應（藍色）缰犁。

注意到權重大多看起來跟它要識別的數字很像。這是因為只做了一次迭代，即權重只在100張圖像上訓練帅容。等經過上千張圖像的訓練之后颇象，權重會變得更難分辨，因為它們需要識別出數字的許多種書寫方法并徘。

plot_weights()

10次優(yōu)化迭代后的性能

# We have already performed 1 iteration.
optimize(num_iterations=9)

print_accuracy()

Accuracy on test-set: 78.2%

plot_example_errors()

plot_weights()

1000次迭代之后的性能

在迭代了1000次之后遣钳，模型在十次里面大約只誤識別了一次。如下圖所示麦乞，有些誤識別情有可原蕴茴，因為即使在人類眼里，也很難確定圖像（的數字）姐直，然而有一些圖像是很明顯的荐开，好的模型應該能分辨出來。但這個簡單的模型無法達到更好的性能简肴，因此需要更為復雜的模型晃听。

# We have already performed 10 iterations.
optimize(num_iterations=990)

print_accuracy()

Accuracy on test-set: 91.7%

plot_example_errors()

模型經過了1000次迭代訓練，每次迭代用到訓練集里面的100張圖像砰识。由于圖像的多樣化能扒，現(xiàn)在權重變得很難辨認，我們可能會懷疑這些權重是否真的理解數字是怎么由線條組成的辫狼，或者模型只是記住了許多不同的像素初斑。

plot_weights()

我們也可以打印并繪制出混淆矩陣，它讓我們看到誤分類的更多細節(jié)膨处。例如见秤，它展示了描繪著數字5的圖像有時會被誤分類成其他可能的數字，但大多是3真椿，6或8鹃答。

print_confusion_matrix()

[[ 957 0 3 2 0 5 11 1 1 0]
[ 0 1108 2 2 1 2 4 2 14 0]
[ 4 9 914 19 15 5 13 14 35 4]
[ 1 0 16 928 0 28 2 14 13 8]
[ 1 1 3 2 939 0 10 2 6 18]
[ 10 3 3 33 10 784 17 6 19 7]
[ 8 3 3 2 11 14 915 1 1 0]
[ 3 9 21 9 7 1 0 959 2 17]
[ 8 8 8 38 11 40 14 18 825 4]
[ 11 7 1 13 75 13 1 39 4 845]]

現(xiàn)在我們用TensorFlow完成了任務，關閉session突硝，釋放資源测摔。

# This has been commented out in case you want to modify and experiment
# with the Notebook without having to restart it.
# session.close()

練習

下面是一些可能會讓你提升TensorFlow技能的一些建議練習。為了學習如何更合適地使用TensorFlow解恰，實踐經驗是很重要的锋八。

在你對這個Notebook進行修改之前，可能需要先備份一下护盈。

• 改變優(yōu)化器的學習率挟纱。
• 改變優(yōu)化器，比如用AdagradOptimizer 或 AdamOptimizer腐宋。
• 將batch-size改為1或1000紊服。
• 這些改變如何影響性能檀轨？
• 你覺得這些改變對其他分類問題或數學模型有相同的影響嗎?
• 如果你不改變任何參數，多次運行Notebook围苫，會得到完成一樣的結果嗎？為什么撤师？
• 改變plot_example_errors() 函數剂府，使它打印誤分類的 logits和y_pred值。
• 用sparse_softmax_cross_entropy_with_logits 代替 softmax_cross_entropy_with_logits剃盾。這可能需要改變代碼的多個地方腺占。探討使用這兩中方法的優(yōu)缺點。
• 不看源碼痒谴，自己重寫程序衰伯。
• 向朋友解釋程序如何工作。

aimaster.png