# 三、機器學習入門 在本章中，我們將介紹以下主題： * 線性回歸 * MNIST 數據集 * 分類器 * 最近鄰算法 * 數據聚類 * K 均值算法 # 線性回歸算法 在本節中，我們將使用線性回歸算法開始對機器學習技術的探索。 我們的目標是建立一個模型，通過該模型從一個或多個自變量的值預測因變量的值。 這兩個變量之間的關系是線性的。 也就是說，如果`y`是因變量，`x`是因變量，則兩個變量之間的線性關系如下所示：`y = Ax + b`。 線性回歸算法可適應多種情況。 由于它的多功能性，它被廣泛應用于應用科學領域，例如生物學和經濟學。 此外，該算法的實現使我們能夠以一種完全清晰易懂的方式介紹機器學習的兩個重要概念：成本函數和**梯度下降算法**。 ## 數據模型 關鍵的第一步是建立我們的數據模型。 前面我們提到變量之間的關系是線性的，即：`y = Ax + b`，其中`A`和`b`是常數。 為了測試我們的算法，我們需要二維空間中的數據點。 我們首先導入 Python 庫 NumPy： ```py import numpy as np ``` 然后，我們定義要繪制的點數： ```py number_of_points = 500 ``` 我們初始化以下兩個列表： ```py x_point = [] y_point = [] ``` 這些點將包含生成的點。 然后，我們設置將出現在`y`與`x`的線性關系中的兩個常數： ```py a = 0.22 b = 0.78 ``` 通過 NumPy 的`random.normal`函數，我們在回歸方程`y = 0.22x + 0.78`周圍生成 300 個隨機點： ```py for i in range(number_of_points): x = np.random.normal(0.0,0.5) y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) y_point.append([y]) ``` 最后，通過`matplotlib`查看生成的點： ```py import matplotlib.pyplot as plt plt.plot(x_point,y_point, 'o', label='Input Data') plt.legend() plt.show() ```  線性回歸：數據模型 ### 成本函數和梯度下降 我們要用 TensorFlow 實現的機器學習算法必須根據我們的數據模型將`y`的值預測為`x`數據的函數。 線性回歸算法將確定常數`A`和`b`（已為我們的數據模型固定）的值，然后這些常數才是問題的真正未知數。 第一步是導入`tensorflow`庫： ```py import tensorflow as tf ``` 然后使用 TensorFlow `tf.Variable`定義`A`和`b`未知數： ```py A = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) ``` 使用`-1`和`1`之間的隨機值初始化未知因子`A`，而變量`b`最初設置為零： ```py b = tf.Variable(tf.zeros([1])) ``` 因此，我們寫了將`y`綁定到`x`的線性關系： ```py y = A * x_point + b ``` 現在，我們將介紹此*成本函數*：其參數包含一對要確定的值`A`和`b`，該參數將返回一個估計參數正確性的值。 在此示例中，我們的成本函數為*均方誤差*： ```py cost_function = tf.reduce_mean(tf.square(y - y_point)) ``` 它提供了對度量的可變性的估計，或更準確地說，是估計值在平均值附近的離散度； 該函數的較小值對應于未知參數`A`和`b`的最佳估計。 為了使`cost_function`最小化，我們使用*梯度下降*的優化算法。 給定幾個變量的數學函數，梯度下降允許找到該函數的局部最小值。 該技術如下： * **在函數域的任意第一個點求值函數本身及其梯度**。 梯度表示函數趨向于最小的方向。 * **在梯度指示的方向上選擇第二個點**。 如果此第二點的函數的值小于在第一點計算的值，則下降可以繼續。 您可以參考下圖來直觀地了解算法：  梯度下降算法 我們還指出，梯度下降只是*局部函數最小值*，但它也可以用于搜索全局最小值，一旦找到了局部最小值，便會隨機選擇一個新的起點，然后重復很多次。 如果函數的最小值的數量有限，并且嘗試的次數非常多，則很有可能早晚確定全局最小值。 使用 TensorFlow，該算法的應用非常簡單。 指令如下： ```py optimizer = tf.train.GradientDescentOptimizer(0.5) ``` 這里`0.5`是該算法的*學習率*。 學習速度決定了我們朝著最佳權重發展的速度是多快還是多慢。 如果太大，則跳過最佳解決方案；如果太大，則需要太多迭代才能收斂到最佳值。 提供了一個中間值（`0.5`），但是必須對其進行調整，以提高整個過程的表現。 我們通過其`minimize`函數將`train`定義為`cost_function`（`optimizer`）應用的結果： ```py train = optimizer.minimize(cost_function) ``` #### 測試模型 現在，我們可以在您之前創建的數據模型上測試梯度下降算法。 和往常一樣，我們必須初始化所有變量： ```py model = tf.initialize_all_variables() ``` 因此，我們構建了迭代（20 個計算步驟），使我們能夠確定`A`和`b`的最佳值，它們定義最適合數據模型的線。 實例化求值圖： ```py with tf.Session() as session: ``` 我們對模型進行仿真： ```py session.run(model) for step in range(0,21): ``` 對于每次迭代，我們執行優化步驟： ```py session.run(train) ``` 每隔五個步驟，我們將打印出點的圖形： ```py if (step % 5) == 0: plt.plot(x_point,y_point,'o', label='step = {}' .format(step)) ``` 直線是通過以下命令獲得的： ```py plt.plot(x_point, session.run(A) * x_point + session.run(B)) plt.legend() plt.show() ``` 下圖顯示了所實現算法的收斂性：  線性回歸：開始計算（步長`= 0`） 僅需五個步驟，我們就可以看到（在下圖中）該生產線的貼合性有了實質性的改進：  線性回歸：5 個計算步驟后的情況 下圖（最后一張圖）顯示了 20 個步驟后的確定結果。 我們可以看到所使用算法的效率，完美地跨越了點云的直線效率。  線性回歸：最終結果 最后，我們報告完整的代碼，以加深我們的理解： ```py import numpy as np import matplotlib.pyplot as plt import tensorflow as tf number_of_points = 200 x_point = [] y_point = [] a = 0.22 b = 0.78 for i in range(number_of_points): x = np.random.normal(0.0,0.5) y = a*x + b +np.random.normal(0.0,0.1) x_point.append([x]) y_point.append([y]) plt.plot(x_point,y_point, 'o', label='Input Data') plt.legend() plt.show() A = tf.Variable(tf.random_uniform([1], -1.0, 1.0)) B = tf.Variable(tf.zeros([1])) y = A * x_point + B cost_function = tf.reduce_mean(tf.square(y - y_point)) optimizer = tf.train.GradientDescentOptimizer(0.5) train = optimizer.minimize(cost_function) model = tf.initialize_all_variables() with tf.Session() as session: session.run(model) for step in range(0,21): session.run(train) if (step % 5) == 0: plt.plot(x_point,y_point,'o', label='step = {}' .format(step)) plt.plot(x_point, session.run(A) * x_point + session.run(B)) plt.legend() plt.show() ``` # MNIST 數據集 [MNIST 數據集](http://yann.lecun.com/exdb/mnist/)在機器學習領域中廣泛用于訓練和測試，我們將在這本書的示例中使用它。 它包含從 0 到 9 的手寫數字的黑白圖像。 數據集分為兩個組：60,000 個用于訓練模型，另外 10,000 個用于測試模型。 將黑白的原始圖像規格化以適合大小為`28×28`像素的盒子，并通過計算像素的質心來居中。 下圖表示如何在 MNIST 數據集中表示數字：  MNIST 數字采樣 每個 MNIST 數據點是一個數字數組，描述每個像素有多暗。 例如，對于以下數字（數字 1），我們可以有：  數字 1 的像素表示 ## 下載并準備數據 以下代碼導入了我們將要分類的 MNIST 數據文件。 我正在使用 Google 提供的腳本，[可以從以下位置下載該腳本](https://github.com/tensorflow/tensorflow/blob/r0.7/tensorflow/examples/tutorials/mnist/input_data.py)。 它必須在文件所在的同一文件夾中運行。 現在，我們將展示如何加載和顯示數據： ```py import input_data import numpy as np import matplotlib.pyplot as plt ``` 使用`input_data`，我們加載數據集： ```py mnist_images = input_data.read_data_sets\ ("MNIST_data/",\ one_hot=False) train.next_batch(10) returns the first 10 images : pixels,real_values = mnist_images.train.next_batch(10) ``` 這還會返回兩個列表：加載的像素矩陣和包含加載的實數值的列表： ```py print "list of values loaded ",real_values example_to_visualize = 5 print "element N° " + str(example_to_visualize + 1)\ + " of the list plotted" >> Extracting MNIST_data/train-labels-idx1-ubyte.gz Extracting MNIST_data/t10k-images-idx3-ubyte.gz Extracting MNIST_data/t10k-labels-idx1-ubyte.gz list of values loaded [7 3 4 6 1 8 1 0 9 8] element N 6 of the list plotted >> ``` 在顯示元素時，我們可以使用 matplotlib，如下所示： ```py image = pixels[example_to_visualize,:] image = np.reshape(image,[28,28]) plt.imshow(image) plt.show() ``` 結果如下：  MNIST 的數字八 # 分類器 在機器學習的上下文中，術語*分類*標識一種算法過程，該算法過程將每個新的輸入數據（*實例*）分配給一種可能的類別（*類*） 。 如果只考慮兩個類，我們將討論二分類。 否則我們有一個多類分類。 該分類屬于*監督學習*類別，這使我們可以根據所謂的*訓練集*對新實例進行分類。 解決監督分類問題的基本步驟如下： 1. 構建訓練示例，以表示完成分類的實際環境和應用。 2. 選擇分類器和相應的算法實現。 3. 在訓練集上訓練算法，并通過驗證設置任何控制參數。 4. 通過應用一組新實例（測試集）評估分類器的準確率和表現。 ## 最近鄰算法 **K 最近鄰**（**KNN**）是用于分類或回歸的監督學習算法。 它是一個系統，根據其與內存中存儲的對象之間的距離來分配測試樣本的類別。 距離`d`定義為兩點之間的歐幾里得距離：  `n`是空間的尺寸。 這種分類方法的優點是能夠對類別*無法線性分離*的對象進行分類。 考慮到訓練數據的*小擾動*不會顯著影響結果，因此這是一個穩定的分類器。 但是，最明顯的缺點是它不能提供真正的數學模型。 相反，對于每個新分類，應通過將新數據添加到所有初始實例并針對所選 K 值重復計算過程來執行。 此外，它需要相當大量的數據才能進行實際的預測，并且對分析數據的噪聲敏感。 在下一個示例中，我們將使用 MNIST 數據集實現 KNN 算法。 ### 建立訓練集 讓我們從模擬所需的導入庫開始： ```py import numpy as np import tensorflow as tf import input_data ``` 要構建訓練集的數據模型，請使用前面介紹的`input_data.read_data_sets`函數： ```py mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) ``` 在我們的示例中，我們將進行訓練階段，該階段包括 100 個 MNIST 圖像： ```py train_pixels,train_list_values = mnist.train.next_batch(100) ``` 在測試`10`圖像的算法時： ```py test_pixels,test_list_of_values = mnist.test.next_batch(10) ``` 最后，我們定義用于構建分類器的張量`train_pixel_tensor`和`test_pixel_tensor`： ```py train_pixel_tensor = tf.placeholder\ ("float", [None, 784]) test_pixel_tensor = tf.placeholder\ ("float", [784]) ``` ### 成本函數和優化 成本函數由距離表示，以像素為單位： ```py distance = tf.reduce_sum\ (tf.abs\ (tf.add(train_pixel_tensor, \ tf.neg(test_pixel_tensor))), \ reduction_indices=1) ``` `tf.reduce`函數 sum 用于計算張量維度上的元素之和。 例如（摘自 TensorFlow 在線手冊）： ```py # 'x' is [[1, 1, 1] # [1, 1, 1]] tf.reduce_sum(x) ==> 6 tf.reduce_sum(x, 0) ==> [2, 2, 2] tf.reduce_sum(x, 1) ==> [3, 3] tf.reduce_sum(x, 1, keep_dims=True) ==> [[3], [3]] tf.reduce_sum(x, [0, 1]) ==> 6 ``` 最后，為了最小化距離函數，我們使用`arg_min`，它返回距離最小（最近鄰）的索引： ```py pred = tf.arg_min(distance, 0) ``` #### 測試和算法評估 準確率是可以幫助我們計算分類器最終結果的參數： ```py accuracy = 0 ``` 初始化變量： ```py init = tf.initialize_all_variables() ``` 開始模擬： ```py with tf.Session() as sess: sess.run(init) for i in range(len(test_list_of_values)): ``` 然后，我們使用前面定義的`pred`函數求值最近的鄰居索引： ```py nn_index = sess.run(pred,\ feed_dict={train_pixel_tensor:train_pixels,\ test_pixel_tensor:test_pixels[i,:]}) ``` 最后，我們找到最近的鄰居類標簽，并將其與其真實標簽進行比較： ```py print "Test N° ", i,"Predicted Class: ", \ np.argmax(train_list_values[nn_index]),\ "True Class: ", np.argmax(test_list_of_values[i]) if np.argmax(train_list_values[nn_index])\ == np.argmax(test_list_of_values[i]): ``` 然后，我們求值并報告分類器的準確率： ```py accuracy += 1./len(test_pixels) print "Result = ", accuracy ``` 如我們所見，訓練集的每個元素均已正確分類。 仿真結果顯示了預測類和真實類，最后報告了仿真的總值： ```py >>> Extracting /tmp/data/train-labels-idx1-ubyte.gz Extracting /tmp/data/t10k-images-idx3-ubyte.gz Extracting /tmp/data/t10k-labels-idx1-ubyte.gz Test N° 0 Predicted Class: 7 True Class: 7 Test N° 1 Predicted Class: 2 True Class: 2 Test N° 2 Predicted Class: 1 True Class: 1 Test N° 3 Predicted Class: 0 True Class: 0 Test N° 4 Predicted Class: 4 True Class: 4 Test N° 5 Predicted Class: 1 True Class: 1 Test N° 6 Predicted Class: 4 True Class: 4 Test N° 7 Predicted Class: 9 True Class: 9 Test N° 8 Predicted Class: 6 True Class: 5 Test N° 9 Predicted Class: 9 True Class: 9 Result = 0.9 >>> ``` 結果不是 100% 準確； 原因是在于對測試編號的錯誤評估。 8 代替 5，分類器的評分為 6。 最后，我們報告用于 KNN 分類的完整代碼： ```py import numpy as np import tensorflow as tf import input_data #Build the Training Set ``` ```py mnist = input_data.read_data_sets("/tmp/data/", one_hot=True) train_pixels,train_list_values = mnist.train.next_batch(100) test_pixels,test_list_of_values = mnist.test.next_batch(10) train_pixel_tensor = tf.placeholder\ ("float", [None, 784]) test_pixel_tensor = tf.placeholder\ ("float", [784]) #Cost Function and distance optimization distance = tf.reduce_sum\ (tf.abs\ (tf.add(train_pixel_tensor, \ tf.neg(test_pixel_tensor))), \ reduction_indices=1) pred = tf.arg_min(distance, 0) # Testing and algorithm evaluation accuracy = 0. init = tf.initialize_all_variables() with tf.Session() as sess: sess.run(init) for i in range(len(test_list_of_values)): nn_index = sess.run(pred,\ feed_dict={train_pixel_tensor:train_pixels,\ test_pixel_tensor:test_pixels[i,:]}) print "Test N° ", i,"Predicted Class: ", \ np.argmax(train_list_values[nn_index]),\ "True Class: ", np.argmax(test_list_of_values[i]) if np.argmax(train_list_values[nn_index])\ == np.argmax(test_list_of_values[i]): accuracy += 1./len(test_pixels) print "Result = ", accuracy ``` # 數據聚類 聚類問題包括從一組初始數據中選擇和分組同類項目。 為了解決這個問題，我們必須： * 確定元素之間的*相似度*度量 * 找出是否存在與所選測度*類似*的元素子集 該算法確定哪些元素構成一個簇，以及在簇內將它們組合在一起的相似程度。 聚類算法屬于*無監督方法*，因為我們不假設有關聚類結構和特征的任何先驗信息。 ## K 均值算法 K 均值是最常見和最簡單的*聚類算法*之一，它可以根據對象的屬性將對象組細分為 k 個分區。 每個簇由*點*或*質心平均值*標識。 該算法遵循一個迭代過程： 1. 隨機選擇 K 個點作為初始質心。 2. 重復： 3. 通過將所有點分配給最接近的質心來形成表格 K 的聚類。 4. 重新計算每個群集的質心。 5. 直到質心不變。 K 均值的流行來自其*收斂速度*和其*易于實現*。 就解決方案的質量而言，該算法不能保證實現全局最優。 最終解決方案的質量在很大程度上取決于集群的*初始集*，并且在實踐中可能會獲得更差的全局最優解。 由于該算法非常快，因此您可以多次應用它，并提供解決方案，您可以從中選擇最滿意的一種。 該算法的另一個缺點是，它要求您選擇要查找的簇數（`k`）。 如果數據不是自然分區的，您將最終得到奇怪的結果。 此外，該算法僅在數據中存在可識別的球形簇時才有效。 現在讓我們看看如何通過 TensorFlow 庫實現 K 均值。 ## 建立訓練集 將所有必需的庫導入到我們的仿真中： ```py import matplotlib.pyplot as plt import numpy as np import tensorflow as tf import pandas as pd ``` ### 注意 Pandas 是適用于 Python 編程語言的開源，易于使用的數據結構和數據分析工具。 要安裝它，請鍵入以下命令： ```py sudo pip install pandas ``` 我們必須定義問題的參數。 我們要聚類的總點數為`1000`分： ```py num_vectors = 1000 ``` 您要通過所有首字母實現的分區數： ```py num_clusters = 4 ``` 我們設置 K 均值算法的計算步驟數： ```py num_steps = 100 ``` 我們初始化初始輸入數據結構： ```py x_values = [] y_values = [] vector_values = [] ``` *訓練集*創建了一個隨機的點集，這就是為什么我們使用`random.normal` NumPy 函數，從而允許我們構建`x_values`和`y_values`向量的原因： ```py for i in xrange(num_vectors): if np.random.random() > 0.5: x_values.append(np.random.normal(0.4, 0.7)) y_values.append(np.random.normal(0.2, 0.8)) else: x_values.append(np.random.normal(0.6, 0.4)) y_values.append(np.random.normal(0.8, 0.5)) ``` 我們使用 Python 的`zip`函數來獲取`vector_values`的完整列表： ```py vector_values = zip(x_values,y_values) ``` 然后，`vector_values`轉換為可由 TensorFlow 使用的常量： ```py vectors = tf.constant(vector_values) ``` 我們可以使用以下命令查看用于聚類算法的*訓練集*： ```py plt.plot(x_values,y_values, 'o', label='Input Data') plt.legend() plt.show() ```  K 均值訓練集 在隨機構建訓練集之后，我們必須生成（`k = 4`）重心，然后使用`tf.random_shuffle`確定索引： ```py n_samples = tf.shape(vector_values)[0] random_indices = tf.random_shuffle(tf.range(0, n_samples)) ``` 通過采用此過程，我們能夠確定四個隨機指數： ```py begin = [0,] size = [num_clusters,] size[0] = num_clusters ``` 它們具有我們初始質心的索引： ```py centroid_indices = tf.slice(random_indices, begin, size) centroids = tf.Variable(tf.gather\ (vector_values, centroid_indices)) ``` ## 成本函數和優化 我們要針對此問題最小化的成本函數再次是兩點之間的歐式距離：  為了管理先前定義的張量`vectors`和`centroids`，我們使用 TensorFlow 函數`expand_dims`，該函數自動擴展兩個參數的大小： ```py expanded_vectors = tf.expand_dims(vectors, 0) expanded_centroids = tf.expand_dims(centroids, 1) ``` 此函數允許您標準化兩個張量的形狀，以便通過`tf.sub`方法求值差異： ```py vectors_subtration = tf.sub(expanded_vectors,expanded_centroids) ``` 最后，我們使用`tf.reduce_sum`函數構建`euclidean_distances`成本函數，該函數計算張量維度上的元素總和，而`tf.square`函數計算`vectors_subtration`元素張量的平方： ```py euclidean_distances = tf.reduce_sum(tf.square\ (vectors_subtration), 2) assignments = tf.to_int32(tf.argmin(euclidean_distances, 0)) ``` 此處`assignments`是跨張量`euclidean_distances`的距離最小的索引值。 現在讓我們進入優化階段，其目的是改善質心的選擇，而質心的構建依賴于質心的構建。 我們使用`assignments`的索引將`vectors`（這是我們的*訓練集*）劃分為`num_clusters`張量。 以下代碼獲取每個樣本的最近索引，并使用`tf.dynamic_partition`將它們作為單獨的組獲取： ```py partitions = tf.dynamic_partition\ (vectors, assignments, num_clusters) ``` 最后，我們對單個組使用`tf.reduce_mean`更新質心，以找到該組的平均值，從而形成其新質心： ```py update_centroids = tf.concat(0, \ [tf.expand_dims\ (tf.reduce_mean(partition, 0), 0)\ for partition in partitions]) ``` 為了形成`update_centroids`張量，我們使用`tf.concat`連接單個張量。 ### 測試和算法評估 現在是測試和評估算法的時候了。 第一個過程是初始化所有變量并實例化求值圖： ```py init_op = tf.initialize_all_variables() sess = tf.Session() sess.run(init_op) ``` 現在我們開始計算： ```py for step in xrange(num_steps): _, centroid_values, assignment_values =\ sess.run([update_centroids,\ centroids,\ assignments]) ``` 為了顯示結果，我們實現以下函數： ```py display_partition(x_values,y_values,assignment_values) ``` 這將使用訓練集的`x_values`和`y_values`向量以及`assignemnt_values`向量來繪制聚類。 此可視化函數的代碼如下： ```py def display_partition(x_values,y_values,assignment_values): labels = [] colors = ["red","blue","green","yellow"] for i in xrange(len(assignment_values)): labels.append(colors[(assignment_values[i])]) color = labels df = pd.DataFrame\ (dict(x =x_values,y = y_values ,color = labels )) fig, ax = plt.subplots() ax.scatter(df['x'], df['y'], c=df['color']) plt.show() ``` 它通過以下數據結構將每個顏色的顏色關聯到每個群集： ```py colors = ["red","blue","green","yellow"] ``` 然后通過 matplotlib 的`scatter`函數繪制它們： ```py ax.scatter(df['x'], df['y'], c=df['color']) ``` 讓我們顯示結果：  k-means 算法的最終結果 這是 K 均值算法的完整代碼： ```py import matplotlib.pyplot as plt import numpy as np import pandas as pd import tensorflow as tf def display_partition(x_values,y_values,assignment_values): labels = [] colors = ["red","blue","green","yellow"] for i in xrange(len(assignment_values)): labels.append(colors[(assignment_values[i])]) color = labels df = pd.DataFrame\ (dict(x =x_values,y = y_values ,color = labels )) fig, ax = plt.subplots() ax.scatter(df['x'], df['y'], c=df['color']) plt.show() num_vectors = 2000 num_clusters = 4 n_samples_per_cluster = 500 num_steps = 1000 x_values = [] y_values = [] vector_values = [] # CREATE RANDOM DATA for i in xrange(num_vectors): if np.random.random() > 0.5: x_values.append(np.random.normal(0.4, 0.7)) y_values.append(np.random.normal(0.2, 0.8)) else: x_values.append(np.random.normal(0.6, 0.4)) y_values.append(np.random.normal(0.8, 0.5)) vector_values = zip(x_values,y_values) vectors = tf.constant(vector_values) n_samples = tf.shape(vector_values)[0] random_indices = tf.random_shuffle(tf.range(0, n_samples)) begin = [0,] size = [num_clusters,] size[0] = num_clusters centroid_indices = tf.slice(random_indices, begin, size) centroids = tf.Variable(tf.gather(vector_values, centroid_indices)) expanded_vectors = tf.expand_dims(vectors, 0) expanded_centroids = tf.expand_dims(centroids, 1) vectors_subtration = tf.sub(expanded_vectors,expanded_centroids) euclidean_distances = \tf.reduce_sum(tf.square(vectors_subtration), 2) assignments = tf.to_int32(tf.argmin(euclidean_distances, 0)) partitions = [0, 0, 1, 1, 0] num_partitions = 2 data = [10, 20, 30, 40, 50] outputs[0] = [10, 20, 50] outputs[1] = [30, 40] partitions = tf.dynamic_partition(vectors, assignments, num_clusters) update_centroids = tf.concat(0, [tf.expand_dims (tf.reduce_mean(partition, 0), 0)\ for partition in partitions]) init_op = tf.initialize_all_variables() sess = tf.Session() sess.run(init_op) for step in xrange(num_steps): _, centroid_values, assignment_values =\ sess.run([update_centroids,\ centroids,\ assignments]) display_partition(x_values,y_values,assignment_values) plt.plot(x_values,y_values, 'o', label='Input Data') plt.legend() plt.show() ``` # 總結 在本章中，我們開始探索 TensorFlow 在機器學習中一些典型問題的潛力。 使用*線性回歸*算法，解釋了*成本函數*和使用*梯度下降*進行優化的重要概念。 然后，我們描述了手寫數字的數據集 MNIST。 我們還使用*最近鄰*算法實現了多類分類器，該分類器屬于機器學習*監督學習*類別。 然后，本章以實現數據聚類問題的 K 均值算法為例，以*無監督學習*為例。 在下一章中，我們將介紹神經網絡。 這些是代表定義為*人工神經元*的元素之間相互聯系的數學模型，即模仿活神經元特性的數學構造。 我們還將使用 TensorFlow 實現一些神經網絡學習模型。