《机器学习实战》—SVM

最新推荐文章于 2024-07-30 01:28:06 发布
最新推荐文章于 2024-07-30 01:28:06 发布
阅读量1.9k 收藏 6
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42314808/article/details/81001586
版权

机器学习实战—SVM（支持向量机）

SVM

SVM - Support Vector Machine：支持向量机，其含义是通过支持向量运算的分类器。其中“机”的意思是机器，可以理解为分类器。在求解的过程中，会发现只根据部分数据就可以确定分类器，这些数据称为支持向量。

见下图，在一个二维环境中，其中点R，S，G点和其它靠近中间黑线的点可以看作为支持向量，它们可以决定分类器，也就是黑线的具体参数。

线性分类

在训练数据中，每个数据都有n个的属性和一个二类类别标志，我们可以认为这些数据在一个n维空间里。我们的目标是找到一个n-1维的超平面（hyperplane），这个超平面可以将数据分成两部分，每部分数据都属于同一个类别。

其实这样的超平面有很多，我们要找到一个最佳的。因此，增加一个约束条件：这个超平面到每边最近数据点的距离是最大的。也成为最大间隔超平面（maximum-margin hyperplane）。这个分类器也成为最大间隔分类器（maximum-marginclassifier）。

支持向量机是一个二类分类器。

f(x) = xw^T + b

w 和 b 是训练数据后产生的值。

KTT条件

核心思想

SVM的目的是要找到一个线性分类的最佳超平面f(x)=xwT+b=0。求 w 和 b。

首先通过两个分类的最近点，找到f(x)的约束条件。

有了约束条件，就可以通过拉格朗日乘子法和KKT条件来求解，这时，问题变成了求拉格朗日乘子ai 和 b。

对于异常点的情况，加入松弛变量ξ来处理。

使用SMO来求拉格朗日乘子ai和b。这时，我们会发现有些ai=0，这些点就可以不用在分类器中考虑了。

惊喜! 不用求w了，可以使用拉格朗日乘子ai和b作为分类器的参数。

非线性分类的问题：映射到高维度、使用核函数。

SMO算法优化

核心公式：



优化方法：

最外层循环，首先在样本中选择违反KKT条件的一个乘子作为最外层循环，然后用”启发式选择”选择另外一个乘子并进行这两个乘子的优化

在非边界乘子中寻找使得|E_i - E_j|最大的样本

如果没有找到，则从整个样本中随机选择一个样本

完整版SMO算法

完整版Platt SMO算法是通过一个外循环来选择违反KKT条件的一个乘子，并且其选择过程会在这两种方式之间进行交替：

在所有数据集上进行单遍扫描

在非边界α中实现单遍扫描

非边界α指的就是那些不等于边界0或C的α值，并且跳过那些已知的不会改变的α值。所以我们要先建立这些α的列表，用于才能出α的更新状态。

在选择第一个α值后，算法会通过“启发选择方式”选择第二个α值。

简化版SVM——SMO代码：
import matplotlib.pyplot as plt
import numpy as np
import random


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 clipAlpha(aj,H,L):
	if aj > H: 
		aj = H
	if L > aj:
		aj = L
	return aj


def showDataSet(dataMat, labelMat):
	data_plus = []                                 
	data_minus = []                               
	for i in range(len(dataMat)):
		if labelMat[i] > 0:
			data_plus.append(dataMat[i])
		else:
			data_minus.append(dataMat[i])
	data_plus_np = np.array(data_plus)            
	data_minus_np = np.array(data_minus)           
	plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1])   
	plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1]) 
	plt.show()



def smoSimple(dataMatIn, classLabels, C, toler, maxIter):
	dataMatrix = np.mat(dataMatIn); labelMat = np.mat(classLabels).transpose()
	b = 0; m,n = np.shape(dataMatrix)
	alphas = np.mat(np.zeros((m,1)))
	iter_num = 0
	while (iter_num < maxIter):
		alphaPairsChanged = 0
		for i in range(m):
			fXi = float(np.multiply(alphas,labelMat).T*(dataMatrix*dataMatrix[i,:].T)) + b
			Ei = fXi - float(labelMat[i])
			if ((labelMat[i]*Ei < -toler) and (alphas[i] < C)) or ((labelMat[i]*Ei > toler) and (alphas[i] > 0)):
				j = selectJrand(i,m)
				fXj = float(np.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("alpha_j变化太小"); continue
				alphas[i] += labelMat[j]*labelMat[i]*(alphaJold - alphas[j])
				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("第%d次迭代 样本:%d, alpha优化次数:%d" % (iter_num,i,alphaPairsChanged))
		if (alphaPairsChanged == 0): iter_num += 1
		else: iter_num = 0
		print("迭代次数: %d" % iter_num)
	return b,alphas

def showClassifer(dataMat, w, b):
	#绘制样本点
	data_plus = []                                
	data_minus = []                                 
	for i in range(len(dataMat)):
		if labelMat[i] > 0:
			data_plus.append(dataMat[i])
		else:
			data_minus.append(dataMat[i])
	data_plus_np = np.array(data_plus)             
	data_minus_np = np.array(data_minus)           
	plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1], s=30, alpha=0.7)   
	plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1], s=30, alpha=0.7) 
	x1 = max(dataMat)[0]
	x2 = min(dataMat)[0]
	a1, a2 = w
	b = float(b)
	a1 = float(a1[0])
	a2 = float(a2[0])
	y1, y2 = (-b- a1*x1)/a2, (-b - a1*x2)/a2
	plt.plot([x1, x2], [y1, y2])
	for i, alpha in enumerate(alphas):
		if abs(alpha) > 0:
			x, y = dataMat[i]
			plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
	plt.show()


def get_w(dataMat, labelMat, alphas):
    alphas, dataMat, labelMat = np.array(alphas), np.array(dataMat), np.array(labelMat)
    w = np.dot((np.tile(labelMat.reshape(1, -1).T, (1, 2)) * dataMat).T, alphas)
    return w.tolist()


if __name__ == '__main__':
	dataMat, labelMat = loadDataSet('testSet.txt')
	b,alphas = smoSimple(dataMat, labelMat, 0.6, 0.001, 40)
	w = get_w(dataMat, labelMat, alphas)
	showClassifer(dataMat, w, b)
完整版SVM——SMO代码：
import matplotlib.pyplot as plt
import numpy as np
import random
class optStruct:

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

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 calcEk(oS, k):
	
	fXk = float(np.multiply(oS.alphas,oS.labelMat).T*(oS.X*oS.X[k,:].T) + oS.b)
	Ek = fXk - float(oS.labelMat[k])
	return Ek

def selectJrand(i, m):
	
	j = i                                 
	while (j == i):
		j = int(random.uniform(0, m))
	return j

def selectJ(i, oS, Ei):
	
	maxK = -1; maxDeltaE = 0; Ej = 0 						
	oS.eCache[i] = [1,Ei]  									
	validEcacheList = np.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 updateEk(oS, k):

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


def clipAlpha(aj,H,L):

	if aj > H: 
		aj = H
	if L > aj:
		aj = L
	return aj

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.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] = clipAlpha(oS.alphas[j],H,L)
		updateEk(oS, j)
		if (abs(oS.alphas[j] - alphaJold) < 0.00001): 
			print("alpha_j变化太小")
			return 0
		oS.alphas[i] += oS.labelMat[j]*oS.labelMat[i]*(alphaJold - oS.alphas[j])
		updateEk(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[i,:]*oS.X[j,:].T
		b2 = oS.b - Ej- oS.labelMat[i]*(oS.alphas[i]-alphaIold)*oS.X[i,:]*oS.X[j,:].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.0
		return 1
	else: 
		return 0

def smoP(dataMatIn, classLabels, C, toler, maxIter):

	oS = optStruct(np.mat(dataMatIn), np.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("全样本遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
			iter += 1
		else: 																						
			nonBoundIs = np.nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]						
			for i in nonBoundIs:
				alphaPairsChanged += innerL(i,oS)
				print("非边界遍历:第%d次迭代 样本:%d, alpha优化次数:%d" % (iter,i,alphaPairsChanged))
			iter += 1
		if entireSet:																				
			entireSet = False
		elif (alphaPairsChanged == 0):																
			entireSet = True  
		print("迭代次数: %d" % iter)
	return oS.b,oS.alphas 																			


def showClassifer(dataMat, classLabels, w, b):

	data_plus = []                                 
	data_minus = []                              
	for i in range(len(dataMat)):
		if classLabels[i] > 0:
			data_plus.append(dataMat[i])
		else:
			data_minus.append(dataMat[i])
	data_plus_np = np.array(data_plus)              
	data_minus_np = np.array(data_minus)           
	plt.scatter(np.transpose(data_plus_np)[0], np.transpose(data_plus_np)[1], s=30, alpha=0.7)   
	plt.scatter(np.transpose(data_minus_np)[0], np.transpose(data_minus_np)[1], s=30, alpha=0.7) 
	x1 = max(dataMat)[0]
	x2 = min(dataMat)[0]
	a1, a2 = w
	b = float(b)
	a1 = float(a1[0])
	a2 = float(a2[0])
	y1, y2 = (-b- a1*x1)/a2, (-b - a1*x2)/a2
	plt.plot([x1, x2], [y1, y2])
	for i, alpha in enumerate(alphas):
		if alpha > 0:
			x, y = dataMat[i]
			plt.scatter([x], [y], s=150, c='none', alpha=0.7, linewidth=1.5, edgecolor='red')
	plt.show()


def calcWs(alphas,dataArr,classLabels):
	
	X = np.mat(dataArr); labelMat = np.mat(classLabels).transpose()
	m,n = np.shape(X)
	w = np.zeros((n,1))
	for i in range(m):
		w += np.multiply(alphas[i]*labelMat[i],X[i,:].T)
	return w

if __name__ == '__main__':
	dataArr, classLabels = loadDataSet('testSet.txt')
	b, alphas = smoP(dataArr, classLabels, 0.6, 0.001, 40)
	w = calcWs(alphas,dataArr, classLabels)
	showClassifer(dataArr, classLabels, w, b)

完整版SMO算法与简化版算法对比：


图中画红圈的样本点为支持向量上的点，是满足算法的一种解。完整版SMO算法覆盖整个数据集进行计算，而简化版SMO算法是随机选择的。可以看出，完整版SMO算法选出的支持向量样点更多，更接近理想的分隔超平面。

非线性SVM

核函数：

对于线性可分的平面其超平面方程：

对于线性不可分平面：

参考文献

【1】Peter Harrington, Machine Learning inAction[M] . US 2007

【2】深入理解拉格朗日乘子和KTT条件


leanzhi
关注
机器学习实战（SVM）
weixin_44337883的博客
04-12 1692
支持向量机是一个功能强大并且全面的机器学习模型，它能够执行线性或非线性分类、回归，甚至是异常值检测任务。
机器学习实战-SVM
weixin_34375054的博客
05-19 191
　　支持向量机 　　线性SVM分类 　　SVM可用于回归、分类，甚至是异常检测，它很强大，广受欢迎。作为线性分类器时，它的核心思想是，不但要正确划分类别，而且要使得离决策边界最近的实例到决策边界的距离最大，这样就能使模型具有良好的泛化性能，因而也并称为大间隔分类。 　　　　　　 　　这些决策边界之间就像街道一样，而 在街道之外增加实例，并不会影响决策边界，因为它是由决策边界上的实例决定的，...
【机器学习】机器学习的基本概念、算法的工作原理、实际应用案例
最新发布
weixin_51306394的博客
07-30 2589
机器学习是人工智能的一个分支，它使计算机能够在没有明确编程的情况下从数据中学习并改进其性能。机器学习的目标是让计算机自动学习模式和规律，从而能够对未知数据做出预测或决策。
机器学习实战——SVM
m0_55818687的博客
10-26 260
机器学习实战——svm
机器学习实战--SVM
weixin_45422335的博客
03-25 470
一、概述 SVM是一种二类分类模型，其基本模型定义为特征空间上的间隔最大的线性分类器，即支持向量机的学习策略便是间隔最大化。 训练数据线性可分时，通过硬间隔最大化，学习一个线性分器，即线性可分支持向量机，又称为硬间隔支持向量机；训练数据近似线性可分时，通过软间隔最大化，也学习一个线性分类器，即线性支持向量机，也称为软间隔支持向量机；训练数据线性不可分时，通过使用核技巧和软间隔最大化，学习非线性支持...
【机器学习实战】第6章 支持向量机
片刻 - ApacheCN
04-24 2558
第6章 支持向量机 http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=default">> 支持向量机 概述 支持向量机(Support Vector Machines, SVM)：是一种机器学习算法。 支持向量(Support Vector)就是离分隔超平面最近的那些点。机(Machine)就是表示一种
《机器学习实战》（五）-- SVM
weixin_41638083的博客
09-03 280
目录绪言Xmind模块语法NumPyreshape(1,-1)dot()*一些函数copy()enumerate() 绪言 我最近开始入门机器学习，使用的书是《机器学习实战》（Peter Harrington 著），为了巩固学习成果，决定写一系列日志，内容是总结性的，会做一些思维导图，写一些我学习时不懂的模块，函数语法等，但不涉及具体算法的实现（不具备教程性质）。 Xmind 模块语法 NumPy...
机器学习 svm实战 课程论文
07-06
### 机器学习中的支持向量机(SVM)理论与实战 #### 1. 前言 ##### 1.1 选题背景和意义 在机器学习领域中，支持向量机(Support Vector Machine, SVM)是一种广泛使用的监督学习方法，主要用于分类和回归任务。随着...
机器学习实战之SVM
steph_curry的博客
03-21 399
简版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.stri...
机器学习实战（六）——SVM
nadph513的博客
05-21 712
支持向量机 线性分类 分类标准 考虑二分类的问题，数据点用xxx表示，这是一个nnn维向量，类别用yyy来表示，取值为-1或1(与Logistc相同)， 分别代表两个不同的类。一个线性分类器的学习目标就是要在nnn维的数据空间中找到一个分类超平面，其方程为：wTx+b=0wTx+b=0w^Tx+b=0 特别的，对于二维平面，超平面方程为[a&amp;amp;nbsp;b][x1x2]+b=0[a&amp;amp;...
《机器学习实战》6.支持向量机（SVM）
豆豆豆豆芽的博客
10-28 1634
本章涉及到的向SVM有很多种实现方法，但是这里学习最流行的一种，即序列最小化（SMO）算法。在此之后，将介绍如何使用一种称为核函数的方式奖SVM拓展到更多数据集上。
机器学习实战--svm
sunnyxiaohu的博客
03-16 2419
这一节，研究了两天，有些地方，还是不是很明白。这里对于算法原理只做一个简单的纪要，具体可以参考我下面列出的博客，推导的很详细。 参考： 1.http://www.tuicool.com/articles/RRZvYb 2.http://www.cnblogs.com/jerrylead/archive/2011/03/18/1988419.html算法简介： 用一句话来总结其原理：确定一个超
SVM实战
m0_46673154的博客
07-30 387
SVM实战
白话机器学习算法理论+实战之支持向量机（SVM）
Miracle8070
02-12 5095
1. 写在前面 如果想从事数据挖掘和数据分析的工作，掌握常用的机器学习算法是非常有必要的，比如我之前写过的一篇十大机器学习算法的小总结，在这简单的先捋一捋， 常见的机器学习算法： 监督学习算法：逻辑回归，线性回归，决策树，朴素贝叶斯，K近邻，支持向量机，集成算法Adaboost等 无监督算法：聚类，降维，关联规则, PageRank等 为了详细的理解这些，曾经看过西瓜书，统计学习方法，机器学习...
机器学习实战（Machine Learning in Action）
ZHOU_YU0715的博客
06-25 678
第一章 机器学习基础 本书是我个人比较喜欢的风格，之前有学习过一部分基于Scikit-Learn 的机器学习，两本书各有特色，近期开始学习Peter的这个Machine learing in action。希望对自己有一定的帮助。 第一章的机器学习基础，大同小异，可参考之前我所写的学习笔记。机器学习概述 ...
《机器学习实战》
勇敢的俍心的博客
06-19 511
书评： 本书侧重于代码实践，理论推导和公式差一些； 适合快速入门和上手，实例比较好； 豆瓣建议结合CSDN和《统计学习方法》；前言说本书就是以实践为主的。
机器学习实战
xj1363695789的博客
08-09 206
目录 第一部分   分类 第一章   机器学习基础 第二章   k-近邻算法 第三章   决策树 第四章   朴素贝叶斯 第五章   logistic回归 第六章   支持向量机 第七章   利用AdaBoost元算法提高分类性能 第二部分   利用回归预测数值型数据 第八章   预测数据型数据：回归 第九张：树回归 第三部分   无监督学习 第十章   利用K-均值聚类...
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值