计算机视觉
图像处理

机器学习(十四)Libsvm学习笔记

Libsvm软件包是台湾大学林智仁(Chih-Jen Lin)博士等用C++实现的LIBSVM库,可以说是使用最方便的SVM训练工具。可以解决分类问题(包括C-SVC、n-SVC)、回归问题(包括e-SVR、n-SVR)以及分布估计(one-class-SVM )等问题,提供了线性、多项式、径向基和S形函数四种常用的核函数供选择,可以有效地解决多类问题、交叉验证选择参数、对不平衡样本加权、多类问题的概率估计等。
但是,在Windows环境下,此软件包只提供DOS工具集(主要包括:训练工具svmtrain.exe,预测工具svmpredict.exe,缩放数据工具svmscale.exe和二维演示工具svmtoy.exe),不过它的源码是开放的,因此我们可以直接调用源码。首先从网上下载libsvm工具包:

然后解压,

把svm.cpp和svm.h复制出来,因为对于我们做开发的,只需要这两个文件就可以了,然后把这两个文件放到vs的项目文件下,然后进行调用。

本篇博文主要讲,如何调用使用libsvm,我主要是通过两个简单的例子,演示如何调用libsvm。因为有了例子,学起来非常容易。

一、二分类测试案例

svm算法是学习训练算法,因此调用的步骤是:

1、数据归一化,数据归一化这一步libsvm好像没有提供函数,所以这一步要自己手动写一些代码,如果没有进行归一化,有的时候会出现问题。

2、数据训练

训练调用函数:

  1. struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);

只要学会这个函数的调用就可以实现训练了。

这个函数包含两个输入参数,第一个参数prob用于输入训练数据,包括输入特征X,训练数据标签y,训练样本的个数,具体svm_problem结构体的定义如下:

  1. struct svm_problem
  2. {
  3.     int l;//训练数据的个数
  4.     double *y;//训练数据的标签,y[i]表示第i个样本的标签
  5.     struct svm_node **x;//训练数据的特征,x[i][j]表示第i个样本的第j个特征值
  6. };

第二个参数,定义了svm算法的相关初始化参数,比如惩罚因子、核函数等,具体的结构体定义如下:

  1. struct svm_parameter
  2. {
  3.     int svm_type;//svm的类型,包括分类、预测拟合等,如果想用svm进行分类那么可以选择C_SVC,如果想用于拟合预测那么可以选择EPSILON_SVR
  4.     int kernel_type;//核函数类型,包括线性核函数、高斯核函数、S激活函数、多项式
  5.     int degree; /* for poly */
  6.     double gamma;   /* for poly/rbf/sigmoid */
  7.     double coef0;   /* for poly/sigmoid */
  8.     /* these are for training only */
  9.     double cache_size; /* in MB */
  10.     double eps; /* stopping criteria *///迭代误差终止条件
  11.     double C;   /* for C_SVC, EPSILON_SVR and NU_SVR *///惩罚因子
  12.     int nr_weight;      /* for C_SVC */
  13.     int *weight_label;  /* for C_SVC */
  14.     double* weight;     /* for C_SVC */
  15.     double nu;  /* for NU_SVC, ONE_CLASS, and NU_SVR */
  16.     double p;   /* for EPSILON_SVR */
  17.     int shrinking;  /* use the shrinking heuristics */
  18.     int probability; /* do probability estimates */
  19. };

具体每个参数的含义,在svm.h文件的定义中,都用相关的注释。

因此进行训练的时候,需要对这两个结构体的相关参数非常清晰。

在上面输入训练数据后,我们一般是先调用下面这个函数:

  1. const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);

这个函数可以进行检验你输入的参数pro,para的格式是否正确,调用完后,才调用svm_train()函数,这样可以确保输入的数据和svm的参数设置没有错后在进行训练。

3、数据预测分类

通过调用svm_train()函数完成训练过程,将返回参数svm_model模型。接着如果要进行预测分类可以调用如下函数:

  1. double svm_predict(const struct svm_model *model, const struct svm_node *x);

这个函数的第一个输入参数就是我们通过训练过程得到的svm_model,第二个参数就是*x就是输入特征,如x[i]表示第i维特征的数值。数据的返回值,如果你是二分类模型,那么将返回数据标签:-1.0,1.0。如果你是用于预测拟合,那么将返回预测到的数值。

开始写代码前,我觉得svm_node的格式需要说明一下:

  1. struct svm_node //储存单一向量的单个特征
  2. {
  3.     int index; //索引
  4.     double value; //值
  5. };

svm_node是定义特征向量的标准输入格式。假设有三维的特征向量X=(10,1,3),那么就需要使用语句:new svm_node*x=new svm_node[4],来定义一个特征向量,然后特征就可以使用3个svm_node来保存:

index    1       2       3   -1
value   10       1       3 NULL

最后一个svm_node是结束的标志,其索引值为-1,数值随便。libsvm就是通过判断其索引是否为-1,来判别特征向量结束的。

OK,接着就用例子作为演示示例,下面是一个二分类的例子,通过输入一个人的身高和体重特征,判别其男性还是女性。下面的例子没有经过归一化,所以其实是不规范的,libsvm并没有进行内部归一化,要自己进行外部归一化好后,在调用libsvm,因为我选用了核函数为线性核函数,有没有归一化好像没啥影响,然而如果选择其他的核函数,那就会发现没有归一化会出现的问题了。

下面我先通过win32控制台,进行测试的一个例子:

  1. #include “stdafx.h”
  2. #include “svm/svm.h”
  3. #include <iostream>
  4. svm_parameter Initialize_svm_parameter()
  5. {
  6.     svm_parameter svmpara;//svm的相关参数
  7.     svmpara.svm_type = C_SVC;
  8.     svmpara.kernel_type = LINEAR;
  9.     svmpara.degree = 3;
  10.     svmpara.gamma = 0;  // 默认大小可选择特征的倒数 1/num_features,核函数中的gamma函数设置(只针对多项式/rbf/sigmoid核函数)
  11.     svmpara.coef0 = 0;
  12.     svmpara.nu = 0.5;
  13.     svmpara.cache_size = 1;//缓存块大小
  14.     svmpara.C = 1;
  15.     svmpara.eps = 1e-3;
  16.     svmpara.p = 0.1;
  17.     svmpara.shrinking = 1;
  18.     svmpara.probability = 0;
  19.     svmpara.nr_weight = 0;
  20.     svmpara.weight_label = NULL;
  21.     svmpara.weight = NULL;
  22.     return svmpara;
  23. }
  24. //二分类测试
  25. //下面是通过人体身高和体重,进行性别的判别
  26. int _tmain(int argc, _TCHAR* argv[])
  27. {
  28.     /*训练样本选取是学生的身高和体重:
  29.         男1:身高:190cm,体重:70kg;
  30.         男2:身高:180cm,体重:80kg;
  31.         女1:身高:161cm,体重:80kg;
  32.         女2:身高:161cm,体重:47kg;*/
  33.     int sample_num=4;//训练样本个数为4
  34.     int feature_dimn=2;//样本的特征维数为2
  35.     double *y=new double[sample_num];
  36.     double **x=new double *[sample_num];
  37.     for (int i=0;i<sample_num;i++)
  38.     {
  39.         x[i]=new double[feature_dimn];
  40.     }
  41.     x[0][0]=190;x[0][1]=70;y[0]=-1;//训练样本1
  42.     x[1][0]=180;x[1][1]=80;y[1]=-1;//训练样本2
  43.     x[2][0]=161;x[2][1]=80;y[2]=1;//训练样本3
  44.     x[3][0]=161;x[3][1]=47;y[3]=1;//训练样本4
  45. //训练数据输入
  46.     svm_parameter svmpara=Initialize_svm_parameter();//svm参数初始化
  47.     svm_problem svmpro;//svm训练数据
  48.     svmpro.l=sample_num;
  49.     svmpro.y=y;//训练数据标签
  50.     svmpro.x=new svm_node *[sample_num];//训练数据的特征向量
  51.     for (int i=0;i<sample_num;i++)
  52.     {
  53.         svmpro.x[i]=new svm_node[feature_dimn+1];
  54.         for (int j=0;j<feature_dimn;j++)
  55.         {
  56.             svm_node node_ij;
  57.             node_ij.index=j+1;//需要注意的是svm_node的第一个数据的索引为1,数值为第一位特征值,我一开始这里搞错了,把索引搞成从0开始
  58.             node_ij.value=x[i][j];
  59.             svmpro.x[i][j]=node_ij;
  60.         }
  61.         svm_node node_last;//需要添加最后一维特征的索引为-1
  62.         node_last.index=-1;
  63.         svmpro.x[i][feature_dimn]=node_last;
  64.     }
  65. //验证输入的训练数据、初始化的参数是否有误
  66.     const char *error_msg;
  67.     error_msg = svm_check_parameter(&svmpro,&svmpara);
  68.     if(error_msg)
  69.     {
  70.         std::cout<<error_msg;
  71.         return 0;
  72.     }
  73. //数据训练
  74.     svm_model *svmmodel=svm_train(&svmpro,&svmpara);
  75. /*预测数据1:身高180cm,体重85kg;
  76. 预测数据2:身高161cm,体重50kg;*/
  77.     svm_node *testX1=new svm_node[feature_dimn+1];
  78.     testX1[0].index=1;
  79.     testX1[0].value=180;
  80.     testX1[1].index=2;
  81.     testX1[1].value=85;
  82.     testX1[2].index=-1;
  83.     double testY1=svm_predict(svmmodel,testX1);
  84.     std::cout<<“测试预测1:”<<testY1<<std::endl;
  85.     svm_node *testX2=new svm_node[feature_dimn+1];
  86.     testX2[0].index=1;
  87.     testX2[0].value=161;
  88.     testX2[1].index=2;
  89.     testX2[1].value=50;
  90.     testX2[2].index=-1;
  91.     double testY2=svm_predict(svmmodel,testX2);//分类预测函数
  92.     std::cout<<“测试预测2:”<<testY2<<std::endl;
  93.     return 0;
  94. }

 

最后的运行正确结果:


二、数据预测拟合案例

接着这个例子是要演示,使用libsvm进行如下图所示的数据拟合,通过数据输入二维的数据点,然后拟合出曲线,也就是相当于输入特征x,然后预测y值:

因此这个特征向量X是一维特征向量。

下面是通过svm进行数据拟合预测的类,为了方便我先把它它的调用封装成类,.cpp文件如下:

  1. CLibsvm::CLibsvm(float C,float gamma,float epsilon)
  2. {
  3.     m_svmpara=Initialize_svm_parameter(C,gamma,epsilon);
  4. }
  5. CLibsvm::~CLibsvm(void)
  6. {
  7. }
  8. svm_parameter CLibsvm::Initialize_svm_parameter(float C,float gamma,float epsilon)
  9. {
  10.     svm_parameter svmpara;//svm的相关参数
  11.     svmpara.svm_type = EPSILON_SVR;
  12.     svmpara.kernel_type =RBF;
  13.     svmpara.degree = 3;
  14.     svmpara.gamma = gamma;  // 默认大小可选择特征的倒数 1/num_features,核函数中的gamma函数设置(只针对多项式/rbf/sigmoid核函数)
  15.     svmpara.coef0 = 0;
  16.     svmpara.nu = 0.5;
  17.     svmpara.cache_size = 1;//缓存块大小
  18.     svmpara.C = C;
  19.     svmpara.eps = 1e-3;
  20.     svmpara.p = epsilon;
  21.     svmpara.shrinking = 1;
  22.     svmpara.probability = 0;
  23.     svmpara.nr_weight = 0;
  24.     svmpara.weight_label = NULL;
  25.     svmpara.weight = NULL;
  26.     return svmpara;
  27. }
  28. //拟合数据输入
  29. void CLibsvm::TrainModel(vector<vec2>traindata)
  30. {
  31.     //Normalizedata(traindata,m_minpt,m_maxpt);
  32.     int sample_num=traindata.size();//训练样本个数
  33.     int feature_dimn=1;//样本的特征维数为1
  34.     double *y=new double[sample_num];
  35.     double **x=new double *[sample_num];
  36.     for (int i=0;i<sample_num;i++)
  37.     {
  38.         x[i]=new double[feature_dimn];
  39.     }
  40.     for (int i=0;i<sample_num;i++)
  41.     {
  42.         y[i]=traindata[i][feature_dimn];
  43.         for (int j=0;j<feature_dimn;j++)
  44.         {
  45.             x[i][j]=traindata[i][j];
  46.         }
  47.     }
  48. //训练数据归一化
  49.     //获取最大最小值
  50.     GetMax_Min(y,sample_num,m_miny,m_maxy);//训练数据y的最大最小值获取
  51.     m_minx=new double[feature_dimn];//特征最大最小值获取
  52.     m_maxx=new double[feature_dimn];
  53.     double *pdata=new double[sample_num];
  54.     for (int j=0;j<feature_dimn;j++)
  55.     {
  56.         for (int i=0;i<sample_num;i++)
  57.         {
  58.             pdata[i]=x[i][j];
  59.         }
  60.         GetMax_Min(pdata,sample_num,m_minx[j],m_maxx[j]);
  61.     }
  62.     //训练数据归一化
  63.     for (int i=0;i<sample_num;i++)
  64.     {
  65.         y[i]=2*(y[i]-m_miny)/(m_maxy-m_miny)-1;
  66.         for (int j=0;j<feature_dimn;j++)
  67.         {
  68.             x[i][j]=2*(x[i][j]-m_minx[j])/(m_maxx[j]-m_minx[j])-1;
  69.         }
  70.     }
  71. //训练数据输入
  72.     svm_problem svmpro;//svm训练数据
  73.     svmpro.l=sample_num;
  74.     svmpro.y=new double[sample_num];
  75.     svmpro.x=new svm_node *[sample_num];//训练数据的特征向量
  76.     for (int i=0;i<sample_num;i++)
  77.     {
  78.         svmpro.y[i]=y[i];//用训练数据的y,作为输入标签
  79.         svmpro.x[i]=new svm_node[feature_dimn+1];
  80.         for (int j=0;j<feature_dimn;j++)
  81.         {
  82.             svm_node node_ij;
  83.             node_ij.index=j+1;//需要注意的是svm_node的第一个数据的索引为1,数值为第一位特征值,我一开始这里搞错了,把索引搞成从0开始
  84.             node_ij.value=x[i][j];
  85.             svmpro.x[i][j]=node_ij;
  86.         }
  87.         svm_node node_last;//需要添加最后一维特征的索引为-1
  88.         node_last.index=-1;
  89.         svmpro.x[i][feature_dimn]=node_last;
  90.     }
  91. //验证输入的训练数据、初始化的参数是否有误
  92.     const char *error_msg;
  93.     error_msg = svm_check_parameter(&svmpro,&m_svmpara);
  94.     if(error_msg)
  95.     {
  96.         AfxMessageBox(error_msg);
  97.     }
  98. //数据训练
  99.     m_svmmodel=svm_train(&svmpro,&m_svmpara);
  100. }
  101. void CLibsvm::Predict(float x,float &y)
  102. {
  103.     x=2*(x-m_minx[0])/(m_maxx[0]-m_minx[0])-1;
  104.     svm_node *testX1=new svm_node[1+1];
  105.     testX1[0].index=1;
  106.     testX1[0].value=x;
  107.     testX1[1].index=-1;
  108.     y=(svm_predict(m_svmmodel,testX1)+1)*(m_maxy-m_miny)*0.5+m_miny;
  109. }
  110. //数据归一化
  111. void CLibsvm::GetMax_Min(double*pdata,int data_num,double &minpt,double&maxpt)
  112. {
  113.     double minx=1e10;
  114.     double maxx=-1e10;
  115.     for (int i=0;i<data_num;i++)
  116.     {
  117.         if (pdata[i]<minx)
  118.         {
  119.             minx=pdata[i];
  120.         }
  121.         if (pdata[i]>maxx)
  122.         {
  123.             maxx=pdata[i];
  124.         }
  125.     }
  126.     minpt=minx;
  127.     maxpt=maxx;
  128. }

然后是头文件:

  1. #pragma once
  2. #include “svm/svm.h”
  3. #include “Vec.h”
  4. #include <vector>
  5. class CLibsvm
  6. {
  7. public:
  8.     CLibsvm(float C=1,float gamma=1,float epsilon=0.1);
  9.     ~CLibsvm(void);
  10.     void TrainModel(vector<vec2>traindata);//数据训练
  11.     void Predict(float x,float &y);//拟合预测函数
  12. private:
  13.     svm_parameter Initialize_svm_parameter(float C=1,float gamma=1,float epsilon=0.1);//参数初始化函数
  14.     svm_parameter m_svmpara;
  15.     svm_problem m_svmprob;
  16.     std::vector<vec2>m_traindata;//二维拟合数据
  17.     svm_model *m_svmmodel;
  18.     void GetMax_Min(double*pdata,int data_num,double &minpt,double&maxpt);//获取数据归一化的最大最小值
  19.     double *m_maxx;//归一化用的参数
  20.     double *m_minx;
  21.     double m_miny;
  22.     double m_maxy;
  23. };

OK,接着是封装好的这个类的调用:

  1.     //m_controlpoint为训练数据,也就是鼠标输入蓝色的点
  2.     CLibsvm csvm(1);
  3.     csvm.TrainModel(m_controlpoint);//二维数据点
  4. /*
  5.     CLibsvm csvm2(1,1);
  6.     csvm2.TrainModel(m_controlpoint);*/
  7.     float minx=1e10;
  8.     float maxx=0;
  9.     for (int i=0;i<m_controlpoint.size();i++)
  10.     {
  11.         if (m_controlpoint[i][0]<minx)
  12.         {
  13.             minx=m_controlpoint[i][0];
  14.         }
  15.         if (m_controlpoint[i][0]>maxx)
  16.         {
  17.             maxx=m_controlpoint[i][0];
  18.         }
  19.     }
  20.     m_resultcurve.clear();
  21.     for (int i=minx;i<maxx;i++)
  22.     {
  23.         float y=0;
  24.         csvm.Predict(i,y);
  25.         m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线
  26.         float y2=0;
  27. /*
  28.         csvm2.Predict(i,y2);
  29.         m_resultcurve2.push_back(vec2(i,y2));*/
  30.     }

接着分析一下CLibsvm构造函数的三个参数好如何选择:

首先第一个参数是惩罚因子,这个参数越大,拟合出来的曲线自然而然越精确,测试一下,测试代码如下:

  1. //m_controlpoint为训练数据,也就是鼠标输入蓝色的点
  2.     CLibsvm csvm(1);
  3. csvm.TrainModel(m_controlpoint);//二维数据点
  4. CLibsvm csvm2(100);
  5. csvm2.TrainModel(m_controlpoint);
  6. float minx=1e10;
  7. float maxx=0;
  8. for (int i=0;i<m_controlpoint.size();i++)
  9. {
  10.     if (m_controlpoint[i][0]<minx)
  11.     {
  12.         minx=m_controlpoint[i][0];
  13.     }
  14.     if (m_controlpoint[i][0]>maxx)
  15.     {
  16.         maxx=m_controlpoint[i][0];
  17.     }
  18. }
  19. m_resultcurve.clear();
  20. for (int i=minx;i<maxx;i++)
  21. {
  22.     float y=0;
  23.     csvm.Predict(i,y);
  24.     m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线
  25.     float y2=0;
  26.     csvm2.Predict(i,y2);
  27.     m_resultcurve2.push_back(vec2(i,y2));
  28. }

通过分别选用C=1 和C=100的参数,得到如下绿色和红色结果曲线,红色的曲线为C=100得到的结果:

OK,接着测试一下,参数sigma对结果的影响,测试代码如下:

  1.     CLibsvm csvm(1,1);
  2. csvm.TrainModel(m_controlpoint);//二维数据点
  3. CLibsvm csvm2(1,100);
  4. csvm2.TrainModel(m_controlpoint);
  5. float minx=1e10;
  6. float maxx=0;
  7. for (int i=0;i<m_controlpoint.size();i++)
  8. {
  9.     if (m_controlpoint[i][0]<minx)
  10.     {
  11.         minx=m_controlpoint[i][0];
  12.     }
  13.     if (m_controlpoint[i][0]>maxx)
  14.     {
  15.         maxx=m_controlpoint[i][0];
  16.     }
  17. }
  18. m_resultcurve.clear();
  19. for (int i=minx;i<maxx;i++)
  20. {
  21.     float y=0;
  22.     csvm.Predict(i,y);
  23.     m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线
  24.     float y2=0;
  25.     csvm2.Predict(i,y2);
  26.     m_resultcurve2.push_back(vec2(i,y2));
  27. }

上面的代码中,我分别选择sigma=1,sigma=100进行比较,结果如下:

可以看到与C一样,参数越大,对于训练数据,其误差越小。当然我们需要知道,对于机器学习算法来说,训练数据后的误差越小并不是越好,上面的结果其实是过拟合的。

参考文献:1、http://blog.csdn.net/liulina603/article/details/8532837

转载注明来源:CV视觉网 » 机器学习(十四)Libsvm学习笔记

分享到:更多 ()
扫描二维码,给作者 打赏
pay_weixinpay_weixin

请选择你看完该文章的感受:

0不错 0超赞 0无聊 0扯淡 0不解 0路过

评论 4

评论前必须登录!