Python SVM(支持向量机)实现方法完整示例

本文实例讲述了Python SVM(支持向量机)实现方法。分享给大家供大家参考,具体如下:

运行环境

  • Pyhton3
  • numpy(科学计算包)
  • matplotlib(画图所需,不画图可不必)

计算过程

st=>start: 开始
e=>end: 结束
op1=>operation: 读入数据
op2=>operation: 格式化数据
cond=>condition: 是否达到迭代次数
op3=>operation: 寻找超平面分割最小间隔
ccond=>conditon: 数据是否改变
op4=>operation: 输出结果
st->op1->op2->cond
cond(yes)->op4->e
cond(no)->op3

啊,这markdown flow好难用,我决定就画到这吧=。=

输入样例

/* testSet.txt */
3.542485 1.977398 -1
3.018896 2.556416 -1
7.551510 -1.580030 1
2.114999 -0.004466 -1
8.127113 1.274372 1
7.108772 -0.986906 1
8.610639 2.046708 1
2.326297 0.265213 -1
3.634009 1.730537 -1
0.341367 -0.894998 -1
3.125951 0.293251 -1
2.123252 -0.783563 -1
0.887835 -2.797792 -1
7.139979 -2.329896 1
1.696414 -1.212496 -1
8.117032 0.623493 1
8.497162 -0.266649 1
4.658191 3.507396 -1
8.197181 1.545132 1
1.208047 0.213100 -1
1.928486 -0.321870 -1
2.175808 -0.014527 -1
7.886608 0.461755 1
3.223038 -0.552392 -1
3.628502 2.190585 -1
7.407860 -0.121961 1
7.286357 0.251077 1
2.301095 -0.533988 -1
-0.232542 -0.547690 -1
3.457096 -0.082216 -1
3.023938 -0.057392 -1
8.015003 0.885325 1
8.991748 0.923154 1
7.916831 -1.781735 1
7.616862 -0.217958 1
2.450939 0.744967 -1
7.270337 -2.507834 1
1.749721 -0.961902 -1
1.803111 -0.176349 -1
8.804461 3.044301 1
1.231257 -0.568573 -1
2.074915 1.410550 -1
-0.743036 -1.736103 -1
3.536555 3.964960 -1
8.410143 0.025606 1
7.382988 -0.478764 1
6.960661 -0.245353 1
8.234460 0.701868 1
8.168618 -0.903835 1
1.534187 -0.622492 -1
9.229518 2.066088 1
7.886242 0.191813 1
2.893743 -1.643468 -1
1.870457 -1.040420 -1
5.286862 -2.358286 1
6.080573 0.418886 1
2.544314 1.714165 -1
6.016004 -3.753712 1
0.926310 -0.564359 -1
0.870296 -0.109952 -1
2.369345 1.375695 -1
1.363782 -0.254082 -1
7.279460 -0.189572 1
1.896005 0.515080 -1
8.102154 -0.603875 1
2.529893 0.662657 -1
1.963874 -0.365233 -1
8.132048 0.785914 1
8.245938 0.372366 1
6.543888 0.433164 1
-0.236713 -5.766721 -1
8.112593 0.295839 1
9.803425 1.495167 1
1.497407 -0.552916 -1
1.336267 -1.632889 -1
9.205805 -0.586480 1
1.966279 -1.840439 -1
8.398012 1.584918 1
7.239953 -1.764292 1
7.556201 0.241185 1
9.015509 0.345019 1
8.266085 -0.230977 1
8.545620 2.788799 1
9.295969 1.346332 1
2.404234 0.570278 -1
2.037772 0.021919 -1
1.727631 -0.453143 -1
1.979395 -0.050773 -1
8.092288 -1.372433 1
1.667645 0.239204 -1
9.854303 1.365116 1
7.921057 -1.327587 1
8.500757 1.492372 1
1.339746 -0.291183 -1
3.107511 0.758367 -1
2.609525 0.902979 -1
3.263585 1.367898 -1
2.912122 -0.202359 -1
1.731786 0.589096 -1
2.387003 1.573131 -1

代码实现

# -*- coding:utf-8 -*-
#!python3
__author__ = 'Wsine'
from numpy import *
import matplotlib.pyplot as plt
import operator
import time
def loadDataSet(fileName):
  dataMat = []
  labelMat = []
  with open(fileName) as fr:
    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
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 updateEk(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.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("j not moving enough")
      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 - Ei - 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, kTup=('lin', 0)):
  """
  输入:数据集, 类别标签, 常数C, 容错率, 最大循环次数
  输出:目标b, 参数alphas
  """
  oS = optStruct(mat(dataMatIn), mat(classLabels).transpose(), C, toler)
  iterr = 0
  entireSet = True
  alphaPairsChanged = 0
  while (iterr < 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" % (iterr, i, alphaPairsChanged))
      iterr += 1
    else:
      nonBoundIs = nonzero((oS.alphas.A > 0) * (oS.alphas.A < C))[0]
      for i in nonBoundIs:
        alphaPairsChanged += innerL(i, oS)
        # print("non-bound, iter: %d i:%d, pairs changed %d" % (iterr, i, alphaPairsChanged))
      iterr += 1
    if entireSet:
      entireSet = False
    elif (alphaPairsChanged == 0):
      entireSet = True
    # print("iteration number: %d" % iterr)
  return oS.b, oS.alphas
def calcWs(alphas, dataArr, classLabels):
  """
  输入:alphas, 数据集, 类别标签
  输出:目标w
  """
  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 plotFeature(dataMat, labelMat, weights, b):
  dataArr = array(dataMat)
  n = shape(dataArr)[0]
  xcord1 = []; ycord1 = []
  xcord2 = []; ycord2 = []
  for i in range(n):
    if int(labelMat[i]) == 1:
      xcord1.append(dataArr[i, 0])
      ycord1.append(dataArr[i, 1])
    else:
      xcord2.append(dataArr[i, 0])
      ycord2.append(dataArr[i, 1])
  fig = plt.figure()
  ax = fig.add_subplot(111)
  ax.scatter(xcord1, ycord1, s=30, c='red', marker='s')
  ax.scatter(xcord2, ycord2, s=30, c='green')
  x = arange(2, 7.0, 0.1)
  y = (-b[0, 0] * x) - 10 / linalg.norm(weights)
  ax.plot(x, y)
  plt.xlabel('X1'); plt.ylabel('X2')
  plt.show()
def main():
  trainDataSet, trainLabel = loadDataSet('testSet.txt')
  b, alphas = smoP(trainDataSet, trainLabel, 0.6, 0.0001, 40)
  ws = calcWs(alphas, trainDataSet, trainLabel)
  print("ws = \n", ws)
  print("b = \n", b)
  plotFeature(trainDataSet, trainLabel, ws, b)
if __name__ == '__main__':
  start = time.clock()
  main()
  end = time.clock()
  print('finish all in %s' % str(end - start))

输出样例

ws =
 [[ 0.65307162]
 [-0.17196128]]
b =
 [[-2.89901748]]
finish all in 2.5683854014099112

绘图方面还存在一些bug。

更多关于Python相关内容感兴趣的读者可查看本站专题:《Python数学运算技巧总结》、《Python数据结构与算法教程》、《Python函数使用技巧总结》、《Python字符串操作技巧汇总》、《Python入门与进阶经典教程》及《Python文件与目录操作技巧汇总》

希望本文所述对大家Python程序设计有所帮助。

(0)

相关推荐

  • Python中的支持向量机SVM的使用(附实例代码)

    除了在Matlab中使用PRTools工具箱中的svm算法,Python中一样可以使用支持向量机做分类.因为Python中的sklearn库也集成了SVM算法,本文的运行环境是Pycharm. 一.导入sklearn算法包 Scikit-Learn库已经实现了所有基本机器学习的算法,具体使用详见官方文档说明:http://scikit-learn.org/stable/auto_examples/index.html. skleran中集成了许多算法,其导入包的方式如下所示, 逻辑回归:from

  • Python机器学习之SVM支持向量机

    SVM支持向量机是建立于统计学习理论上的一种分类算法,适合与处理具备高维特征的数据集. SVM算法的数学原理相对比较复杂,好在由于SVM算法的研究与应用如此火爆,CSDN博客里也有大量的好文章对此进行分析,下面给出几个本人认为讲解的相当不错的: 支持向量机通俗导论(理解SVM的3层境界) JULY大牛讲的是如此详细,由浅入深层层推进,以至于关于SVM的原理,我一个字都不想写了..强烈推荐. 还有一个比较通俗的简单版本的:手把手教你实现SVM算法 SVN原理比较复杂,但是思想很简单,一句话概括,就

  • Python中支持向量机SVM的使用方法详解

    除了在Matlab中使用PRTools工具箱中的svm算法,Python中一样可以使用支持向量机做分类.因为Python中的sklearn库也集成了SVM算法,本文的运行环境是Pycharm. 一.导入sklearn算法包 Scikit-Learn库已经实现了所有基本机器学习的算法,具体使用详见官方文档说明 skleran中集成了许多算法,其导入包的方式如下所示, 逻辑回归:from sklearn.linear_model import LogisticRegression 朴素贝叶斯:fro

  • Python中使用支持向量机(SVM)算法

    在机器学习领域,支持向量机SVM(Support Vector Machine)是一个有监督的学习模型,通常用来进行模式识别.分类(异常值检测)以及回归分析. 其具有以下特征: (1)SVM可以表示为凸优化问题,因此可以利用已知的有效算法发现目标函数的全局最小值.而其他分类方法都采用一种基于贪心学习的策略来搜索假设空间,这种方法一般只能获得局部最优解.   (2) SVM通过最大化决策边界的边缘来实现控制模型的能力.尽管如此,用户必须提供其他参数,如使用核函数类型和引入松弛变量等.   (3)S

  • Python中使用支持向量机SVM实践

    在机器学习领域,支持向量机SVM(Support Vector Machine)是一个有监督的学习模型,通常用来进行模式识别.分类(异常值检测)以及回归分析. 其具有以下特征: (1)SVM可以表示为凸优化问题,因此可以利用已知的有效算法发现目标函数的全局最小值.而其他分类方法都采用一种基于贪心学习的策略来搜索假设空间,这种方法一般只能获得局部最优解. (2) SVM通过最大化决策边界的边缘来实现控制模型的能力.尽管如此,用户必须提供其他参数,如使用核函数类型和引入松弛变量等. (3)SVM一般

  • Python SVM(支持向量机)实现方法完整示例

    本文实例讲述了Python SVM(支持向量机)实现方法.分享给大家供大家参考,具体如下: 运行环境 Pyhton3 numpy(科学计算包) matplotlib(画图所需,不画图可不必) 计算过程 st=>start: 开始 e=>end: 结束 op1=>operation: 读入数据 op2=>operation: 格式化数据 cond=>condition: 是否达到迭代次数 op3=>operation: 寻找超平面分割最小间隔 ccond=>cond

  • Python生成器的使用方法和示例代码

    本文是<Effect Python 编写高质量Python代码的59个有效方法>的学习笔记.主要记录生成器的使用方法和示例代码. 返回队列的函数 如果函数要产生一系列结果,那么最简单的做法就是把这些结构都放在一份列表里,然后将其返回给调用者. def index_words(text): """用append方法将这些此的首字母索引添加到result列表中,并在函数结束时将其返回给调用者.""" result = [] if text

  • JS图片等比例缩放方法完整示例

    本文实例讲述了JS图片等比例缩放方法.分享给大家供大家参考,具体如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <head>

  • JS动态图片的实现方法完整示例

    本文实例讲述了JS动态图片的实现方法.分享给大家供大家参考,具体如下: <html> <head> <meta charset="UTF-8"> <title>js-是动态实现图片显示</title> <script type="text/javascript"> // 设置图片的动态效果 function photoOper(ph,photo){ // 获取图片对象 // var ph=doc

  • Jquery滑动门/tab切换实现方法完整示例

    本文实例讲述了Jquery滑动门/tab切换实现方法.分享给大家供大家参考,具体如下: <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml"> <

  • Python调用shell cmd方法代码示例解析

    1.使用os.system()去调用,但是只能返回执行状态,不能获取shell cmd执行结果 #!/usr/bin/python # -*- coding: utf-8 import os status = os.system("ps aux |grep Xcode |grep -v grep") print status 2.使用os.popen执行并获取结果 ​ 如果返回是str,直接通过read拿结果使用,如果是多行,选择readlines转list获取每行内容 #整份字符串处

  • Python面向对象编程repr方法示例详解

    目录 为什么要讲 __repr__ 重写 __repr__ 方法 str() 和 repr() 的区别 为什么要讲 __repr__ 在 Python 中,直接 print 一个实例对象,默认是输出这个对象由哪个类创建的对象,以及在内存中的地址(十六进制表示) 假设在开发调试过程中,希望使用 print 实例对象时,输出自定义内容,就可以用 __repr__ 方法了 或者通过 repr() 调用对象也会返回 __repr__ 方法返回的值 是不是似曾相识....没错..和 __str__ 一样的

  • Python创建对称矩阵的方法示例【基于numpy模块】

    本文实例讲述了Python创建对称矩阵的方法.分享给大家供大家参考,具体如下: 对称(实对称)矩阵也即: step 1:创建一个方阵 >>> import numpy as np >>> X = np.random.rand(5**2).reshape(5, 5) >>> X array([[ 0.26984148, 0.25408384, 0.12428487, 0.0194565 , 0.91287708], [ 0.31837673, 0.354

  • Python连接phoenix的方法示例

    本文实例讲述了Python连接phoenix的方法.分享给大家供大家参考,具体如下: phoenix是由saleforce.com开源的一个项目,后又捐给了Apache.它相当于一个Java中间件,帮助开发者,像使用jdbc访问关系型数据库一些,访问NoSql数据库HBase.可以把Phoenix只看成一种代替HBase的语法的一个工具.虽然可以用java可以用jdbc来连接phoenix,然后操作HBase,但是在生产环境中,不可以用在OLTP中. Phoenix官网:http://phoen

随机推荐