目錄
10 sklearn實現SVC（支持向量分類）,SVR（支持向量回歸）：
1.導出目標
2拉格朗日轉換
3對偶問題：
因為是希望得出L最小時的一些參數w,b,a，但是目前很難一起求得最佳參數，所以換個思路。因為：
所以能夠容易的計算出拉格朗日乘子a約束時的最壞情況是：
但是m個a的值還是無法求出，而后面會得知，根據L對w,b的求導關系，w,b可以被a表示出來，所以關鍵變為求a。
根據對偶關系，極大值關系可以轉為極小值關系，且轉換后的問題會不大於原問題，在取得極值的時候才取等號，也就是：
這樣問題變為，先把w,b求導關系代入求L極小值關系，最后再尋找a的問題，最后a的求解會通過SMO等思路求解，具體SMO放到最后講解，因為太難了。
4求對偶問題
1）求L的極小值時的w,b，求導：
得出極小值需滿足如上這些關系
2）代入L求導關系式，求關於a的極大值：
所以關鍵是對這個函數求極大值時的a，假設通過后面的SMO找到了，記為a*，那么顯然得到了w的解析式：
5 求b
因為對於所有支持向量點（正例上支持向量點位於WTx+b = 1超平面上，反例WTx+b= -1）記作(xs,ys)，均有:
根據KKT條件：ai>0時，yi(WTxi+b)-1=0：（必定：WTxi+b = 1 或WTxi+b= -1）即xi必須是支持向量點，而ai=0時:
也就是說對w無影響，因此上式中w還可以簡化成只考慮支持向量點計算（實際上這就是SVM稱為支持向量機的原因，因為模型真正起作用的，就只是這些支持向量點）：
假設我們有S個支持向量（位於WTx+b = 1，WTx+b= -1超平面上的點集），則對應我們求出S個b∗,理論上這些b∗都可以作為最終的結果， 但是我們一般采用一種更健壯的辦法，即求出所有支持向量所對應的b∗，然后將其平均值作為最后的結果：
6 得出模型
ai參數求出之后，如上所示，就相當於求出了w,b了。就可以得到模型，進行預測了：
def _f(self, i):
r = self.b
for j in range(self.m):
r += self.alpha[j] * self.Y[j] * self.kernel(self.X[i], self.X[j])
return r
6.1 f(x)的約束條件：
7 核函數
現實中可能有些不存在線性的可分超平面，但是可能映射到更高維度可能就可分了，有證明顯示，如果原始空間維度有限，那么一定存在高維特征空間使樣本可分。
這樣對x的映射關系，可以直接用到上面推導的所有公式里：
原問題映射：
對偶形式映射：
這種映射我們並不知道具體是如何的，因此也不知如何去計算了，所以這里就設想出來核函數的概念了：
def kernel(self, x1, x2):
if self._kernel == 'linear':
return sum([x1[k] * x2[k] for k in range(self.n)])
elif self._kernel == 'poly':
return (sum([x1[k] * x2[k] for k in range(self.n)]) + 1) ** 2
return 0假設出原來的這種內積映射，是等價於某個函數k(.,.)計算的結果。問題就變成了：
求解后模型為：
核函數性質
k是核函數，當且僅當’核矩陣’K總是半正定：
常見核函數列表：
另外核函數線性組合起來還是核函數（系數為正），k1,k1,r1>0,r2>0：k3=r1k1+r2k2 也是核函數
7.1 軟間隔
討論軟間隔是因為像這種情況，嚴格分出來（線性不可分了已經，用核函數可以分）是個彎曲的，但實際上應該就是這下面這樣一條斜線才是最好的模型表示：
因此辦法是，允許在一些情況下出現錯誤，引入軟間隔的概念，在這個軟間隔內允許出錯。也就是允許不滿足約束：
對於不滿足的點，我們會累記一個損失函數，再引入懲罰力度因子C，則可以重新定義優化目標：
7.2 松弛變量：
顯然，這些損失是常數且>=0，因此引入松弛變量的概念替換原來的損害函數計算結果，重寫簡化：
上式進行拉格朗日變換：為什么這樣：https://blog.csdn.net/jiang425776024/article/details/87607526
同樣的求導，對偶和上面4一致，省略。最終得到如下對偶問題：
7.3 KKT約束
可見，與非軟間隔的問題相比，僅僅是對約束ai多了一個上界約束，且約束就是<懲罰因子C。然后同樣SMO解得參數就可以得到模型f(x)了，和6一致，同樣因為存在不等式約束約束，所以這里模型f(x)有KKT條件約束：
這個約束是有道理的：
a) 如果α=0,那么yi(wTxi+b)−1≥0,即樣本在間隔邊界上或者已經被正確分類。
b) 如果0<α<C,那么ξi=0,yi(wTxi+b)−1=0,即點在間隔邊界上。
c) 如果α=C，說明這是一個可能比較異常的點，需要檢查此時ξi
1)如果0≤ξi≤1,那么點被正確分類，但是卻在超平面和自己類別的間隔邊界之間
2)如果ξi=1,那么點在分離超平面上，無法被正確分類。
3)如果ξi>1,那么點在超平面的另一側，也就是說，這個點不能被正常分類
實現代碼，判斷是否否后KKT條件，True符合，False不符合：
def _KKT(self, i):
y_g = self._g(i) * self.Y[i]
if self.alpha[i] == 0:#a=0:需要yif(xi)-1>=0
return y_g >= 1
elif 0 < self.alpha[i] < self.C: #0<a<C:需要在邊界上yif(xi)=1
return y_g == 1
else:
return y_g <= 1 #a>=C:異常點,需要0≤ξi≤1滿足在區間內yif(xi)<=1
8 SMO求a
8.1對偶問題上，上面已知對偶形式:
8.2.SMO算法思想
在SMO算法中的思想是，每次選擇一對變量(αi,αj)進行優化，其余m-2個固定看作是常量, 因為在SVM中，α並不是完全獨立的，而是具有約束的:
因此一個只選一個ai，那么ai可以被其它表示。
假設我們選取的兩個需要優化的參數為α1,α2, 剩下的α3,α4,…,αm則固定作為常數處理。將SVM優化問題進行展開就可以得到(把與α1,α2無關的項合並成常數項C):（省略了a3+a4+...+am=C，因為其對max函數無意義）
8.2.1更新方法
因為y1,y2只能是1/-1，因此a1,a2的關系被限制在盒子里的一條線段上（只能是a1-a2/a1+a2兩種情況），所以兩變量的優化問題實際上僅僅是一個變量的優化問題（一個能由另一個得出）。我們假設是對a2的優化問題,所以只存在2幅圖的情況：
1）y1!=y2,則約束a1y1+a2y2=k：a1-a2=k，L，H為約束下a2的最小最大值,為下圖
2）y1=y2:
if self.Y[i1] == self.Y[i2]:
L = max(0, self.alpha[i1] + self.alpha[i2] - self.C)
H = min(self.C, self.alpha[i1] + self.alpha[i2])
else:
L = max(0, self.alpha[i2] - self.alpha[i1])
H = min(self.C, self.C + self.alpha[i2] - self.alpha[i1])
def _E(self, i):
return self._f(i) - self.Y[i]則最優化問題轉為更新：
最終更新方式：
剪輯判斷：
def _compare(self, _alpha, L, H):
# 剪輯操作
if _alpha > H:
return H
elif _alpha < L:
return L
else:
return _alphaa1,a2更新：
# 邊界
if self.Y[i1] == self.Y[i2]:
L = max(0, self.alpha[i1] + self.alpha[i2] - self.C)
H = min(self.C, self.alpha[i1] + self.alpha[i2])
else:
L = max(0, self.alpha[i2] - self.alpha[i1])
H = min(self.C, self.C + self.alpha[i2] - self.alpha[i1])
E1 = self.E[i1]
E2 = self.E[i2]
eta = self.kernel(self.X[i1], self.X[i1]) + self.kernel(self.X[i2], self.X[i2]) - 2 * self.kernel(
self.X[i1], self.X[i2])
if eta <= 0:
# print('eta <= 0')
continue
alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (E1 - E2) / eta
alpha2_new = self._compare(alpha2_new_unc, L, H)
alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)
self.alpha[i1] = alpha1_new
self.alpha[i2] = alpha2_new
8.2.2 推導過程
則：
求導：
代入關系式，添加新舊標記方便迭代更新：
得：
得出上面的更新方式。
8.2.3選兩點a1,a2的方法
SMO每個子問題選擇兩個變量優化，其中至少一個變量是違法KKT條件的。
第1個變量a1的選擇
SMO稱選擇第一個變量的過程為外層循環，外層循環選取違反KKT條件最嚴重的樣本點(xi,yi)對應的ai值作為第一個變量a1；檢測是否滿足KKT條件（7.3有具體介紹）：
一般，外層循環先遍歷所有滿足0<ai<C的樣本點，如果都滿足再遍歷整個訓練集點，檢驗是否滿足KKT條件。
第2個變量a2的選擇
SMO算法稱選擇第二一個變量為內層循環，假設我們在外層循環已經找到了α1, 第二個變量α2的選擇標准是讓|E1−E2|有足夠大的變化。8.2.1定義了E(預測值與真實值之差)。由於α1定了的時候,E1也確定了，所以要想|E1−E2|最大，只需要在E1為正時，選擇最小的Ei作為E2，在E1為負時，選擇最大的Ei作為E2，可以將所有的Ei保存為列表，加快迭代。
如果內存循環找到的點不能讓目標函數有足夠的下降，可以采用遍歷支持向量點來做α2,直到目標函數有足夠的下降， 如果所有的支持向量做α2都不能讓目標函數有足夠的下降，可以跳出循環，重新選擇α1。
def _init_alpha(self):
# 外層循環首先遍歷所有滿足0<a<C的樣本點，檢驗是否滿足KKT
index_list = [i for i in range(self.m) if 0 < self.alpha[i] < self.C]
# 否則遍歷整個訓練集
non_satisfy_list = [i for i in range(self.m) if i not in index_list]
index_list.extend(non_satisfy_list)
for i in index_list:
if self._KKT(i):#滿足KKT條件就不做下一步計算
continue
E1 = self.E[i]
# 如果E2是+，選擇最小的；如果E2是負的，選擇最大的
if E1 >= 0:
j = min(range(self.m), key=lambda x: self.E[x])
else:
j = max(range(self.m), key=lambda x: self.E[x])
# 找到一對就返回，沒找到再循環
return i, j8.2.4b和E計算更新
b1_new= self.b
b2_new= self.b
if 0 < alpha1_new < self.C:
b1_new = -E1 - self.Y[i1] * self.kernel(self.X[i1], self.X[i1])
* (alpha1_new - self.alpha[i1]) - self.Y[i2]
* self.kernel(self.X[i2], self.X[i1])
* (alpha2_new - self.alpha[i2])
+ self.b
if 0 < alpha2_new < self.C:
b2_new = -E2 - self.Y[i1] * self.kernel(self.X[i1], self.X[i2])
* (alpha1_new - self.alpha[i1]) - self.Y[i2]
* self.kernel(self.X[i2], self.X[i2])
* (alpha2_new - self.alpha[i2])
+ self.b
b_new = (b1_new + b2_new) / 2
self.b = b_new
# 更新E
self.E[i1] = self._E(i1)
self.E[i2] = self._E(i2)8.3算法偽代碼
8.4完整實現：
python版
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
def create_data():
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
data = np.array(df.iloc[:100, [0, 1, -1]])
for i in range(len(data)):
if data[i, -1] == 0:
data[i, -1] = -1
# print(data)
return data[:, :2], data[:, -1]
X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
class SVM:
def __init__(self, max_iter=100, kernel='linear'):
self.max_iter = max_iter
self._kernel = kernel
def init_args(self, features, labels):
self.m, self.n = features.shape
self.X = features
self.Y = labels
self.b = 0.0
# 將Ei保存在一個列表里
self.alpha = np.ones(self.m)
self.E = [self._E(i) for i in range(self.m)]
# 松弛變量
self.C = 1.0
def _KKT(self, i):
y_g = self._g(i) * self.Y[i]
if self.alpha[i] == 0:
return y_g >= 1
elif 0 < self.alpha[i] < self.C:
return y_g == 1
else:
return y_g <= 1
# g(x)預測值，輸入xi（X[i]）
def _g(self, i):
r = self.b
for j in range(self.m):
r += self.alpha[j] * self.Y[j] * self.kernel(self.X[i], self.X[j])
return r
# 核函數
def kernel(self, x1, x2):
if self._kernel == 'linear':
return sum([x1[k] * x2[k] for k in range(self.n)])
elif self._kernel == 'poly':
return (sum([x1[k] * x2[k] for k in range(self.n)]) + 1) ** 2
return 0
# E（x）為g(x)對輸入x的預測值和y的差
def _E(self, i):
return self._g(i) - self.Y[i]
def _init_alpha(self):
# 外層循環首先遍歷所有滿足0<a<C的樣本點，檢驗是否滿足KKT
index_list = [i for i in range(self.m) if 0 < self.alpha[i] < self.C]
# 否則遍歷整個訓練集
non_satisfy_list = [i for i in range(self.m) if i not in index_list]
index_list.extend(non_satisfy_list)
for i in index_list:
if self._KKT(i):
continue
E1 = self.E[i]
# 如果E2是+，選擇最小的；如果E2是負的，選擇最大的
if E1 >= 0:
j = min(range(self.m), key=lambda x: self.E[x])
else:
j = max(range(self.m), key=lambda x: self.E[x])
# 找到一對就返回，沒找到再循環
return i, j
def _compare(self, _alpha, L, H):
# 剪輯操作
if _alpha > H:
return H
elif _alpha < L:
return L
else:
return _alpha
def fit(self, features, labels):
# 訓練
self.init_args(features, labels)
for t in range(self.max_iter):
# train
i1, i2 = self._init_alpha()
# 邊界
if self.Y[i1] == self.Y[i2]:
L = max(0, self.alpha[i1] + self.alpha[i2] - self.C)
H = min(self.C, self.alpha[i1] + self.alpha[i2])
else:
L = max(0, self.alpha[i2] - self.alpha[i1])
H = min(self.C, self.C + self.alpha[i2] - self.alpha[i1])
E1 = self.E[i1]
E2 = self.E[i2]
eta = self.kernel(self.X[i1], self.X[i1]) + self.kernel(self.X[i2], self.X[i2]) - 2 * self.kernel(
self.X[i1], self.X[i2])
if eta <= 0:
# print('eta <= 0')
continue
alpha2_new_unc = self.alpha[i2] + self.Y[i2] * (E1 - E2) / eta
alpha2_new = self._compare(alpha2_new_unc, L, H)
alpha1_new = self.alpha[i1] + self.Y[i1] * self.Y[i2] * (self.alpha[i2] - alpha2_new)
self.alpha[i1] = alpha1_new
self.alpha[i2] = alpha2_new
b1_new= self.b
b2_new= self.b
if 0 < alpha1_new < self.C:
b1_new = -E1 - self.Y[i1] * self.kernel(self.X[i1], self.X[i1]) * (alpha1_new - self.alpha[i1]) - self.Y[
i2] * self.kernel(self.X[i2], self.X[i1]) * (alpha2_new - self.alpha[i2]) + self.b
if 0 < alpha2_new < self.C:
b2_new = -E2 - self.Y[i1] * self.kernel(self.X[i1], self.X[i2]) * (alpha1_new - self.alpha[i1]) - self.Y[
i2] * self.kernel(self.X[i2], self.X[i2]) * (alpha2_new - self.alpha[i2]) + self.b
b_new = (b1_new + b2_new) / 2
self.b = b_new
# 更新E
self.E[i1] = self._E(i1)
self.E[i2] = self._E(i2)
return 'train done!'
def predict(self, data):
r = self.b
for i in range(self.m):
r += self.alpha[i] * self.Y[i] * self.kernel(data, self.X[i])
return 1 if r > 0 else -1
def predicts(self, datas):
pred = np.array([])
for i in range(len(datas)):
pred = np.append(pred, self.predict(datas[i]))
return pred
def score(self, X_test, y_test):
right_count = 0
for i in range(len(X_test)):
result = self.predict(X_test[i])
if result == y_test[i]:
right_count += 1
return right_count / len(X_test)
svm = SVM(max_iter=500)
svm.fit(X_train, y_train)
print(svm.score(X_test, y_test))
9 SVR支持向量回歸
構建一個寬度為2ε的間隔帶，若訓練樣本落入此間隔帶，則認為是被預測正確的。圖像：
和SVM類似的，因此SVR問題可轉化為：
其中L是誤差計算函數，對小於epsilon的誤差為0：
同樣是數字，引入松弛變量替代，（間隔帶兩側的松弛程度可有所不同），則變成：
約束（即預測值與真實的差<=epsilon+松弛變量）：
引入拉格朗日乘子，可得拉格朗日函數：
存在不等式約束，所以上式還有KKT條件等約束。同樣的求導，然后對偶。
求導：
把上邊的式子帶入，即可求得SVR的對偶問題：
KKT條件：
如果求出a的話最后，可得SVR的模型：
10 sklearn實現SVC（支持向量分類）,SVR（支持向量回歸）：
scikit-learn SVM算法庫封裝了libsvm 和 liblinear 的實現，僅僅重寫了算法了接口部分。分為兩類，分類：SVC， NuSVC，和LinearSVC。回歸：SVR， NuSVR，和LinearSVR 。相關的類都包裹在sklearn.svm模塊中。sklearn官方svm API：https://scikit-learn.org/stable/modules/classes.html#module-sklearn.svm。
1）分類classification
SVC， NuSVC，和LinearSVC。SVC， NuSVC類似，區間是NuSVC多了nu參數：
| nu | LinearSVC 和SVC沒有這個參數，LinearSVC 和SVC使用懲罰系數C來控制懲罰力度。 | nu代表訓練集訓練的錯誤率的上限，或者說支持向量的百分比下限，取值范圍為(0,1],默認是0.5.它和懲罰系數C類似，都可以控制懲罰的力度。 | |
因此nu沒有懲罰系數C，因為它會自己選：
| 懲罰系數C | 即為我們第二節中SVM分類模型原型形式和對偶形式中的懲罰系數C，默認為1，一般需要通過交叉驗證來選擇一個合適的C。一般來說，如果噪音點較多時，C需要小一些。 | NuSVC沒有這個參數, 它通過另一個參數nu來控制訓練集訓練的錯誤率，等價於選擇了一個C，讓訓練集訓練后滿足一個確定的錯誤率 | |
LinearSVC從名字就可以看出，是線性分類，也就是不支持各種低維到高維的核函數，僅僅支持線性核函數，對線性不可分的數據不能使用。
2）回歸Regression
SVR， NuSVR，和LinearSVR。SVR， NuSVR差不多，區別僅僅在於對損失的度量方式不同，NuSVR有nu參數：
| nu | LinearSVR 和SVR沒有這個參數，用ϵ控制錯誤率 | nu代表訓練集訓練的錯誤率的上限，或者說支持向量的百分比下限，取值范圍為(0,1],默認是0.5.通過選擇不同的錯誤率可以得到不同的距離誤差ϵ。也就是說這里的nu的使用和LinearSVR 和SVR的ϵ參數等價。 | |
1）一般推薦在做訓練之前對數據進行歸一化，當然測試集中的數據也需要歸一化。。
2）在特征數非常多的情況下，或者樣本數遠小於特征數的時候，使用線性核，效果已經很好，並且只需要選擇懲罰系數C即可。
3）在選擇核函數時，如果線性擬合不好，一般推薦使用默認的高斯核'rbf'。這時我們主要需要對懲罰系數C和核函數參數γγ進行艱苦的調參，通過多輪的交叉驗證選擇合適的懲罰系數C和核函數參數γγ。
4）理論上高斯核不會比線性核差，但是這個理論卻建立在要花費更多的時間來調參上。所以實際上能用線性核解決問題我們盡量使用線性核。
這個有個不錯的中文表格介紹參數：https://www.cnblogs.com/pinard/p/6117515.html
使用方法具體看官方例子：
LinearSVC：https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVC.html#sklearn.svm.LinearSVC
LinearSVR ：https://scikit-learn.org/stable/modules/generated/sklearn.svm.LinearSVR.html#sklearn.svm.LinearSVR
NuSVC：https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVC.html#sklearn.svm.NuSVC
NuSVR：https://scikit-learn.org/stable/modules/generated/sklearn.svm.NuSVR.html#sklearn.svm.NuSVR
SVC：https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html#sklearn.svm.SVC
SVR:https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html#sklearn.svm.SVR
附一個SVC的實現：
from sklearn.svm import SVC
import numpy as np
import pandas as pd
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
def create_data():
iris = load_iris()
df = pd.DataFrame(iris.data, columns=iris.feature_names)
df['label'] = iris.target
df.columns = ['sepal length', 'sepal width', 'petal length', 'petal width', 'label']
data = np.array(df.iloc[:100, [0, 1, -1]])
for i in range(len(data)):
if data[i, -1] == 0:
data[i, -1] = -1
# print(data)
return data[:, :2], data[:, -1]
X, y = create_data()
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25)
clf = SVC()
clf.fit(X_train, y_train)
print('分數:', clf.score(X_test, y_test))
#分數: 0.96
可視化：https://blog.csdn.net/jiang425776024/article/details/87857059
