# 二、回歸 本章說明如何使用 TensorFlow 進行回歸。 在本章中，我們將介紹以下主題： * 選擇損失函數 * TensorFlow 中的優化器 * 從 CSV 文件讀取和預處理數據 * 房價估計 -- 簡單線性回歸 * 房價估計 -- 多元線性回歸 * MNIST 數據集上的邏輯回歸 # 介紹 回歸是用于數學建模，分類和預測的最古老但功能非常強大的工具之一。 回歸在工程，物理科學，生物學，金融市場到社會科學等各個領域都有應用。 它是數據科學家手中的基本工具。 回歸通常是機器學習中人們使用的第一個算法。 它使我們能夠通過學習因變量和自變量之間的關系來根據數據進行預測。 例如，在房價估計的情況下，我們確定房屋面積（**自變量**）與其價格（**因變量**）之間的關系； 然后，可以使用這種關系來預測給定房屋面積的任何房屋的價格。 我們可以有多個影響因變量的自變量。 因此，回歸有兩個重要的組成部分：自變量和因變量之間的**關系**，以及不同自變量對因變量的**影響強度**。 有多種可用的回歸方法： * **線性回歸**：這是最廣泛使用的建模技術之一。 它已有 200 多年的歷史，幾乎從所有可能的角度進行了探索。 線性回歸假設輸入變量（`X`）和單個輸出變量（`Y`）之間存在**線性關系**。 它涉及尋找以下形式的預測值`Y`的線性方程：  在這里，`X = (x[1], x[2], ..., x[n])`是`n`個輸入變量和`W = (w[1], w[2], ... w[n])`是線性系數，以`b`為偏差項。 目標是找到系數`W`的最佳估計，以使預測`Y`的誤差最小。 線性系數`W`使用最小二乘法估計，即最小化預測值（`Y_hat`）和值（`Y`）之間的平方差之和。因此，我們嘗試最小化*損失*函數：  在這里，總和是所有訓練樣本的總和。 根據輸入變量`X`的數量和類型，可以使用不同類型的線性回歸：簡單線性回歸（一個輸入變量，一個輸出變量），多個線性回歸（許多獨立輸入變量，一個輸出變量） ）或多元線性回歸（許多獨立的輸入變量和多個輸出變量）。 有關線性回歸的更多信息，請參考[這個頁面](https://en.wikipedia.org/wiki/Linear_regression)。 * **Logistic 回歸**：用于確定事件的概率。 按照慣例，事件表示為分類因變量。 使用`logit`函數（`sigmoid`函數）表示事件的可能性：  現在的目標是估計權重`W = (w1, w2, ... wn)`和偏差項`b`。 在邏輯回歸中，使用最大似然估計器或隨機梯度下降法估計系數。 通常將損耗定義為互熵項，如下所示：  Logistic 回歸用于分類問題，例如，給定醫學數據，我們可以使用 Logistic 回歸對一個人是否患有癌癥進行分類。 如果輸出分類變量具有兩個或多個級別，則可以使用多項邏輯回歸。 用于兩個或多個輸出變量的另一種常用技術是“一對多”。 對于多類邏輯回歸，對交叉熵*損失*函數的修改如下：  在此， `K`是類別的總數。 有關邏輯回歸的更多信息，請參見[這個頁面](https://en.wikipedia.org/wiki/Logistic_regression)。 這是兩種常用的回歸技術。 * **正則化**：當存在大量輸入特征時，需要進行正則化以確保預測的模型不復雜。 正則化有助于防止數據過擬合。 它還可以用于獲得凸的*損失*函數。 有兩種類型的正則化，L1 和 L2 正則化，在以下幾點中進行了描述：   在希臘字母上方，lambda（`λ`）是正則化參數。 # 選擇損失函數 如前所述，在回歸中，我們定義`loss`函數或目標函數，目的是找到使損失最小的系數。 在本秘籍中，您將學習如何在 TensorFlow 中定義`loss`函數，并根據眼前的問題選擇合適的`loss`函數。 # 準備 聲明`loss`函數需要將系數定義為變量，將數據集定義為占位符。 一個人可以具有恒定的學習率或變化的學習率和正則化常數。 在以下代碼中，令`m`為樣本數，`n`為特征數，`P`為類數。 我們應該在代碼之前定義以下全局參數： ```py m = 1000 n = 15 P = 2 ``` # 操作步驟 現在讓我們看一下如何進行秘籍： 1. 在標準線性回歸的情況下，我們只有一個輸入變量和一個輸出變量： ```py # Placeholder for the Training Data X = tf.placeholder(tf.float32, name='X') Y = tf.placeholder(tf.float32, name='Y') # Variables for coefficients initialized to 0 w0 = tf.Variable(0.0) w1 = tf.Variable(0.0) # The Linear Regression Model Y_hat = X*w1 + w0 # Loss function loss = tf.square(Y - Y_hat, name='loss') ``` 2. 在多元線性回歸的情況下，輸入變量大于 1，而輸出變量保持為 1。 現在，您可以定義形狀為`[m, n]`的`X`占位符，其中`m`是樣本數，`n`是特征數，然后代碼如下： ```py # Placeholder for the Training DataX = tf.placeholder(tf.float32, name='X', shape=[m,n]) Y = tf.placeholder(tf.float32, name='Y') # Variables for coefficients initialized to 0w0 = tf.Variable(0.0) w1 = tf.Variable(tf.random_normal([n,1])) # The Linear Regression ModelY_hat = tf.matmul(X, w1) + w0 # Multiple linear regression loss functionloss = tf.reduce_mean(tf.square(Y - Y_hat, name='loss') ``` 3. 在邏輯回歸的情況下，`loss`函數由交叉熵定義。 現在，輸出`Y`的尺寸將等于訓練數據集中的類數。 通過`P`個類，我們將具有以下內容： ```py # Placeholder for the Training DataX = tf.placeholder(tf.float32, name='X', shape=[m,n]) Y = tf.placeholder(tf.float32, name='Y', shape=[m,P]) # Variables for coefficients initialized to 0w0 = tf.Variable(tf.zeros([1,P]), name=’bias’) w1 = tf.Variable(tf.random_normal([n,1]), name=’weights’) # The Linear Regression ModelY_hat = tf.matmul(X, w1) + w0 # Loss functionentropy = tf.nn.softmax_cross_entropy_with_logits(Y_hat,Y) loss = tf.reduce_mean(entropy) ``` 4. 如果我們要對損失添加 L1 正則化，則代碼如下： ```py lamda = tf.constant(0.8) # regularization parameter regularization_param = lamda*tf.reduce_sum(tf.abs(W1)) # New loss loss += regularization_param ``` 5. 對于 L2 正則化，我們可以使用以下代碼： ```py lamda = tf.constant(0.8) # regularization parameter regularization_param = lamda*tf.nn.l2_loss(W1) # New loss loss += regularization_param ``` # 工作原理 您學習了如何實現不同類型的`loss`函數。 根據手頭的回歸任務，您可以選擇相應的`loss`函數或自行設計。 也可以在損耗項中組合 L1 和 L2 正則化。 # 更多 `loss`函數應為凸形以確保收斂。 平滑，可微凸的`loss`函數可提供更好的收斂性。 隨著學習的進行，`loss`函數的值應減小并最終變得穩定。 # TensorFlow 中的優化器 從中學數學開始，您必須知道函數的一階導數的最大值和最小值為零。 梯度下降算法基于相同的原理-調整系數（權重和偏差），以使`loss`函數的梯度減小。 在回歸中，我們使用梯度下降來優化`loss`函數并獲得系數。 在本秘籍中，您將學習如何使用 TensorFlow 的梯度下降優化器及其某些變體。 # 準備 系數（`W`和`b`）的更新與`loss`函數的梯度的負值成比例地完成。 根據訓練樣本的大小，梯度下降有三種變化： * **普通梯度下降**：在普通梯度下降（有時也稱為**全量梯度下降**）中，為每個周期的整個訓練集計算`loss`函數的梯度。 對于非常大的數據集，此過程可能很慢且難以處理。 對于凸`loss`函數，可以保證收斂到全局最小值，但是對于非凸`loss`函數，可以收斂到局部最小值。 * **隨機梯度下降**：在隨機梯度下降中，一次顯示一個訓練樣本，權重和偏差得到更新，以使`loss`函數的梯度減小，然后我們移至下一個訓練樣本 。 重復整個過程許多周期。 由于它一次執行一次更新，因此它比普通更新要快，但是同時，由于頻繁更新，`loss`函數可能會有很大差異。 * **小批量梯度下降**：結合了前兩種產品的最佳質量； 在這里，為一批訓練樣本更新了參數。 # 操作步驟 我們按以下步驟進行： 1. 我們決定的第一件事是我們想要的優化器。 TensorFlow 為您提供了各種各樣的優化器。 我們從最流行，最簡單的梯度下降優化器開始： ```py tf.train.GradientDescentOptimizer(learning_rate) ``` 2. `GradientDescentOptimizer`的`learning_rate`參數可以是常數或張量。 其值可以在 0 到 1 之間。 3. 必須告知優化器要優化的函數。 這是使用其方法來完成的，最小化。 該方法計算梯度并將梯度應用于學習系數。 TensorFlow 文檔中定義的函數如下： ```py minimize( loss, global_step=None, var_list=None, gate_gradients=GATE_OP, aggregation_method=None, colocate_gradients_with_ops=False, name=None, grad_loss=None ) ``` 4. 結合所有這些，我們定義計算圖： ```py ... optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01) train_step = optimizer.minimize(loss) ... #Execution Graph with tf.Session() as sess: ... sess.run(train_step, feed_dict = {X:X_data, Y:Y_data}) ... ``` 5. 饋送到`feed_dict`的`X`和`Y`數據可以是單個`X`和`Y`點（隨機梯度），整個訓練集（普通）或批次。 6. 梯度下降的另一個變化是增加了動量項（我們將在第 3 章“神經網絡感知機”中找到更多相關信息）。 為此，我們使用優化器`tf.train.MomentumOptimizer()`。 它同時將`learning_rate`和`momentum`作為`init`參數： ```py optimizer = tf.train.MomentumOtimizer(learning_rate=0.01, momentum=0.5).minimize(loss) ``` 7. 如果使用`tf.train.AdadeltaOptimizer()`，則可以自適應地單調降低學習率，它使用兩個`init`自變量`learning_rate`和衰減因子`rho`： ```py optimizer = tf.train.AdadeltaOptimizer(learning_rate=0.8, rho=0.95).minimize(loss) ``` 8. TensorFlow 還支持 Hinton 的 RMSprop，其工作方式類似于 Adadelta -- `tf.train.RMSpropOptimizer()`： ```py optimizer = tf.train.RMSpropOptimizer(learning_rate=0.01, decay=0.8, momentum=0.1).minimize(loss) ``` Adadelta 和 RMSprop 之間有一些細微的差異。 要了解有關它們的更多信息，可以參考[這里](http://www.cs.toronto.edu/~tijmen/csc321/slides/lecture_slides_lec6.pdf)和[這里](https://arxiv.org/pdf/1212.5701.pdf)。 9. TensorFlow 支持的另一種流行的優化器是 Adam 優化器。 該方法使用第一個和第二個梯度矩的估計來計算不同系數的個體自適應學習率： ```py optimizer = tf.train.AdamOptimizer().minimize(loss) ``` 10. 除了這些，TensorFlow 還提供以下優化器： ```py tf.train.AdagradOptimizer #Adagrad Optimizer tf.train.AdagradDAOptimizer #Adagrad Dual Averaging optimizer tf.train.FtrlOptimizer #Follow the regularized leader optimizer tf.train.ProximalGradientDescentOptimizer #Proximal GD optimizer tf.train.ProximalAdagradOptimizer # Proximal Adagrad optimizer ``` # 更多 通常建議您從較高的學習率值入手，并隨著學習的進行逐漸降低。 這有助于對訓練進行微調。 我們可以使用 TensorFlow `tf.train.exponential_decay`方法來實現。 根據 TensorFlow 文檔： 訓練模型時，通常建議隨著訓練的進行降低學習率。 此函數將指數衰減函數應用于提供的初始學習率。 它需要一個`global_step`值來計算衰減的學習率。 您可以只傳遞一個 TensorFlow 變量，該變量在每個訓練步驟中都會遞增。該函數返回遞減的學習率。 參數： + `learning_rate`: `float32`或`float64`標量張量或 Python 數字。 初始學習率。 + `global_step`: `float32`或`float64`標量張量或 Python 數字。 用于衰減計算的全局步長。 不能為負。 + `decay_steps`: `float32`或`float64`標量張量或 Python 數字。 必須是正的。 請參閱前面介紹的衰減計算。 + `decay_rate`: `float32`或`float64`標量張量或 Python 數字。 衰減率。 + `staircase`: 布爾值。 如果`True`，在離散時間間隔衰減學習率。 + `name`: 字符串。 操作的可選名稱。 默認為`'ExponentialDecay'`。 返回值： 與`learning_rate`類型相同的標量張量。 學習率衰減。 要實現指數衰減的學習率，請考慮以下代碼示例： ```py global_step = tf.Variable(0, trainable = false) initial_learning_rate = 0.2 learning_rate = tf.train.exponential_decay(initial_learning_rate, global_step, decay_steps=100000, decay_rate=0.95, staircase=True) # Pass this learning rate to optimizer as before. ``` # 另見 以下是一些針對不同優化器的良好鏈接： * [Arxiv 1609.04747](https://arxiv.org/pdf/1609.04747.pdf) ：該白皮書很好地概述了各種優化算法。 * [這是 TensorFlow.org 鏈接](https://www.tensorflow.org/api_guides/python/train#Optimizers)，其中詳細介紹了如何使用 TensorFlow 中包含的不同優化器。 * [Arxiv 1412.6980](https://arxiv.org/pdf/1412.6980.pdf)：有關 Adam 優化器的論文。 # 從 CSV 文件讀取和預處理數據 你們大多數人已經熟悉 Pandas 及其在處理大型數據集文件中的實用性。 TensorFlow 還提供了讀取文件的方法。 在第一章中，我們介紹了從 TensorFlow 中讀取文件的方法。 在本秘籍中，我們將重點介紹如何在訓練之前從 CSV 文件讀取和預處理數據。 # 準備 我們將考慮 Harrison 和 Rubinfield 在 1978 年收集的[波士頓住房價格數據集](http://lib.stat.cmu.edu/datasets/boston)。該數據集包含 506 個樣本案例。 每個房屋都有 14 個屬性： * **`CRIM`**：按城鎮劃分的人均犯罪率 * **`ZN`**：已劃定 25,000 平方英尺以上土地的居住用地比例 * **`INDIA`**：每個城鎮的非零售營業面積比例 * **`CHAS`**：查爾斯河虛擬變量（如果束縛河，則為 1；否則為 0） * **`NOX`**：一氧化氮濃度（百萬分之幾） * **`RM`**：每個住宅的平均房間數 * **`AGE`**：1940 年之前建造的自有住房的比例 * **`DIS`**：到五個波士頓就業中心的加權距離 * **`RAD`**：徑向公路的可達性指數 * **`TAX`**：每 10,000 美元的全值財產稅率 * **`PTRATIO`**：按城鎮劃分的師生比率 * **`B`**：`1000(Bk-0.63)^2`，其中`Bk`是按城鎮劃分的黑人比例 * **`LSTAT`**：人口狀況降低的百分比 * **`MEDV`**：自有住房的中位數價值，單位為 1,000 美元 # 操作步驟 我們按以下步驟進行： 1. 導入所需的模塊并聲明全局變量： ```py import tensorflow as tf # Global parameters DATA_FILE = 'boston_housing.csv' BATCH_SIZE = 10 NUM_FEATURES = 14 ``` 2. 接下來，我們定義一個函數，該函數將文件名作為參數，并以等于`BATCH_SIZE`的大小批量返回張量： ```py defdata_generator(filename): """ Generates Tensors in batches of size Batch_SIZE. Args: String Tensor Filename from which data is to be read Returns: Tensors feature_batch and label_batch """ ``` 3. 定義文件名`f_queue`和`reader`： ```py f_queue = tf.train.string_input_producer(filename) reader = tf.TextLineReader(skip_header_lines=1) # Skips the first line _, value = reader.read(f_queue) ``` 4. 我們指定了數據缺失時要使用的數據。 解碼`.csv`并選擇我們需要的特征。 對于示例，我們選擇`RM`，`PTRATIO`和`LSTAT`： ```py record_defaults = [ [0.0] for _ in range(NUM_FEATURES)] data = tf.decode_csv(value, record_defaults=record_defaults) features = tf.stack(tf.gather_nd(data,[[5],[10],[12]])) label = data[-1] ``` 5. 定義參數以生成批量，并使用`tf.train.shuffle_batch()`隨機調整張量。 函數返回張量-`feature_batch`和`label_batch`： ```py # minimum number elements in the queue after a dequeuemin_after_dequeue = 10 * BATCH_SIZE # the maximum number of elements in the queue capacity = 20 * BATCH_SIZE # shuffle the data to generate BATCH_SIZE sample pairs feature_batch, label_batch = tf.train.shuffle_batch([features, label], batch_size=BATCH_SIZE, capacity=capacity, min_after_dequeue=min_after_dequeue) return feature_batch, label_batch ``` 6. 我們定義了另一個函數來在會話中生成批量： ```py def generate_data(feature_batch, label_batch): with tf.Session() as sess: # intialize the queue threads coord = tf.train.Coordinator() threads = tf.train.start_queue_runners(coord=coord) for _ in range(5): # Generate 5 batches features, labels = sess.run([feature_batch, label_batch]) print (features, "HI") coord.request_stop() coord.join(threads) ``` 7. 現在，我們可以使用這兩個函數來批量獲取數據。 在這里，我們只是打印數據。 學習時，我們將在此時執行優化步驟： ```py if __name__ =='__main__': feature_batch, label_batch = data_generator([DATA_FILE]) generate_data(feature_batch, label_batch) ``` # 更多 我們可以使用第一章中介紹的 TensorFlow 控件操作和張量操作來預處理數據。 例如，在波士頓房價的情況下，大約有 16 個數據行，其中`MEDV`為`50.0`。 這些數據點最有可能包含缺失或審查的值，建議不要在訓練中考慮它們。 我們可以使用以下代碼將它們從訓練數據集中刪除： ```py condition = tf.equal(data[13], tf.constant(50.0)) data = tf.where(condition, tf.zeros(NUM_FEATURES), data[:]) ``` 在這里，我們首先定義一個張量布爾條件，如果`MEDV`等于`50.0`，則為真。 然后，如果條件為真，則使用 TensorFlow `tf.where()`操作分配全零。 # 房價估計 -- 簡單線性回歸 在此秘籍中，我們將基于波士頓房價數據集上的房間數（`RM`）執行簡單的線性回歸。 # 準備 我們的目標是預測最后一欄（`MEDV`）中給出的房價。 在此秘籍中，我們直接從 TensorFlow Contrib 數據集中加載數據集。 我們使用隨機梯度下降優化器優化單個訓練樣本的系數。 # 操作步驟 我們按以下步驟進行： 1. 第一步是導入我們需要的所有包： ```py import tensorflow as tf import numpy as np import matplotlib.pyplot as plt ``` 2. 在神經網絡中，所有輸入都線性相加以產生活動。 為了進行有效的訓練，應該對輸入進行標準化，因此我們定義了對輸入數據進行標準化的函數： ```py def normalize(X): """ Normalizes the array X""" mean = np.mean(X) std = np.std(X) X = (X - mean)/std return X ``` 3. 現在，我們使用 TensorFlow `contrib`數據集加載波士頓房價數據集，并將其分為`X_train`和`Y_train`。 我們可以選擇在此處標準化數據： ```py # Data boston = tf.contrib.learn.datasets.load_dataset('boston') X_train, Y_train = boston.data[:,5], boston.target #X_train = normalize(X_train) # This step is optional here n_samples = len(X_train) ``` 4. 我們為訓練數據聲明 TensorFlow 占位符： ```py # Placeholder for the Training Data X = tf.placeholder(tf.float32, name='X') Y = tf.placeholder(tf.float32, name='Y') ``` 5. 我們為權重和偏差創建 TensorFlow 變量，初始值為零： ```py # Variables for coefficients initialized to 0 b = tf.Variable(0.0) w = tf.Variable(0.0) ``` 6. 我們定義了用于預測的線性回歸模型： ```py # The Linear Regression Model Y_hat = X * w + b ``` 7. 定義`loss`函數： ```py # Loss function loss = tf.square(Y - Y_hat, name='loss') ``` 8. 我們選擇梯度下降優化器： ```py # Gradient Descent with learning rate of 0.01 to minimize loss optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss) ``` 9. 聲明初始化操作： ```py # Initializing Variables init_op = tf.global_variables_initializer() total = [] ``` 10. 現在，我們開始計算圖。 我們進行了 100 個周期的訓練： ```py # Computation Graph with tf.Session() as sess: # Initialize variables sess.run(init_op) writer = tf.summary.FileWriter('graphs', sess.graph) # train the model for 100 epochs for i in range(100): total_loss = 0 for x,y in zip(X_train,Y_train): _, l = sess.run ([optimizer, loss], feed_dict={X:x, Y:y}) total_loss += l total.append(total_loss / n_samples) print('Epoch {0}: Loss {1}'.format(i, total_loss/n_samples)) writer.close() b_value, w_value = sess.run([b,w]) ``` 11. 查看結果： ```py Y_pred = X_train * w_value + b_value print('Done') # Plot the result plt.plot(X_train, Y_train, 'bo', label='Real Data') plt.plot(X_train,Y_pred, 'r', label='Predicted Data') plt.legend() plt.show() plt.plot(total) plt.show() ``` # 工作原理 從圖中可以看出，我們的簡單線性回歸器試圖將線性線擬合到給定的數據集：  在下圖中，我們可以看到，隨著我們的模型學習到數據，`loss`函數如預期的那樣下降：  以下是我們的簡單線性回歸器的 TensorBoard 圖：  該圖具有兩個名稱作用域節點，即`Variable`和`Variable_1`，它們是分別表示偏差和權重的高級節點。 名為`gradient`的節點也是高級節點。 擴展節點，我們可以看到它接受了七個輸入并計算了`gradient`，然后`GradientDescentOptimizer`使用了這些梯度來計算權重和偏差并應用更新：  # 更多 好吧，我們執行了簡單的線性回歸，但是如何找出模型的表現呢？ 有多種方法可以做到這一點。 從統計上講，我們可以計算 R 方或將我們的數據分為訓練和交叉驗證集，并檢查驗證集的準確率（損失項）。 # 房價估計 -- 多元線性回歸 我們可以通過對權重和占位符的聲明進行一些修改來對同一數據進行多元線性回歸。 在多元線性回歸的情況下，由于每個特征都有不同的值范圍，因此規范化必不可少。 這是使用所有 13 種輸入特征對波士頓房價數據集進行多元線性回歸的代碼。 # 操作步驟 這是我們進行秘籍的方法： 1. 第一步是導入我們需要的所有包： ```py import tensorflow as tf import numpy as np import matplotlib.pyplot as plt ``` 2. 由于所有特征的數據范圍都不同，因此我們需要對特征數據進行規范化。 我們為其定義了歸一化函數。 同樣，在這里，我們通過添加總是固定為一個值的另一輸入來將偏差與權重相結合。 為此，我們定義函數`append_bias_reshape()`。 有時會使用此技術來簡化編程： ```py def normalize(X) """ Normalizes the array X """ mean = np.mean(X) std = np.std(X) X = (X - mean)/std return X def append_bias_reshape(features,labels): m = features.shape[0] n = features.shape[1] x = np.reshape(np.c_[np.ones(m),features],[m,n + 1]) y = np.reshape(labels,[m,1]) return x, y ``` 3. 現在，我們使用 TensorFlow contrib 數據集加載波士頓房價數據集，并將其分為`X_train`和`Y_train`。 觀察到這次`X_train`包含所有特征。 我們可以在此處選擇對數據進行規范化，也可以使用附加偏差并為網絡重塑數據： ```py # Data boston = tf.contrib.learn.datasets.load_dataset('boston') X_train, Y_train = boston.data, boston.target X_train = normalize(X_train) X_train, Y_train = append_bias_reshape(X_train, Y_train) m = len(X_train) #Number of training examples n = 13 + 1 # Number of features + bias ``` 4. 聲明 TensorFlow 占位符以獲取訓練數據。 觀察`X`占位符形狀的變化。 ```py # Placeholder for the Training Data X = tf.placeholder(tf.float32, name='X', shape=[m,n]) Y = tf.placeholder(tf.float32, name='Y') ``` 5. 我們為權重和偏差創建 TensorFlow 變量。 這次，權重用隨機數初始化： ```py # Variables for coefficients w = tf.Variable(tf.random_normal([n,1])) ``` 6. 定義要用于預測的線性回歸模型。 現在我們需要矩陣乘法來完成任務： ```py # The Linear Regression Model Y_hat = tf.matmul(X, w) ``` 7. 為了更好的區分，我們定義`loss`函數： ```py # Loss function loss = tf.reduce_mean(tf.square(Y - Y_hat, name='loss')) ``` 8. 選擇合適的優化器： ```py # Gradient Descent with learning rate of 0.01 to minimize loss optimizer = tf.train.GradientDescentOptimizer(learning_rate=0.01).minimize(loss) ``` 9. 定義初始化操作： ```py # Initializing Variables init_op = tf.global_variables_initializer() total = [] ``` 10. 啟動計算圖： ```py with tf.Session() as sess: # Initialize variables sess.run(init_op) writer = tf.summary.FileWriter('graphs', sess.graph) # train the model for 100 epcohs for i in range(100): _, l = sess.run([optimizer, loss], feed_dict={X: X_train, Y: Y_train}) total.append(l) print('Epoch {0}: Loss {1}'.format(i, l)) writer.close() w_value, b_value = sess.run([w, b]) ``` 11. 繪制`loss`函數： ```py plt.plot(total) plt.show() ``` 同樣在這里，我們發現損失隨著訓練的進行而減少：  # 工作原理 在此秘籍中，我們使用了所有 13 個特征來訓練模型。 簡單線性回歸和多元線性回歸之間的重要區別在于權重，系數的數量始終等于輸入特征的數量。 以下是我們構建的多元線性回歸模型的 TensorBoard 圖：  # 更多 我們現在可以使用從模型中學到的系數來預測房價： ```py N= 500 X_new = X_train [N,:] Y_pred = (np.matmul(X_new, w_value) + b_value).round(1) print('Predicted value: ${0} Actual value: / ${1}'.format(Y_pred[0]*1000, Y_train[N]*1000) , '\nDone') ``` # MNIST 數據集上的邏輯回歸 此秘籍基于[這個頁面](https://www.tensorflow.org/get_started/mnist/beginners)提供的 MNIST 的邏輯回歸，但我們將添加一些 TensorBoard 摘要以更好地理解它。 你們大多數人必須已經熟悉 MNIST 數據集-就像機器學習的 ABC 一樣。 它包含手寫數字的圖像和每個圖像的標簽，說明它是哪個數字。 對于邏輯回歸，我們對輸出 Y 使用一熱編碼。因此，我們有 10 位代表輸出； 每個位可以具有 0 或 1 的值，并且為 1 熱點意味著對于標簽 Y 中的每個圖像，10 個位中只有 1 個位的值為 1，其余為 0。 在這里，您可以看到手寫數字 8 的圖像及其熱編碼值`[0 0 0 0 0 0 0 0 0 1 0]`：  # 操作步驟 這是我們進行秘籍的方法： 1. 與往常一樣，第一步是導入所需的模塊： ```py import tensorflow as tf import matplotlib.pyplot as plt, matplotlib.image as mpimg ``` 2. 我們從模塊`input_data`中給出的 TensorFlow 示例中獲取 MNIST 的輸入數據。 `one_hot`標志設置為`True`以啟用標簽的`one_hot`編碼。 這導致生成兩個張量，形狀為`[55000, 784]`的`mnist.train.images`和形狀為`[55000, 10]`的`mnist.train.labels`。 `mnist.train.images`的每個條目都是像素強度，其值在 0 到 1 之間： ```py from tensorflow.examples.tutorials.mnist import input_data mnist = input_data.read_data_sets("MNIST_data/", one_hot=True) ``` 3. 為訓練數據集輸入`x`創建占位符，并在 TensorFlow 圖上標記`y`： ```py x = tf.placeholder(tf.float32, [None, 784], name='X') y = tf.placeholder(tf.float32, [None, 10],name='Y') ``` 4. 創建學習變量??，權重和偏置： ```py W = tf.Variable(tf.zeros([784, 10]), name='W') b = tf.Variable(tf.zeros([10]), name='b') ``` 5. 創建邏輯回歸模型。 TensorFlow OP 被賦予`name_scope("wx_b")`： ```py with tf.name_scope("wx_b") as scope: y_hat = tf.nn.softmax(tf.matmul(x,W) + b) ``` 6. 添加摘要 OP，以在訓練時收集數據。 我們使用直方圖摘要，以便我們可以看到權重和偏差隨時間相對于彼此的值如何變化。 我們將可以在 TensorBoard 直方圖選項卡中看到以下內容： ```py w_h = tf.summary.histogram("weights", W) b_h = tf.summary.histogram("biases", b) ``` 7. 定義`cross-entropy`和`loss`函數，并添加名稱范圍和摘要以更好地可視化。 在這里，我們使用標量匯總來獲取`loss`函數隨時間的變化。 標量摘要在“事件”選項卡下可見： ```py with tf.name_scope('cross-entropy') as scope: loss = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(labels=y, logits=y_hat) tf.summary.scalar('cross-entropy', loss) ``` 8. 使用具有學習率`0.01`的 TensorFlow `GradientDescentOptimizer`。 再次，為了更好地可視化，我們定義了`name_scope`： ```py with tf.name_scope('Train') as scope: optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss) ``` 9. 聲明變量的初始化操作： ```py # Initializing the variables init = tf.global_variables_initializer() ``` 10. 我們結合了所有匯總操作： ```py merged_summary_op = tf.summary.merge_all() ``` 11. 現在，我們定義會話并將摘要存儲在定義的文件夾中： ```py with tf.Session() as sess: sess.run(init) # initialize all variables summary_writer = tf.summary.FileWriter('graphs', sess.graph) # Create an event file # Training for epoch in range(max_epochs): loss_avg = 0 num_of_batch = int(mnist.train.num_examples/batch_size) for i in range(num_of_batch): batch_xs, batch_ys = mnist.train.next_batch(100) # get the next batch of data _, l, summary_str = sess.run([optimizer,loss, merged_summary_op], feed_dict={x: batch_xs, y: batch_ys}) # Run the optimizer loss_avg += l summary_writer.add_summary(summary_str, epoch*num_of_batch + i) # Add all summaries per batch loss_avg = loss_avg/num_of_batch print('Epoch {0}: Loss {1}'.format(epoch, loss_avg)) print('Done') print(sess.run(accuracy, feed_dict={x: mnist.test.images,y: mnist.test.labels})) ``` 12. 在 30 個周期后，我們的準確率為 86.5%，在 50 個周期后為 89.36%，在 100 個周期后，準確率提高到 90.91%。 # 工作原理 我們使用張量`tensorboard --logdir=garphs`啟動 TensorBoard。 在瀏覽器中，導航到網址`localhost:6006`，以查看 TensorBoard。 先前模型的圖形如下：  在“直方圖”標簽下，我們可以看到**權重**和**偏置**的直方圖：  **權重**和**偏置**的分布如下：  我們可以看到，隨著時間的推移，偏差和權重都發生了變化。 從我們的案例來看，偏差更大，從 TensorBoard 中的分布可以看出。 在“事件”選項卡下，我們可以看到標量摘要，在這種情況下為交叉熵。 下圖顯示交叉熵損失隨時間減少：  # 另見 如果您有興趣了解更多信息，這些是一些很好的資源： * [關于 TensorBoard 和可視化](https://www.tensorflow.org/get_started/summaries_and_tensorboard) * [這是一門有關統計和概率的很好的課程](https://www.khanacademy.org/math/statistics-probability/describing-relationships-quantitative-data) * [有關回歸的更多詳細信息](https://onlinecourses.science.psu.edu/stat501/node/250)