机器学习算法
代码下载链接
最小二乘支持向量详解
目录
-
- 数据
- 导入包
- 导入数据
- 定义核函数
- 初始化实例
- 最小二乘法求 参数
-
- 对def leastSquares() 方法求参数 alphas，b 的解释说明
-
- 方程求解
- hstack() 堆栈数组水平顺序（列）
- vstack（）：堆栈数组垂直顺序（行）
- 预测
- 主函数
数据
导入包
from numpy import *
- 1
导入数据
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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
定义核函数
支持向量机的几种核函数
LSSVM
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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
。。。。。。。
以上计算重复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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
循环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
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30
- 31
- 32
- 33
- 34
- 35
- 36
- 37
- 38
- 39
- 40
- 41
- 42
- 43
- 44
- 45
- 46
- 47
- 48
- 49
- 50
- 51
- 52
- 53
- 54
- 55
- 56
对def leastSquares() 方法求参数 alphas，b 的解释说明
方程求解
unit = mat(ones((oS.m,1))) # m行1列的 全1 矩阵
- 1
I = eye(oS.m) # m 行 m 列的单位矩阵
- 1
zero = mat(zeros((1,1))) # 1行1列的0矩阵
- 1
hstack() 堆栈数组水平顺序（列）
numpy中的stack操作：hstack()、vstack（）、stack（）、dstack（）、vsplit（）、concatenate（）
upmat = hstack((zero,unit.T)) # hstack（）：堆栈数组水平顺序（列）
- 1
downmat = hstack((unit,oS.K + I/float(C)))
- 1
completemat = vstack((upmat,downmat)) #lssvm中求解方程的左边矩阵
- 1
vstack（）：堆栈数组垂直顺序（行）
rightmat = vstack((zero,oS.labelMat)) # lssvm中求解方程的右边矩阵
- 1
b_alpha = completemat.I * rightmat
- 1
oS.b = b_alpha[0,0]
- 1
for i in range(oS.m):
oS.alphas[i,0] = b_alpha[i+1,0]
- 1
- 2
预测
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))
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
主函数
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)
- 1
- 2
- 3
- 4
- 5
- 6
- 7
- 8
- 9
- 10
- 11
- 12
- 13
- 14
- 15
- 16
- 17
- 18
- 19
- 20
- 21
- 22
- 23
- 24
- 25
- 26
- 27
- 28
- 29
- 30