【机器学习代码例】LSSVM,python代码实例

机器学习算法

代码下载链接

最小二乘支持向量详解

数据

在这里插入图片描述

导入包

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

在这里插入图片描述
在这里插入图片描述

定义核函数

支持向量机的几种核函数
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

在这里插入图片描述
在这里插入图片描述
。。。。。。。
在这里插入图片描述
在这里插入图片描述
以上计算重复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)
發表評論
所有評論
還沒有人評論,想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章