Machine Learning 之 SVM实现（个人认为最好的算法）

最新推荐文章于 2024-06-11 14:34:13 发布
最新推荐文章于 2024-06-11 14:34:13 发布
阅读量1.6w 收藏 51
点赞数 2
分类专栏： 数值分析 Python，算法 机器学习 文章标签： 统计学 算法 numpy
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_33829806/article/details/78388025
版权

SVM.py

#coding=utf-8
"""
      主要思想及算法流程来自李航的《统计学习方法》
      《理解SVM的三重境界》
      yi={1,-1}
      难点：
      KKT条件
      SMO算法
"""
import time
import random
import numpy as np
import math
import copy
a=np.matrix([[1.2,3.1,3.1]])
#print a.astype(int)
#print a.A

class SVM:
      def __init__(self,data,kernel,maxIter,C,epsilon):
            self.trainData=data
            self.C=C  #惩罚因子
            self.kernel=kernel
            self.maxIter=maxIter
            self.epsilon=epsilon
            self.a=[0 for i in range(len(self.trainData))]
            self.w=[0 for i in range(len(self.trainData[0][0]))]
            self.eCache=[[0,0] for i in range(len(self.trainData))]
            self.b=0
            self.xL=[self.trainData[i][0] for i in range(len(self.trainData))]
            self.yL=[self.trainData[i][1] for i in range(len(self.trainData))]

      def train(self):
            #support_Vector=self.__SMO()
            self.__SMO()
            self.__update()

      def __kernel(self,A,B):
            #核函数 是对输入的向量进行变形 从低维映射到高维度
            res=0
            if self.kernel=='Line':
                  res=self.__Tdot(A,B)
            elif self.kernel[0]=='Gauss':
                  K=0
                  for m in range(len(A)):
                       K+=(A[m]-B[m])**2 
                  res=math.exp(-0.5*K/(self.kernel[1]**2))
            return res


      def __Tdot(self,A,B):
            res=0
            for k in range(len(A)):
                  res+=A[k]*B[k]
            return res


      def __SMO(self):
            #SMO是基于 KKT 条件的迭代求解最优化问题算法
            #SMO是SVM的核心算法
            support_Vector=[]
            self.a=[0 for i in range(len(self.trainData))]
            pre_a=copy.deepcopy(self.a)
            for it in range(self.maxIter):
                  flag=1
                  for i in range(len(self.xL)):
                        #print self.a
                        #更新 self.a  使用 机器学习实战的求解思路
                        #计算 j更新
                        diff=0
                        self.__update()
                        #选择有最大误差的j 丹麦理工大学的算法是 对j在数据集上循环, 随机选取i 显然效率不是很高
                        #机器学习实战 硬币书表述正常 代码混乱且有错误 启发式搜索
                        Ei=self.__calE(self.xL[i],self.yL[i])
                        j,Ej=self.__chooseJ(i,Ei)
                        #计算 L H
                        (L,H)=self.__calLH(pre_a,j,i)
                        #思路是先表示为self.a[j] 的唯一变量的函数 再进行求导（一阶导数=0 更新）
                        kij=self.__kernel(self.xL[i],self.xL[i])+self.__kernel(self.xL[j],self.xL[j])-2*self.__kernel(self.xL[i],self.xL[j])
                        #print kij,"aa"
                        if(kij==0):
                              continue
                        self.a[j] = pre_a[j] + float(1.0*self.yL[j]*(Ei-Ej))/kij
                        #下届是L 也就是截距,小于0时为0
                        #上届是H 也就是最大值,大于H时为H
                        self.a[j] = min(self.a[j], H)
                        self.a[j] = max(self.a[j], L)
                        #self.a[j] = min(self.a[j], H)
                        #print L,H
                        self.eCache[j]=[1,self.__calE(self.xL[j],self.yL[j])]
                        self.a[i] = pre_a[i]+self.yL[i]*self.yL[j]*(pre_a[j]-self.a[j])
                        self.eCache[i]=[1,self.__calE(self.xL[i],self.yL[i])]
                        diff=sum([abs(pre_a[m]-self.a[m]) for m in range(len(self.a))])
                        #print diff,pre_a,self.a
                        if diff < self.epsilon:
                              flag=0
                        pre_a=copy.deepcopy(self.a)
                  if flag==0:
                        print it,"break"
                        break

            #return support_Vector

      def __chooseJ(self,i,Ei):
            self.eCache[i]=[1,Ei]
            chooseList=[]
            #print self.eCache
            #从误差缓存中得到备选的j的列表 chooseList  误差缓存的作用：解决初始选择问题
            for p in range(len(self.eCache)):
                  if self.eCache[p][0]!=0 and p!=i:
                        chooseList.append(p)
            if len(chooseList)>1:
                  delta_E=0
                  maxE=0
                  j=0
                  Ej=0
                  for k in chooseList:
                        Ek=self.__calE(self.xL[k],self.yL[k])
                        delta_E=abs(Ek-Ei)
                        if delta_E>maxE:
                              maxE=delta_E
                              j=k
                              Ej=Ek
                  return j,Ej
            else:
                  #最初始状态
                  j=self.__randJ(i)
                  Ej=self.__calE(self.xL[j],self.yL[j])
                  return j,Ej

      def __randJ(self,i):
            j=i
            while(j==i):
                  j=random.randint(0,len(self.xL)-1)
            return j

      def __calLH(self,pre_a,j,i):
            if(self.yL[j]!= self.yL[i]):
                  return (max(0,pre_a[j]-pre_a[i]),min(self.C,self.C-pre_a[i]+pre_a[j]))
            else:
                  return (max(0,-self.C+pre_a[i]+pre_a[j]),min(self.C,pre_a[i]+pre_a[j]))

      def __calE(self,x,y):
            #print x,y
            y_,q=self.predict(x)
            return y_-y

      def __calW(self):
            self.w=[0 for i in range(len(self.trainData[0][0]))]
            for i in range(len(self.trainData)):
                  for j in range(len(self.w)):
                        self.w[j]+=self.a[i]*self.yL[i]*self.xL[i][j]

      def __update(self):
            #更新 self.b 和 self.w
            self.__calW()
            #得到了self.w 下面求b
            #print self.a
            maxf1=-99999
            min1=99999
            for k in range(len(self.trainData)):
                  y_v=self.__Tdot(self.w,self.xL[k])
                  #print y_v
                  if self.yL[k]==-1:
                        if y_v>maxf1:
                              maxf1=y_v
                  else:
                        if y_v<min1:
                              min1=y_v
            self.b=-0.5*(maxf1+min1)

      def predict(self,testData):
            pre_value=0
            #从trainData 改成 suport_Vector
            for i in range(len(self.trainData)):
                  pre_value+=self.a[i]*self.yL[i]*self.__kernel(self.xL[i],testData)
            pre_value+=self.b
            #print pre_value,"pre_value"
            if pre_value<0:
                  y=-1
            else:
                  y=1
            return y,abs(pre_value-0)

      def save(self):
            pass




def LoadSVM():
      pass


#coding=utf-8
from SVM import *

data=[
        [[1,1],1],
        [[2,1],1],
        [[1,0],1],
        [[3,7],-1],
        [[4,8],-1],
        [[4,10],-1],
      ]

testSVM.py


#如果为gauss核的话  ['Gauss',标准差]
svm=SVM(data,'Line',1000,0.02,0.001)
svm.train()
print svm.predict([4,0])
print svm.a
print svm.w
print svm.b
BUAA-XX
关注
  • 2
    点赞
  • 踩
  • 51
    收藏
    觉得还不错? 一键收藏
  • 5
    评论
专栏目录
SVM实现多分类的三种方案
weixin_33705053的博客
03-11 4429
SVM本身是一个二值分类器 　　SVM算法最初是为二值分类问题设计的，当处理多类问题时，就需要构造合适的多类分类器。 　　目前，构造SVM多类分类器的方法主要有两类 　　（1）直接法，直接在目标函数上进行修改，将多个分类面的参数求解合并到一个最优化问题中，通过求解该最优化问题“一次性”实现多类分类。这种方法看似简单，但其计算复杂度比较高，实现起来比较困难，只适合用于小型问题中； 　　（2）...
SVM算法的介绍
Despicable_Me的博客
06-03 7806
SVM（Support Vector Machine）是一种常见的监督学习算法，用于进行二分类或多分类任务。它的主要思想是找到一个最优的超平面，将不同类别的样本分隔开。超平面最大间隔介绍：上左图显示了三种可能的线性分类器的决策边界：虚线所代表的模型表现非常糟糕，甚至都无法正确实现分类。其余两个模型在这个训练集上表现堪称完美。但是它们的决策边界与实例过于接近，导致在面对新实例时，表现可能不会太好。右图中的实线代表SM分类器的决策边界，不仅分离了两个类别，且尽可能远离最近的训练实例。
【机器学习】十大算法之一 “SVM”
Code_and516的博客
06-16 3966
支持向量机（Support Vector Machine，SVM）是机器学习十大算法之一，是一种二分类模型。SVM将实例空间映射到一个高维空间，将空间进行线性划分，同时使得分类面到两端最近的数据点的距离（margin）最大化，因此SVM也被称为最大间隔分类器（Maximal Margin Classifier）。SVM是由Vapnik和Cortes于1995年提出的，是一种广泛应用的机器学习算法，具有很好的泛化能力和鲁棒性。SVM是一种非常有用的算法，它在分类和回归问题中都表现出色。
机器学习——支持向量机（SVM）
智能2212-45-杨豪
06-11 1209
支持向量机（Support Vector Machine，SVM）是一种基于统计学习理论的机器学习算法，它是由Vapnik和Cortes于1995年提出的。SVM是一种二类分类模型，它的基本模型定义为特征空间上的间隔最大的线性分类器，其学习策略就是间隔最大化，同时它还能够应用于回归问题（SVR，Support Vector Regression）。支持向量机（SVM）是一种强大的机器学习算法，广泛应用于分类和回归任务。它的核心思想是在特征空间中找到一个最优的超平面，使得不同类别的数据点能够被最佳地分隔。
SVM介绍以及实战
艰难困苦，玉汝于成。
08-01 2073
在龙岗的时候就在想着什么时候学习SVM了，回想起来好像已经过了很久很久了！SVM介绍SVM，全称是supportvertormachine，直译过来是支持向量机，属于监督学习算法。原理支持向量机是一个线性分类器，其定义在于找到一个界限，使得两边的样本都离这个界限足够远。这个界限被称之为超平面。超平面一般是直线或者是平面。在SVM中，样本点距离直线的距离，代表着样本分类的可信程度。最好的情况对于SVM来说，最好的分类情况是，超平面对每个类别最近的元素距离最远。优点劣势https。...
SVM.rar_CSharp SVM _SVM CSharp_machine learning_svm函
09-20
这些库提供了API，便于在C#项目中集成SVM算法。LibSVM是由台湾大学开发的一个流行的支持向量机库，它支持多种核函数，包括线性、多项式、径向基函数（RBF）等。而SharpSVM是专为.NET Framework设计的SVM库，同样支持...
svm.zip_SVM_machine learning
09-14
总的来说，SVM是一种强大的机器学习算法，结合MATLAB提供的工具，可以在多种场景下实现高效且准确的学习任务。通过深入理解和熟练应用SVM，我们可以解决复杂的数据分析问题，实现有效的预测和决策。
svm.zip_SVM_machine learning_zip
09-21
在"svm.zip_SVM_machine learning_zip"这个压缩包中，可能包含了一个关于SVM的实例，`p6.py`可能是Python代码，用于实现SVM算法或者展示SVM的工作原理。而`result_p6.png`很可能是运行结果的可视化图像，展示了SVM...
01_SpeechDetection.rar_machine learning_svm；机器学习_yellow8em
07-15
"machine learning_svm"和"yellow8em"是关键词，前者指明了主题领域，后者可能是项目作者或者特定的标识。 在描述中提到，这个项目是在MATLAB平台上实现的，说明我们将探讨的是基于MATLAB的语音检测算法。"简单易懂...
face_SVM_machinelearning_
09-29
标题中的"face_SVM_machinelearning_"表明我们讨论的主题是关于人脸识别技术，具体是利用支持向量机（SVM，Support Vector Machine）这一机器学习算法进行的。在这个领域，SVM通常用于特征分类和识别，特别是在...
svm原理，最最详细的介绍
04-11
svm基本原理，python代码实现，拉格朗日与KKT算法描述
JSAT：Java统计分析工具，一个用于机器学习的Java库
02-03
Java统计分析工具 JSAT是一个用于快速入门机器学习问题的库。 它是在我的业余时间开发的，可根据GPL 3使用。该库的一部分用于自学，因此-所有代码都包含在其中。 JSAT没有外部依赖关系，并且是纯Java。 我的目标还在于使该库适合中小型问题。 因此，许多代码都支持并行执行。 当JSAT迁移到Java 8时，当前的JSAT主分支正在经历更大的重构。这可能会导致某些示例（如果将其用于头版本）会中断，但是它们应该可以通过最小的更改进行修复。 获取JSAT 当前的JSAT版本是0.0.9版，并支持Java6。当前的master分支现在是Java 8+。 您可以从Maven Centra
机器学习之支持向量机SVM及代码示例
cxmscb的博客
02-22 5万+
一、线性可分SVMSVM算法最初是用来处理二分类问题的，是一种有监督学习的分类算法。对于线性可分的二分类问题，我们可以找到无穷多个超平面，将两类样本进行区分。(超平面：一维中是一个点；二维中是一条线；三维中是一个面……)在上面的多个超平面中，它们都可以成功将样本集划分两边，但哪一个超平面更好？一般来说，当样本点离超平面越近，样本的标签为某类型的概率应该为0.5左右，确信度比较低，而样本点离超平面越远
svm详细过程
CSDN_LYY的专栏
09-19 1634
转载地址 https://blog.csdn.net/u013019431/article/details/79952483
手写数字识别（二）----SVM 实现Mnist-image 手写数字图像识别
奔跑在路上的专栏
11-07 5万+
前言前两天利用kNN实现了手写数字的识别，数据不是很多，训练数据1934个，测试数据946个。这两天把Mnist-image的手写数字数据down了下来，利用SVM进行识别一下。Mnist-image的手写数字数据有7万的图像数据（6万训练数据+1万测试数据），每个图像数据为 20px * 20px。
SVM的matlab代码及SVM的多分类的作法
热门推荐
fengsigaoju的博客
08-25 5万+
SVM是常用的一种有监督的学习模型（即给你一些输入特征，告诉你这些特征的样本是属于A类，再给你一些输入特征，告诉你这些特征的样本是属于B类，现在再来一些数据，来判断它们是属于哪一类）。 它与Kmeans的区别在于kmenas是无监督的学习模型，即kmeans不需要提前知道（训练），只要你把特征给我，我根据特征分就完事了. 它与Knn的区别在于knn来一个就算一次(和集合内的其余点进行比较)，而
SVM算法流程图
u012413709的博客
06-01 6371
https://blog.csdn.net/u010484388/article/details/54317921?utm_medium=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase&depth_1-utm_source=distribute.pc_relevant.none-task-blog-BlogCommendFromMachineLearnPai2-1.nonecase
机器学习实战之使用 scikit-learn 库实现 svm
CongliYin的博客
04-04 4228
有关 svm 的理论知识，在博客支持向量机（SVM）入门理解与推导中已有详细介绍，svm的特性： 训练好的模型的算法复杂度由支持向量的个数决定，而不是由数据的维度决定，所以 svm 算法不太容易产生 overfitting； svm 训练出来的模型完全依赖于支持向量，即使训练集中所有的非支持向量都被去除，重复训练过程，结果仍然是一样的模型； 一个 svm 如果训练得出的支持向量比较少，那么模...
scala实现svm算法
最新发布
06-13
Scala 是一种功能强大的静态类型、面向对象和函数式编程语言，它非常适合在 Scala 中实现支持向量机（Support Vector Machine, SVM）算法。SVM 是一种常用的监督学习算法，尤其在分类和回归问题中表现出色，因为它能够找到最优超平面进行决策。 在 Scala 中实现 SVM，你可以使用开源库如 Smile（Scalable Machine Learning Library）或 Breeze（专为 Scala 设计的数值计算库），它们提供了现成的 SVM 实现和相关的工具。 以下是一个简单的步骤概述： 1. **引入库**：如果你还没安装，首先需要添加对应库到你的项目依赖中，例如在 SBT (Scala Build Tool) 项目中添加 Smile 或者 Breeze。 ```scala libraryDependencies += "com.github.haifengl" %% "smile-core" % "2.6.0" ``` 2. **数据预处理**：将数据集转换成适合 SVM 输入的格式，通常包括特征向量和对应的标签。 3. **模型创建**：使用 Smile 或 Breeze 的 SVM 类，如 `LinearSVC` 或 `SMO` 来创建模型。 ```scala import smile.classification._ import breeze.linalg.DenseVector val svm = LinearSVC() ``` 4. **训练模型**：使用数据集对模型进行训练。 ```scala val data = ... // 从文件或数据库读取的数据 val (inputs, labels) = data.map { case features, label => DenseVector(features), label }.unzip svm.train(inputs, labels) ``` 5. **预测和评估**：对新的数据点进行预测，并使用交叉验证等方法评估模型性能。 ```scala val testData = ... // 预测用的数据 val predictions = svm.predict(testData) ```

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值