# 在 TensorFlow 中使用內核 先前的 SVM 使用線性可分數據。如果我們分離非線性數據，我們可以改變將線性分隔符投影到數據上的方式。這是通過更改 SVM 損失函數中的內核來完成的。在本章中，我們將介紹如何更改內核并分離非線性可分離數據。 ## 做好準備 在本文中，我們將激勵支持向量機中內核的使用。在線性 SVM 部分，我們用特定的損失函數求解了軟邊界。這種方法的另一種方法是解決所謂的優化問題的對偶。可以證明線性 SVM 問題的對偶性由以下公式給出：  對此，以下適用：  這里，模型中的變量將是`b`向量。理想情況下，此向量將非常稀疏，僅對我們數據集的相應支持向量采用接近 1 和-1 的值。我們的數據點向量由`x[i]`表示，我們的目標（1 或 -1）`y[i]`表示。 前面等式中的內核是點積`x[i] · y[j]`，它給出了線性內核。該內核是一個方形矩陣，填充了數據點`i, j`的點積。 我們可以將更復雜的函數擴展到更高的維度，而不是僅僅在數據點之間進行點積，而在這些維度中，類可以是線性可分的。這似乎是不必要的復雜，但我們可以選擇一個具有以下屬性的函數`k`：  這里`, k`被稱為核函數。更常見的內核是使用高斯內核（也稱為徑向基函數內核或 RBF 內核）。該內核用以下等式描述：  為了對這個內核進行預測，比如說`p[i]`，我們只需在內核中的相應方程中用預測點替換，如下所示：  在本節中，我們將討論如何實現高斯內核。我們還將在適當的位置記下在何處替換實現線性內核。我們將使用的數據集將手動創建，以顯示高斯內核更適合在線性內核上使用的位置。 ## 操作步驟 我們按如下方式處理秘籍： 1. 首先，我們加載必要的庫并啟動圖會話，如下所示： ```py import matplotlib.pyplot as plt import numpy as np import tensorflow as tf from sklearn import datasets sess = tf.Session() ``` 1. 現在，我們生成數據。我們將生成的數據將是兩個同心數據環;每個戒指都屬于不同的階級。我們必須確保類只有-1 或 1。然后我們將數據分成每個類的`x`和`y`值以用于繪圖目的。為此，請使用以下代碼： ```py (x_vals, y_vals) = datasets.make_circles(n_samples=500, factor=.5, noise=.1) y_vals = np.array([1 if y==1 else -1 for y in y_vals]) class1_x = [x[0] for i,x in enumerate(x_vals) if y_vals[i]==1] class1_y = [x[1] for i,x in enumerate(x_vals) if y_vals[i]==1] class2_x = [x[0] for i,x in enumerate(x_vals) if y_vals[i]==-1] class2_y = [x[1] for i,x in enumerate(x_vals) if y_vals[i]==-1] ``` 1. 接下來，我們聲明批量大小和占位符，并創建我們的模型變量`b`。對于 SVM，我們傾向于需要更大的批量大小，因為我們需要一個非常穩定的模型，該模型在每次訓練生成時都不會波動很大。另請注意，我們為預測點添加了額外的占位符。為了可視化結果，我們將創建一個顏色網格，以查看哪些區域最后屬于哪個類。我們這樣做如下： ```py batch_size = 250 x_data = tf.placeholder(shape=[None, 2], dtype=tf.float32) y_target = tf.placeholder(shape=[None, 1], dtype=tf.float32) prediction_grid = tf.placeholder(shape=[None, 2], dtype=tf.float32) b = tf.Variable(tf.random_normal(shape=[1,batch_size])) ``` 1. 我們現在將創建高斯內核。該內核可以表示為矩陣運算，如下所示： ```py gamma = tf.constant(-50.0) dist = tf.reduce_sum(tf.square(x_data), 1) dist = tf.reshape(dist, [-1,1]) sq_dists = tf.add(tf.subtract(dist, tf.multiply(2., tf.matmul(x_data, tf.transpose(x_data)))), tf.transpose(dist)) my_kernel = tf.exp(tf.multiply(gamma, tf.abs(sq_dists))) ``` > 注意`add`和`subtract`操作的`sq_dists`行中廣播的使用。 另外，請注意線性內核可以表示為`my_kernel = tf.matmul(x_data, tf.transpose(x_data))`。 1. 現在，我們宣布了本秘籍中之前所述的雙重問題。最后，我們將使用`tf.negative()`函數最小化損失函數的負值，而不是最大化。我們使用以下代碼完成此任務： ```py model_output = tf.matmul(b, my_kernel) first_term = tf.reduce_sum(b) b_vec_cross = tf.matmul(tf.transpose(b), b) y_target_cross = tf.matmul(y_target, tf.transpose(y_target)) second_term = tf.reduce_sum(tf.multiply(my_kernel, tf.multiply(b_vec_cross, y_target_cross))) loss = tf.negative(tf.subtract(first_term, second_term)) ``` 1. 我們現在創建預測和準確率函數。首先，我們必須創建一個預測內核，類似于步驟 4，但是我們擁有帶有預測數據的點的核心，而不是點的內核。然后預測是模型輸出的符號。這實現如下： ```py rA = tf.reshape(tf.reduce_sum(tf.square(x_data), 1),[-1,1]) rB = tf.reshape(tf.reduce_sum(tf.square(prediction_grid), 1),[-1,1]) pred_sq_dist = tf.add(tf.subtract(rA, tf.multiply(2., tf.matmul(x_data, tf.transpose(prediction_grid)))), tf.transpose(rB)) pred_kernel = tf.exp(tf.multiply(gamma, tf.abs(pred_sq_dist))) prediction_output = tf.matmul(tf.multiply(tf.transpose(y_target),b), pred_kernel) prediction = tf.sign(prediction_output-tf.reduce_mean(prediction_output)) accuracy = tf.reduce_mean(tf.cast(tf.equal(tf.squeeze(prediction), tf.squeeze(y_target)), tf.float32)) ``` > 為了實現線性預測內核，我們可以編寫`pred_kernel = tf.matmul(x_data, tf.transpose(prediction_grid))`。 1. 現在，我們可以創建一個優化函數并初始化所有變量，如下所示： ```py my_opt = tf.train.GradientDescentOptimizer(0.001) train_step = my_opt.minimize(loss) init = tf.global_variables_initializer() sess.run(init) ``` 1. 接下來，我們開始訓練循環。我們將記錄每代的損耗向量和批次精度。當我們運行準確率時，我們必須放入所有三個占位符，但我們輸入`x`數據兩次以獲得對點的預測，如下所示： ```py loss_vec = [] batch_accuracy = [] for i in range(500): rand_index = np.random.choice(len(x_vals), size=batch_size) rand_x = x_vals[rand_index] rand_y = np.transpose([y_vals[rand_index]]) sess.run(train_step, feed_dict={x_data: rand_x, y_target: rand_y}) temp_loss = sess.run(loss, feed_dict={x_data: rand_x, y_target: rand_y}) loss_vec.append(temp_loss) acc_temp = sess.run(accuracy, feed_dict={x_data: rand_x, y_target: rand_y, prediction_grid:rand_x}) batch_accuracy.append(acc_temp) if (i+1)%100==0: print('Step #' + str(i+1)) print('Loss = ' + str(temp_loss)) ``` 1. 這導致以下輸出： ```py Step #100 Loss = -28.0772 Step #200 Loss = -3.3628 Step #300 Loss = -58.862 Step #400 Loss = -75.1121 Step #500 Loss = -84.8905 ``` 1. 為了查看整個空間的輸出類，我們將在系統中創建一個預測點網格，并對所有這些預測點進行預測，如下所示： ```py x_min, x_max = x_vals[:, 0].min() - 1, x_vals[:, 0].max() + 1 y_min, y_max = x_vals[:, 1].min() - 1, x_vals[:, 1].max() + 1 xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02), np.arange(y_min, y_max, 0.02)) grid_points = np.c_[xx.ravel(), yy.ravel()] [grid_predictions] = sess.run(prediction, feed_dict={x_data: x_vals, y_target: np.transpose([y_vals]), prediction_grid: grid_points}) grid_predictions = grid_predictions.reshape(xx.shape) ``` 1. 以下是繪制結果，批次準確率和損失的代碼： ```py plt.contourf(xx, yy, grid_predictions, cmap=plt.cm.Paired, alpha=0.8) plt.plot(class1_x, class1_y, 'ro', label='Class 1') plt.plot(class2_x, class2_y, 'kx', label='Class -1') plt.legend(loc='lower right') plt.ylim([-1.5, 1.5]) plt.xlim([-1.5, 1.5]) plt.show() plt.plot(batch_accuracy, 'k-', label='Accuracy') plt.title('Batch Accuracy') plt.xlabel('Generation') plt.ylabel('Accuracy') plt.legend(loc='lower right') plt.show() plt.plot(loss_vec, 'k-') plt.title('Loss per Generation') plt.xlabel('Generation') plt.ylabel('Loss') plt.show() ``` 為了簡潔起見，我們將僅顯示結果圖，但我們也可以單獨運行繪圖代碼并查看損失和準確率。 以下屏幕截圖說明了線性可分離擬合對我們的非線性數據有多糟糕：  圖 7：非線性可分離數據上的線性 SVM 以下屏幕截圖顯示了高斯內核可以更好地擬合非線性數據： Figure 8: Non-linear SVM with Gaussian kernel results on non-linear ring data 如果我們使用高斯內核來分離我們的非線性環數據，我們會得到更好的擬合。 ## 工作原理 有兩個重要的代碼需要了解：我們如何實現內核，以及我們如何為 SVM 雙優化問題實現損失函數。我們已經展示了如何實現線性和高斯核，并且高斯核可以分離非線性數據集。 我們還應該提到另一個參數，即高斯核中的伽馬值。此參數控制影響點對分離曲率的影響程度。通常選擇小值，但它在很大程度上取決于數據集。理想情況下，使用交叉驗證等統計技術選擇此參數。 > 對于新點的預測/評估，我們使用以下命令：`sess.run(prediction, feed_dict:{x_data: x_vals, y_data: np.transpose([y_vals])})`。此評估必須包括原始數據集（`x_vals`和`y_vals`），因為 SVM 是使用支持向量定義的，由哪些點指定在邊界上或不是。 ## 更多 如果我們這樣選擇，我們可以實現更多內核。以下是一些更常見的非線性內核列表： * 多項式齊次核：  * 多項式非均勻內核：  * 雙曲正切內核：