目錄
數據
導入包
from numpy import *
導入數據
def loadDataSet(filename):
'''導入數據
input: filename:文件名
output:dataMat(list)樣本特徵
labelMat(list)樣本標籤
'''
dataMat = []
labelMat = []
fr = open(filename)
for line in fr.readlines():
lineArr = line.strip().split('\t')
dataMat.append([float(lineArr[0]),float(lineArr[1])])
labelMat.append(float(lineArr[2]))
return dataMat,labelMat
定義核函數
def kernelTrans(X,A,kTup):
'''數據集中每一個數據向量與數據A的核函數值
input: X--特徵數據集
A--輸入向量
kTup--核函數參量定義
output: K--數據集中每一個數據向量與A的核函數值組成的矩陣
'''
# 本實驗對該方法的調用
# self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)
X = mat(X)
m,n = shape(X)
K = mat(zeros((m,1)))
if kTup[0] == 'lin':
# 線性函數
K = X * A.T
elif kTup[0] == 'rbf':
# rbf 徑向基函數
# 對矩陣 K 的每一列的每一行進行覈計算
for j in range(m):
deltaRow = X[j,:] - A
K[j] = deltaRow * deltaRow.T
K = exp(K/(-1 * kTup[1] ** 2))
else: raise NameError('Houston We Have a Problem -- That Kernel is not recognized')
return K
。。。。。。。
以上計算重複9次
初始化實例
class optStruct:
def __init__(self,dataMatIn,classLabels,C,kTup):
self.X = dataMatIn
self.labelMat = classLabels
self.C = C
self.m = shape(dataMatIn)[0]
self.alphas = mat(zeros((self.m,1)))
self.b = 0
self.K = mat(zeros((self.m,self.m))) #特徵數據集合中向量兩兩核函數值組成的矩陣，[i,j]表示第i個向量與第j個向量的核函數值
for i in range(self.m):
# 對 矩陣 K 的每一列進行覈計算
self.K[:,i] = kernelTrans(self.X, self.X[i,:], kTup)
print("i:",i)
print("self.K:\n",self.K)
# print(KKKKK)
循環9次
最小二乘法求 參數
def leastSquares(dataMatIn,classLabels,C,kTup):
'''最小二乘法求解alpha序列
input:dataMatIn(list):特徵數據集
classLabels(list):分類標籤集
C(float):參數，（鬆弛變量，允許有些數據點可以處於分隔面的錯誤一側)
kTup(string): 核函數類型和參數選擇
output:b(float):w.T*x+b=y中的b
alphas(mat):alphas序列
'''
# 調用 optStruct 方法，計算得到 核矩陣 K
oS = optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,kTup)
# print("oS.X:\n",oS.X) # 100 * 2
# print("oS.labelMat:\n",oS.labelMat) # 100 * 1
# print("oS.C:\n",oS.C)
# print("oS.m:\n",oS.m)
# print("alphas:\n",oS.alphas)
# print("oS.b:\n",oS.b) # 0
# print("oS.K:\n",oS.K) #
# print("oS.K.shape:\n",oS.K.shape) # 100 * 100
# 打印自定義變量得到的參數 b ,alphas
#1.參數設置
unit = mat(ones((oS.m,1))) #[1,1,...,1].T
# print("unit:\n",unit)
I = eye(oS.m) # m 行 m 列的單位矩陣
# print("I:\n",I)
zero = mat(zeros((1,1)))
# print("zero:\n",zero)
# print("zero.shape:",zero.shape)
# hstack（）：堆棧數組水平順序（列）
upmat = hstack((zero,unit.T)) # hstack((1,1),(1,m)) = (1,10)
# print("upmat:\n",upmat)
# print("upmat.shape:\n",upmat.shape)
downmat = hstack((unit,oS.K + I/float(C))) # hstack((m,1),(m,m)+(m,m)) = (m,m+1)
# print("downmat:\n",downmat)
# print("downmat.shape:\n", downmat.shape)
##2.方程求解
#lssvm中求解方程的左邊矩陣
completemat = vstack((upmat,downmat)) # vstack((1,10),(9,10)) = (10,10)
# print("completemat:\n",completemat)
# print("completemat.shape:\n",completemat.shape)
# lssvm中求解方程的右邊矩陣
rightmat = vstack((zero,oS.labelMat)) # vstack((1，1),(m,1)) = (m+1,1)
# print("rightmat:\n",rightmat)
# print("rightmat.shape",rightmat.shape)
# completemat.I : completemat 的逆矩陣
b_alpha = completemat.I * rightmat # 10 *1
# print("b_alpha:\n",b_alpha)
# print("b_alpha:\n",b_alpha.shape)
oS.b = b_alpha[0,0]
# print("oS.b:",oS.b)
for i in range(oS.m):
oS.alphas[i,0] = b_alpha[i+1,0]
# print("oS.alphas:\n",oS.alphas)
# print("oS.alphas.shape:\n",oS.alphas.shape)
return oS.alphas,oS.b,oS.K
對def leastSquares() 方法求參數 alphas，b 的解釋說明
方程求解
unit = mat(ones((oS.m,1))) # m行1列的 全1 矩陣
I = eye(oS.m) # m 行 m 列的單位矩陣
zero = mat(zeros((1,1))) # 1行1列的0矩陣
hstack() 堆棧數組水平順序（列）
numpy中的stack操作：hstack()、vstack（）、stack（）、dstack（）、vsplit（）、concatenate（）
upmat = hstack((zero,unit.T)) # hstack（）：堆棧數組水平順序（列）
downmat = hstack((unit,oS.K + I/float(C)))
completemat = vstack((upmat,downmat)) #lssvm中求解方程的左邊矩陣
vstack（）：堆棧數組垂直順序（行）
rightmat = vstack((zero,oS.labelMat)) # lssvm中求解方程的右邊矩陣
b_alpha = completemat.I * rightmat
oS.b = b_alpha[0,0]
for i in range(oS.m):
oS.alphas[i,0] = b_alpha[i+1,0]
預測
def predict(alphas,b,dataMat,testVec):
'''預測結果
input:alphas(mat):Lagrange乘子序列
b(float):分隔超平面的偏置
dataMat()
output：sign(float(predict_value))(int):預測樣本的類別
'''
Kx = kernelTrans(dataMat,testVec,kTup) #可以對alphas進行稀疏處理找到更準確的值
predict_value = Kx.T * alphas + b
# print('預測值爲：%f'%predict_value)
# print('分類結果爲：%f'%sign(float(predict_value)))
return sign(float(predict_value))
主函數
if __name__ == '__main__':
##1.導入數據
print('-----------------------------1.Load Data-------------------------------')
dataMat,labelMat = loadDataSet('testSetRBF.txt')
# print("dataMat:\n",dataMat)
# print("labelMat:\n",labelMat)
C = 0.6
k1 = 0.3
kernel = 'rbf'
print("kernel:",kernel) # 打印：kernel: rbf
kTup = (kernel,k1)
print("kTup:",kTup) # 打印：kTup:('rbf', 0.3)
##2.訓練模型
print('----------------------------2.Train Model------------------------------')
alphas,b,K = leastSquares(dataMat,labelMat,C,kTup)
# print("alphas:\n",alphas)
# print("b:\n",b)
#3.計算訓練誤差
print('----------------------------3.Calculate Train Error--------------------')
error = 0.0
Y_predict = []
# print("訓練集有 %int 條數據"%len(dataMat))
for i in range(len(dataMat)):
test = predict(alphas,b,dataMat,dataMat[i])
Y_predict.append(test)
if test != float(labelMat[i]):
error +=1.0
# print("Y_predict:\n",Y_predict)
errorRate = error/len(dataMat)
# print('---------------訓練誤差爲：%f-------------------'%errorRate)