机器学习实战之SVM

最新推荐文章于 2022-10-28 20:50:48 发布
最新推荐文章于 2022-10-28 20:50:48 发布
阅读量386 收藏
点赞数
分类专栏： 机器学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/steph_curry/article/details/79642143
版权

简版SMO:

from numpy import *
import time
import matplotlib.pyplot as plt
def loaddata(filename):
    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 selectrand(i,m):
    j=i
    while(j==i):
        j=int(random.uniform(0,m))
    return j
def clipalpha(aj,H,L):
    if(aj<L):
        aj=L
    if(aj>H):
        aj=H
    return aj
def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
    dataMatrix = mat(dataMatIn); labelMat = mat(classLabels).transpose()
    b = 0; m,n = shape(dataMatrix)
    alphas = mat(zeros((m,1)))
    iter = 0
    while (iter < maxIter):
        alphaPairsChanged = 0
        for i in range(m):
            fXi = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
            Ei = fXi - float(labelMat[i])#if checks if an example violates KKT conditions
            if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):
                j = selectrand(i,m)
                fXj = float(multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[j,:].T)) + b
                Ej = fXj - float(labelMat[j])
                alphaIold = alphas[i].copy(); alphaJold = alphas[j].copy()
                if (labelMat[i] != labelMat[j]):
                    L = max(0, alphas[j] - alphas[i])
                    H = min(C, C + alphas[j] - alphas[i])
                else:
                    L = max(0, alphas[j] + alphas[i] - C)
                    H = min(C, alphas[j] + alphas[i])
                if L==H: print ("L==H"); continue
                eta = 2.0 * dataMatrix[i,:]*dataMatrix[j,:].T - dataMatrix[i,:]*dataMatrix[i,:].T - dataMatrix[j,:]*dataMatrix[j,:].T
                if eta >= 0: print ("eta>=0"); continue
                alphas[j] -= labelMat[j]*(Ei - Ej)/eta
                alphas[j] = clipalpha(alphas[j],H,L)
                if (abs(alphas[j] - alphaJold) < 0.00001): print ("j not moving enough"); continue
                alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])#update i by the same amount as j
                                                                        #the update is in the oppostie direction
                b1 = b - Ei- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[i,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[i,:]*dataMatrix[j,:].T
                b2 = b - Ej- labelMat[i]*(alphas[i]-alphaIold)*dataMatrix[i,:]*dataMatrix[j,:].T - labelMat[j]*(alphas[j]-alphaJold)*dataMatrix[j,:]*dataMatrix[j,:].T
                if (0 < alphas[i]) and (C > alphas[i]): b = b1
                elif (0 < alphas[j]) and (C > alphas[j]): b = b2
                else: b = (b1 + b2)/2.0
                alphaPairsChanged += 1
                print ("iter: %d i:%d, pairs changed %d" % (iter,i,alphaPairsChanged))
        if (alphaPairsChanged == 0):
            iter += 1
        else: iter = 0
        print ("iteration number: %d" % iter)
    return b,alphas

def calcws(alphas,data,label):
    x=mat(data)
    label=mat(label).transpose()
    m,n=shape(x)
    w=zeros((n,1))

    for i in range(m):
        w+=multiply(alphas[i]*label[i],x[i,:].T)
    return w


data,label=loaddata(r"C:\Users\huashuo111\Desktop\python\machinelearninginaction\Ch06\testSet.txt")
data=mat(data)
label=mat(label)
b,alphas=smoSimple(data,label,0.6,0.001,40)

'''
w=mat(zeros((100,2)))
w=multiply(alphas,label.transpose())
w=multiply(w,data)
W=mat(zeros((1,2)))
W=sum(w,axis=0)


x=[]
y=[]
X=[]
Y=[]
for i in range(100):
    if label[0,i]==1:
        x.append(data[i,0])
        y.append(data[i,1])
    else:
        X.append(data[i, 0])
        Y.append(data[i, 1])

plt.scatter(x,y,s=20,c='red')
plt.scatter(X,Y,s=20,c='green')
xx=arange(0,10,0.1)
w1=W[0,0]
w2=W[0,1]
yy=(-b-w1*xx)/w2
A=[]
B=[]
for i in range(100):
    A.append(xx[i])
    B.append((yy[0,i]))

plt.plot(A,B)
plt.show()
'''

完整版SMO（速度提升约10倍）

import numpy as np
from numpy import *
import matplotlib.pyplot as plt
import time
def loadDataSet(filename):
    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 selectJrand(i,m):
    j=i
    while(j==i):
        j=int(random.uniform(0,m))
    return j

def clipAlphas(aj,H,L):
    if aj>H:
        aj=H
    if aj<L:
        aj=L
    return aj

class optStruct:
    def __init__(self,dataMatIn,classLabels,C,toler):
        self.X=dataMatIn
        self.labelMat=classLabels
        self.C=C
        self.tol=toler
        self.m=shape(dataMatIn)[0]
        self.alphas=mat(zeros((self.m,1)))
        self.b=0
        self.eCache=mat(zeros((self.m,2)))

def calcEk(oS,k):
    fXk=float(multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T))+oS.b
    Ek=fXk-float(oS.labelMat[k])
    return Ek

def selectJ(i,oS,Ei):
    maxK=-1;maxDeltaE=0;Ej=0
    oS.eCache[i]=[1,Ei]
    validEcacheList=nonzero(oS.eCache[:,0].A)[0]
    if len(validEcacheList)>1:
        for k in validEcacheList:
            if k==i:continue
            Ek=calcEk(oS,k)
            deltaE=abs(Ei-Ek)
            if(deltaE>maxDeltaE):
                maxK=k;
                maxDeltaE=deltaE;
                Ej=Ek;
        return maxK,Ej
    else:
        j=selectJrand(i,oS.m)
        Ej=calcEk(oS,j)
    return j,Ej

def updataEk(oS,k):
    Ek=calcEk(oS,k)
    oS.eCache[k]=[1,Ek]


def innerL(i,oS):
    Ei=calcEk(oS,i)
    if ((oS.labelMat[i]*Ei<-oS.tol)and(oS.alphas[i]<oS.C))or\
       ((oS.labelMat[i]*Ei>oS.tol)and(oS.alphas[i]>0)):
        j,Ej=selectJ(i,oS,Ei)
        alphaIold=oS.alphas[i].copy();alphaJold=oS.alphas[j].copy()
        if(oS.labelMat[i]!=oS.labelMat[j]):
            L=max(0,oS.alphas[j]-oS.alphas[i])
            H=min(oS.C,oS.C+oS.alphas[j]-oS.alphas[i])
        else:
            L=max(0,oS.alphas[j]+oS.alphas[i]-oS.C)
            H=min(oS.C,oS.C+oS.alphas[j]+oS.alphas[i])
        if L==H:print("L==H");return 0
        eta=2.0*oS.X[i,:]*oS.X[j,:].T-oS.X[i,:]*oS.X[i,:].T-oS.X[j,:]*oS.X[j,:].T
        if eta>=0:print("eta>=0");return 0
        oS.alphas[j]-=oS.labelMat[j]*(Ei-Ej)/eta
        oS.alphas[j]=clipAlphas(oS.alphas[j],H,L)
        updataEk(oS,j)
        if(abs(oS.alphas[j]-alphaJold)<0.00001):
            print("j not moving enough");return 0
        oS.alphas[i]+=oS.labelMat[j]*oS.labelMat[i]*(alphaJold-oS.alphas[j])
        updataEk(oS,i)
        b1=oS.b-Ei-oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[i,:].T-\
            oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[j,:]*oS.X[j,:].T
        b2=oS.b-Ej-oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[i,:].T-\
            oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.X[j,:]*oS.X[j,:].T

        if(0<oS.alphas[i])and(oS.C>oS.alphas[i]):oS.b=b1
        elif (0<oS.alphas[j])and(oS.C>oS.alphas[j]):oS.b=b2
        else:oS.b=(b1+b2)/2
        return 1
    else:
        return 0

 

def smoP(dataMatIn,classLabels,C,toler,maxIter):
    oS=optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,toler)
    iter=0
    entireSet=True;alphaPairsChanged=0
    while(iter<maxIter)and((alphaPairsChanged>0)or(entireSet)):
        alphaPairsChanged=0
        if entireSet:
            for i in range(oS.m):
                alphaPairsChanged+=innerL(i,oS)
            print("fullSet,iter:%d i:%d,pairs changed %d"%(iter,i,alphaPairsChanged))
            iter+=1
        else:
            nonBoundIs=nonzero((oS.alphas.A>0)*(oS.alphas.A<oS.C))[0]
            for i in nonBoundIs:
                alphaPairsChanged+=innerL(i,oS)
            print("non-bound,iter:%d i:%d,pairs changed %d"%(iter,i,alphaPairsChanged))
            iter+=1
        if entireSet:entireSet=False
        elif(alphaPairsChanged==0):entireSet=True
        print("iteration number:%d"%iter)
    return oS.b,oS.alphas
def calWs(alphas,dataArr,classLabels):
    X=mat(dataArr);labelMat=mat(classLabels).transpose()
    m,n=shape(X)
    w=zeros((n,1))
    for i in range(m):
        w+=multiply(alphas[i]*labelMat[i],X[i,:].T)
    return w

def plotfig_SVM(xMat,yMat,ws,b,alphas):
    xMat = mat(xMat)
    yMat = mat(yMat)
    b = array(b)[0] #b原来是矩阵，先转为数组类型后其数组大小为（1,1），所以后面加[0]，变为(1,)
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xMat[:,0].flatten().A[0],xMat[:,1].flatten().A[0]) #a.flatten()就是把a降到一维，默认是按横的方向降，矩阵.A（等效于矩阵.getA()）变成了数组
    x = arange(-1.0,10.0,0.1) #x最大值，最小值根据原数据集dataArr[:,0]的大小而定
    y =(-b-ws[0][0]*x)/ws[1][0] #根据x.w + b = 0 得到，其式子展开为w0.x1 + w1.x2 + b = 0,x2就是y值
    ax.plot(x,y)
    for i in range(100): #找到支持向量，并在图中标红
        if alphas[i]>0.0:
            ax.plot(xMat[i,0],xMat[i,1],'ro')
    plt.show()
    
dataArr,labelArr=loadDataSet(r'C:/Users/huashuo111/Desktop/python/machinelearninginaction/Ch06/testSet.txt')
b,alphas=smoP(dataArr,labelArr,0.6,0.001,40)
ws=calWs(alphas,dataArr,labelArr)
plotfig_SVM(dataArr,labelArr,ws,b,alphas)

核函数：

 
import numpy as np
from numpy import *
import matplotlib.pyplot as plt
import time
def loadDataSet(filename):
    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 selectJrand(i,m):
    j=i
    while(j==i):
        j=int(random.uniform(0,m))
    return j

def clipAlphas(aj,H,L):
    if aj>H:
        aj=H
    if aj<L:
        aj=L
    return aj

class optStruct:
    def __init__(self,dataMatIn,classLabels,C,toler,kTup):
        self.X=dataMatIn
        self.labelMat=classLabels
        self.C=C
        self.tol=toler
        self.m=shape(dataMatIn)[0]
        self.alphas=mat(zeros((self.m,1)))
        self.b=0
        self.eCache=mat(zeros((self.m,2)))
        self.K=mat(zeros((self.m,self.m)))
        for i in range(self.m):
            self.K[:,i]=kernelTrans(self.X,self.X[i,:],kTup)

def calcEk(oS,k):
    fXk=float(multiply(oS.alphas,oS.labelMat).T*oS.K[:,k])+oS.b
    Ek=fXk-float(oS.labelMat[k])
    return Ek

def selectJ(i,oS,Ei):
    maxK=-1;maxDeltaE=0;Ej=0
    oS.eCache[i]=[1,Ei]
    validEcacheList=nonzero(oS.eCache[:,0].A)[0]
    if len(validEcacheList)>1:
        for k in validEcacheList:
            if k==i:continue
            Ek=calcEk(oS,k)
            deltaE=abs(Ei-Ek)
            if(deltaE>maxDeltaE):
                maxK=k;
                maxDeltaE=deltaE;
                Ej=Ek;
        return maxK,Ej
    else:
        j=selectJrand(i,oS.m)
        Ej=calcEk(oS,j)
    return j,Ej

def updataEk(oS,k):
    Ek=calcEk(oS,k)
    oS.eCache[k]=[1,Ek]


def innerL(i,oS):
    Ei=calcEk(oS,i)
    if ((oS.labelMat[i]*Ei<-oS.tol)and(oS.alphas[i]<oS.C))or\
       ((oS.labelMat[i]*Ei>oS.tol)and(oS.alphas[i]>0)):
        j,Ej=selectJ(i,oS,Ei)
        alphaIold=oS.alphas[i].copy();alphaJold=oS.alphas[j].copy()
        if(oS.labelMat[i]!=oS.labelMat[j]):
            L=max(0,oS.alphas[j]-oS.alphas[i])
            H=min(oS.C,oS.C+oS.alphas[j]-oS.alphas[i])
        else:
            L=max(0,oS.alphas[j]+oS.alphas[i]-oS.C)
            H=min(oS.C,oS.C+oS.alphas[j]+oS.alphas[i])
        if L==H:print("L==H");return 0
        eta=2.0*oS.K[i,j]-oS.K[i,i]-oS.K[j,j]
        if eta>=0:print("eta>=0");return 0
        oS.alphas[j]-=oS.labelMat[j]*(Ei-Ej)/eta
        oS.alphas[j]=clipAlphas(oS.alphas[j],H,L)
        updataEk(oS,j)
        if(abs(oS.alphas[j]-alphaJold)<0.00001):
            print("j not moving enough");return 0
        oS.alphas[i]+=oS.labelMat[j]*oS.labelMat[i]*(alphaJold-oS.alphas[j])
        updataEk(oS,i)
        b1=oS.b-Ei-oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,i]-\
            oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j]
        b2=oS.b-Ej-oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.K[i,i]-\
            oS.labelMat[j]*(oS.alphas[j]-alphaJold)*oS.K[j,j]

        if(0<oS.alphas[i])and(oS.C>oS.alphas[i]):oS.b=b1
        elif (0<oS.alphas[j])and(oS.C>oS.alphas[j]):oS.b=b2
        else:oS.b=(b1+b2)/2
        return 1
    else:
        return 0

 

def smoP(dataMatIn,classLabels,C,toler,maxIter,kTup=('lin',0)):
    oS=optStruct(mat(dataMatIn),mat(classLabels).transpose(),C,toler,kTup)
    iter=0
    entireSet=True;alphaPairsChanged=0
    while(iter<maxIter)and((alphaPairsChanged>0)or(entireSet)):
        alphaPairsChanged=0
        if entireSet:
            for i in range(oS.m):
                alphaPairsChanged+=innerL(i,oS)
            print("fullSet,iter:%d i:%d,pairs changed %d"%(iter,i,alphaPairsChanged))
            iter+=1
        else:
            nonBoundIs=nonzero((oS.alphas.A>0)*(oS.alphas.A<oS.C))[0]
            for i in nonBoundIs:
                alphaPairsChanged+=innerL(i,oS)
            print("non-bound,iter:%d i:%d,pairs changed %d"%(iter,i,alphaPairsChanged))
            iter+=1
        if entireSet:entireSet=False
        elif(alphaPairsChanged==0):entireSet=True
        print("iteration number:%d"%iter)
    return oS.b,oS.alphas

def kernelTrans(X,A,kTup):
    m,n=shape(X)
    K=mat(zeros((m,1)))
    if kTup[0]=='lin':
        K=X*A.T
    elif kTup[0]=='rbf':
        for j in range(m):
            deltaRow=X[j,:]-A
            K[j]=deltaRow*deltaRow.T
        K=exp(-K/(kTup[1]**2))
    else:raise NameError("The Kernel is not recognized!")
    return K

def testRbf(k1=1.3):
    dataArr,labelArr=loadDataSet(r'C:/Users/huashuo111/Desktop/python/machinelearninginaction/Ch06/testSetRBF.txt')
    b,alphas=smoP(dataArr,labelArr,200,0.0001,10000,('rbf',k1))
    dataMat=mat(dataArr)
    labelMat=mat(labelArr).transpose()
    svInd=nonzero(alphas.A>0)[0]
    sVs=dataMat[svInd]
    labelSV=labelMat[svInd];print("there are %d support vectors" % shape(sVs)[0])
    m,n=shape(dataMat)
    errorCount=0
    for i in range(m):
        kernelEval=kernelTrans(sVs,dataMat[i,:],('rbf',k1))
        predict=kernelEval.T*multiply(labelSV,alphas[svInd])+b
        if sign(predict)!=sign(labelArr[i]):errorCount+=1
    print("the training error rate is: %f" %(float(errorCount)/m))
    dataArr,labelArr=loadDataSet(r'C:/Users/huashuo111/Desktop/python/machinelearninginaction/Ch06/testSetRBF2.txt')
    dataMat=mat(dataArr)
    labelMat=mat(labelArr).transpose()
    errorCount=0
    m,n=shape(labelMat)
    for i in range(m):
        kernelEval=kernelTrans(sVs,dataMat[i,:],('rbf',k1))
        predict=kernelEval.T*multiply(labelSV,alphas[svInd])+b
        if sign(predict)!=sign(labelArr[i]):errorCount+=1
    print("the test error rate is: %f" %(float(errorCount)/m))   
def calWs(alphas,dataArr,classLabels):
    X=mat(dataArr);labelMat=mat(classLabels).transpose()
    m,n=shape(X)
    w=zeros((n,1))
    for i in range(m):
        w+=multiply(alphas[i]*labelMat[i],X[i,:].T)
    return w

def plotfig_SVM(xMat,yMat,ws,b,alphas):
    xMat = mat(xMat)
    yMat = mat(yMat)
    b = array(b)[0] #b原来是矩阵，先转为数组类型后其数组大小为（1,1），所以后面加[0]，变为(1,)
    fig = plt.figure()
    ax = fig.add_subplot(111)
    ax.scatter(xMat[:,0].flatten().A[0],xMat[:,1].flatten().A[0]) #a.flatten()就是把a降到一维，默认是按横的方向降，矩阵.A（等效于矩阵.getA()）变成了数组
    x = arange(-1.0,10.0,0.1) #x最大值，最小值根据原数据集dataArr[:,0]的大小而定
    y =(-b-ws[0][0]*x)/ws[1][0] #根据x.w + b = 0 得到，其式子展开为w0.x1 + w1.x2 + b = 0,x2就是y值
    ax.plot(x,y)
    for i in range(100): #找到支持向量，并在图中标红
        if alphas[i]>0.0:
            ax.plot(xMat[i,0],xMat[i,1],'ro')
    plt.show()
    
testRbf()

steph_curry
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
机器学习实战--SVM
weixin_45422335的博客
03-25 440
一、概述 SVM是一种二类分类模型，其基本模型定义为特征空间上的间隔最大的线性分类器，即支持向量机的学习策略便是间隔最大化。 训练数据线性可分时，通过硬间隔最大化，学习一个线性分器，即线性可分支持向量机，又称为硬间隔支持向量机；训练数据近似线性可分时，通过软间隔最大化，也学习一个线性分类器，即线性支持向量机，也称为软间隔支持向量机；训练数据线性不可分时，通过使用核技巧和软间隔最大化，学习非线性支持...
针对testSet.txt中数据，使用SVM进行分类，并画出分隔结果，标出支持向量。
IT_zxl001的博客
05-28 2732
训练集：testSet.txt# 1. 针对testSet.txt中数据，使用SVM进行分类，并画出分隔结果，标出支持向量。 from numpy import * import matplotlib.pyplot as plt from sklearn import svm # 加载数据集 def loadDataSet(filename): dataMat = []; labelM...
机器学习实战-SVM
weixin_34375054的博客
05-19 184
　　支持向量机 　　线性SVM分类 　　SVM可用于回归、分类，甚至是异常检测，它很强大，广受欢迎。作为线性分类器时，它的核心思想是，不但要正确划分类别，而且要使得离决策边界最近的实例到决策边界的距离最大，这样就能使模型具有良好的泛化性能，因而也并称为大间隔分类。 　　　　　　 　　这些决策边界之间就像街道一样，而 在街道之外增加实例，并不会影响决策边界，因为它是由决策边界上的实例决定的，...
【机器学习实战】第6章 支持向量机
片刻 - ApacheCN
04-24 2516
第6章 支持向量机 http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default">> 支持向量机 概述 支持向量机(Support Vector Machines, SVM)：是一种机器学习算法。 支持向量(Support Vector)就是离分隔超平面最近的那些点。机(Machine)就是表示一种
机器学习实战（SVM）
weixin_44337883的博客
04-12 1678
支持向量机是一个功能强大并且全面的机器学习模型，它能够执行线性或非线性分类、回归，甚至是异常值检测任务。
机器学习实战——SVM
m0_55818687的博客
10-26 243
机器学习实战——svm
机器学习 svm实战 课程论文
最新发布
07-06
机器学习算法svm
机器学习实战.zip
04-12
随着统计学的发展，统计学习在机器学习中占据了重要地位，支持向量机（SVM）、决策树和随机森林等算法的提出和发展，使得机器学习能够更好地处理分类、回归和聚类等任务。进入21世纪，深度学习成为机器学习领域的...
《机器学习实战》—SVM
anzhi的博客
07-11 1865
机器学习实战—SVM（支持向量机）SVMSVM - Support Vector Machine：支持向量机，其含义是通过支持向量运算的分类器。其中“机”的意思是机器，可以理解为分类器。在求解的过程中，会发现只根据部分数据就可以确定分类器，这些数据称为支持向量。见下图，在一个二维环境中，其中点R，S，G点和其它靠近中间黑线的点可以看作为支持向量，它们可以决定分类器，也就是黑线的具体参数。线性分类在...
《机器学习实战》6.支持向量机（SVM）
豆豆豆豆芽的博客
10-28 1332
本章涉及到的向SVM有很多种实现方法，但是这里学习最流行的一种，即序列最小化（SMO）算法。在此之后，将介绍如何使用一种称为核函数的方式奖SVM拓展到更多数据集上。
机器学习实战笔记——SVM算法
Evitachan的博客
05-18 1283
      我理解的支持向量机，就是找到个超平面，将样本空间划分为两类，并使得距离超平面最近的点尽可能远。基于数据集中某几个样本点就能找到这样的超平面，这些样本点称为支持向量。如果只是简单划分为两类，下图中5条线都可以，但如果满足最优划分，只有粗线满足了。超平面满足线性方程ωTx+b=0任意点到超平面的距离为                                             ...
实习笔记Day03:SSM框架与SVM
weixin_39670804的博客
06-28 366
实习笔记Day03:SSM框架与mvc什么是SSM1.1、Spring1.2、SpringMVC1.3、MyBatis 什么是SSM 1.1、Spring Spring是一个轻量级的控制反转（IOC）和面向切面（AOP）的容器框架。 让spring帮助我们new对象。 1.2、SpringMVC Spring MVC属于SpringFrameWork的后续产品，已经融合在Spring Web Fl...
Python3《机器学习实战》学习笔记（七）：Logistic回归实战篇之预测病马死亡率
热门推荐
Jack-Cui
09-05 3万+
本文对梯度上升算法和改进的随机梯度上升算法进行了对比，总结了各自的优缺点，并对sklearn.linear_model.LogisticRegression进行了详细介绍。
【机器学习实战】支持向量机SMO算法详解
lyl771857509的博客
03-03 1731
SMO算法 # 加载数据 def loadDataSet(fileName): dataMat = [];labelMat = [] fr = open(fileName) for line in fr.readlines(): lineArr = line.strip
Python机器学习实战之逻辑回归
沉心修炼
12-30 1331
逻辑回归Python代码
python line.strip().split()_.strip().split()
weixin_39822923的博客
12-18 5431
np.argsort()用法import numpy as npx=np.array([1,4,3,-1,6,9])x.argsort()输出的结果为array([3,0,2,1,4,5])argsort()函数是将x中的元素从小到大排列，提取其对应的index(索引)，然后输出到y。例如：x[3]=-1最小，所以y[0]=3,x[5]=9最大，所以y[5]=5。np.argsort()[num]...
支持向量机python代码_【机器学习算法-python实现】svm支持向量机(二)—简化版SMO算法...
weixin_39560245的博客
11-24 141
import matplotlib.pyplot as pltfrom numpy import *from time import sleepdef loadDataSet(fileName):dataMat = []; labelMat = []fr = open(fileName)for line in fr.readlines():lineArr = line.strip().split(...
机器学习理论与实战（六）支持向量机
计算机视觉、机器学习朝拜者
07-11 5749
上节基本完成了SVM的理论推倒，寻找最大化间隔的目标最终转换成求解拉格朗日对偶变量alpha的求解问题，求出了alpha即可求解出SVM的权重W，有了权重也就有了最大间隔距离，但是其实上节我们有个假设：就是训练集是线性可分的，这样求出的alpha在[0,infinite]。但是如果数据不是线性可分的呢？此时我们就要允许部分的样本可以越过分类器，这样优化的目标函数就可以不变，只要引入松弛变量即可，它
实现一下模式识别（四）支持向量机
zarathurstra的博客
07-27 277
看了很多，对我来说最有帮助的是Python3《机器学习实战》学习笔记（八）：支持向量机原理篇之手撕线性SVM截图保存一下内容 # -*- coding:UTF-8 -*- from time import sleep import matplotlib.pyplot as plt import numpy as np import random import types """ 函数说明:读取数据 fileName - 文件名 dataMat - 数据矩阵 labelMat
实战机器学习1
08-03
"实战机器学习1"是一本由ApacheCN提供并广泛参与编写的机器学习实战指南，它旨在帮助读者理解和应用机器学习的基本概念和算法。该书分为五个主要部分，涵盖了机器学习的核心内容。 第一部分着重于机器学习基础，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值