机器学习（十四）Libsvm学习笔记

Libsvm学习笔记

原文地址：http://blog.youkuaiyun.com/hjimce/article/details/46971039 

作者：hjimce

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、数据训练

训练调用函数：

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

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

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

struct svm_problem
{
	int l;//训练数据的个数
	double *y;//训练数据的标签，y[i]表示第i个样本的标签
	struct svm_node **x;//训练数据的特征，x[i][j]表示第i个样本的第j个特征值
};

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

struct svm_parameter
{
	int svm_type;//svm的类型，包括分类、预测拟合等，如果想用svm进行分类那么可以选择C_SVC，如果想用于拟合预测那么可以选择EPSILON_SVR
	int kernel_type;//核函数类型，包括线性核函数、高斯核函数、S激活函数、多项式
	int degree;	/* for poly */
	double gamma;	/* for poly/rbf/sigmoid */
	double coef0;	/* for poly/sigmoid */

	/* these are for training only */
	double cache_size; /* in MB */
	double eps;	/* stopping criteria *///迭代误差终止条件
	double C;	/* for C_SVC, EPSILON_SVR and NU_SVR *///惩罚因子
	int nr_weight;		/* for C_SVC */
	int *weight_label;	/* for C_SVC */
	double* weight;		/* for C_SVC */
	double nu;	/* for NU_SVC, ONE_CLASS, and NU_SVR */
	double p;	/* for EPSILON_SVR */
	int shrinking;	/* use the shrinking heuristics */
	int probability; /* do probability estimates */
};

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

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

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

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模型。接着如果要进行预测分类可以调用如下函数：

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的格式需要说明一下：

struct svm_node //储存单一向量的单个特征
{
	int index; //索引
	double value; //值
};

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控制台，进行测试的一个例子：

#include "stdafx.h"
#include "svm/svm.h"
#include <iostream>
svm_parameter Initialize_svm_parameter()
{
	svm_parameter svmpara;//svm的相关参数
	svmpara.svm_type = C_SVC;
	svmpara.kernel_type = LINEAR;
	svmpara.degree = 3;
	svmpara.gamma = 0;	// 默认大小可选择特征的倒数 1/num_features，核函数中的gamma函数设置（只针对多项式/rbf/sigmoid核函数）
	svmpara.coef0 = 0;
	svmpara.nu = 0.5;
	svmpara.cache_size = 1;//缓存块大小
	svmpara.C = 1;
	svmpara.eps = 1e-3;
	svmpara.p = 0.1;
	svmpara.shrinking = 1;
	svmpara.probability = 0;
	svmpara.nr_weight = 0;
	svmpara.weight_label = NULL;
	svmpara.weight = NULL;
	return svmpara;
}
//二分类测试
//下面是通过人体身高和体重，进行性别的判别
int _tmain(int argc, _TCHAR* argv[])
{
	

	/*训练样本选取是学生的身高和体重：
		男1：身高：190cm，体重：70kg；
		男2：身高：180cm，体重：80kg；
		女1：身高：161cm，体重：80kg；
		女2：身高：161cm，体重：47kg；*/

	int sample_num=4;//训练样本个数为4
	int feature_dimn=2;//样本的特征维数为2
	double *y=new double[sample_num];
	double **x=new double *[sample_num];
	for (int i=0;i<sample_num;i++)
	{
		x[i]=new double[feature_dimn];
	}
	x[0][0]=190;x[0][1]=70;y[0]=-1;//训练样本1
	x[1][0]=180;x[1][1]=80;y[1]=-1;//训练样本2
	x[2][0]=161;x[2][1]=80;y[2]=1;//训练样本3
	x[3][0]=161;x[3][1]=47;y[3]=1;//训练样本4




//训练数据输入
	svm_parameter svmpara=Initialize_svm_parameter();//svm参数初始化
	svm_problem svmpro;//svm训练数据
	svmpro.l=sample_num;
	svmpro.y=y;//训练数据标签
	svmpro.x=new svm_node *[sample_num];//训练数据的特征向量
	for (int i=0;i<sample_num;i++)
	{
		svmpro.x[i]=new svm_node[feature_dimn+1];
		for (int j=0;j<feature_dimn;j++)
		{
			svm_node node_ij;
			node_ij.index=j+1;//需要注意的是svm_node的第一个数据的索引为1，数值为第一位特征值，我一开始这里搞错了，把索引搞成从0开始
			node_ij.value=x[i][j];
			svmpro.x[i][j]=node_ij;
		}
		svm_node node_last;//需要添加最后一维特征的索引为-1
		node_last.index=-1;
		svmpro.x[i][feature_dimn]=node_last;
	}






//验证输入的训练数据、初始化的参数是否有误
	const char *error_msg;
	error_msg = svm_check_parameter(&svmpro,&svmpara);
	if(error_msg)
	{
		std::cout<<error_msg;
		return 0;
	}
//数据训练
	svm_model *svmmodel=svm_train(&svmpro,&svmpara);

	
/*预测数据1：身高180cm，体重85kg；
预测数据2：身高161cm，体重50kg；*/
	svm_node *testX1=new svm_node[feature_dimn+1];
	testX1[0].index=1;
	testX1[0].value=180;
	testX1[1].index=2;
	testX1[1].value=85;
	testX1[2].index=-1;
	double testY1=svm_predict(svmmodel,testX1);
	std::cout<<"测试预测1："<<testY1<<std::endl;


	svm_node *testX2=new svm_node[feature_dimn+1];
	testX2[0].index=1;
	testX2[0].value=161;
	testX2[1].index=2;
	testX2[1].value=50;
	testX2[2].index=-1;
	double testY2=svm_predict(svmmodel,testX2);//分类预测函数
	std::cout<<"测试预测2："<<testY2<<std::endl;

	return 0;
}

最后的运行正确结果：

二、数据预测拟合案例

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

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

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

CLibsvm::CLibsvm(float C,float gamma,float epsilon)
{

	m_svmpara=Initialize_svm_parameter(C,gamma,epsilon);
}


CLibsvm::~CLibsvm(void)
{
}
svm_parameter CLibsvm::Initialize_svm_parameter(float C,float gamma,float epsilon)
{
	svm_parameter svmpara;//svm的相关参数
	svmpara.svm_type = EPSILON_SVR;
	svmpara.kernel_type =RBF;
	svmpara.degree = 3;
	svmpara.gamma = gamma;	// 默认大小可选择特征的倒数 1/num_features，核函数中的gamma函数设置（只针对多项式/rbf/sigmoid核函数）
	svmpara.coef0 = 0;
	svmpara.nu = 0.5;
	svmpara.cache_size = 1;//缓存块大小
	svmpara.C = C;
	svmpara.eps = 1e-3;
	svmpara.p = epsilon;
	svmpara.shrinking = 1;
	svmpara.probability = 0;
	svmpara.nr_weight = 0;
	svmpara.weight_label = NULL;
	svmpara.weight = NULL;
	return svmpara;
}
//拟合数据输入
void CLibsvm::TrainModel(vector<vec2>traindata)
{
	//Normalizedata(traindata,m_minpt,m_maxpt);
	int sample_num=traindata.size();//训练样本个数
	int feature_dimn=1;//样本的特征维数为1
	double *y=new double[sample_num];
	double **x=new double *[sample_num];
	for (int i=0;i<sample_num;i++)
	{
		x[i]=new double[feature_dimn];
	}

	for (int i=0;i<sample_num;i++)
	{
		y[i]=traindata[i][feature_dimn];
		for (int j=0;j<feature_dimn;j++)
		{
			x[i][j]=traindata[i][j];
		}
	}

//训练数据归一化
	//获取最大最小值
	GetMax_Min(y,sample_num,m_miny,m_maxy);//训练数据y的最大最小值获取
	m_minx=new double[feature_dimn];//特征最大最小值获取
	m_maxx=new double[feature_dimn];
	double *pdata=new double[sample_num];
	for (int j=0;j<feature_dimn;j++)
	{
		for (int i=0;i<sample_num;i++)
		{
			pdata[i]=x[i][j];	
		}
		GetMax_Min(pdata,sample_num,m_minx[j],m_maxx[j]);
	}
	//训练数据归一化
	for (int i=0;i<sample_num;i++)
	{
		y[i]=2*(y[i]-m_miny)/(m_maxy-m_miny)-1;
		for (int j=0;j<feature_dimn;j++)
		{
			x[i][j]=2*(x[i][j]-m_minx[j])/(m_maxx[j]-m_minx[j])-1;
		}
	}



//训练数据输入
	svm_problem svmpro;//svm训练数据
	svmpro.l=sample_num;
	svmpro.y=new double[sample_num];
	svmpro.x=new svm_node *[sample_num];//训练数据的特征向量
	for (int i=0;i<sample_num;i++)
	{
		svmpro.y[i]=y[i];//用训练数据的y，作为输入标签
		svmpro.x[i]=new svm_node[feature_dimn+1];
		for (int j=0;j<feature_dimn;j++)
		{
			svm_node node_ij;
			node_ij.index=j+1;//需要注意的是svm_node的第一个数据的索引为1，数值为第一位特征值，我一开始这里搞错了，把索引搞成从0开始
			node_ij.value=x[i][j];
			svmpro.x[i][j]=node_ij;
		}
		svm_node node_last;//需要添加最后一维特征的索引为-1
		node_last.index=-1;
		svmpro.x[i][feature_dimn]=node_last;
	}
//验证输入的训练数据、初始化的参数是否有误
	const char *error_msg;
	error_msg = svm_check_parameter(&svmpro,&m_svmpara);
	if(error_msg)
	{
		AfxMessageBox(error_msg);
	}
//数据训练
	m_svmmodel=svm_train(&svmpro,&m_svmpara);
}
void CLibsvm::Predict(float x,float &y)
{

	x=2*(x-m_minx[0])/(m_maxx[0]-m_minx[0])-1;
	svm_node *testX1=new svm_node[1+1];
	testX1[0].index=1;
	testX1[0].value=x;
	testX1[1].index=-1;
	y=(svm_predict(m_svmmodel,testX1)+1)*(m_maxy-m_miny)*0.5+m_miny;


}
//数据归一化
void CLibsvm::GetMax_Min(double*pdata,int data_num,double &minpt,double&maxpt)
{

	double minx=1e10;
	double maxx=-1e10;
	for (int i=0;i<data_num;i++)
	{
		if (pdata[i]<minx)
		{
			minx=pdata[i];
		}
		if (pdata[i]>maxx)
		{
			maxx=pdata[i];
		}
	}
	minpt=minx;
	maxpt=maxx;
}

然后是头文件：

#pragma once
#include "svm/svm.h"
#include "Vec.h"
#include <vector>
class CLibsvm
{
public:
	CLibsvm(float C=1,float gamma=1,float epsilon=0.1);
	~CLibsvm(void);
	void TrainModel(vector<vec2>traindata);//数据训练
	void Predict(float x,float &y);//拟合预测函数

private:
	svm_parameter Initialize_svm_parameter(float C=1,float gamma=1,float epsilon=0.1);//参数初始化函数
	svm_parameter m_svmpara;
	svm_problem m_svmprob;
	std::vector<vec2>m_traindata;//二维拟合数据
	svm_model *m_svmmodel;
	void GetMax_Min(double*pdata,int data_num,double &minpt,double&maxpt);//获取数据归一化的最大最小值
	double *m_maxx;//归一化用的参数
	double *m_minx;
	double m_miny;
	double m_maxy;

};

OK，接着是封装好的这个类的调用：

	//m_controlpoint为训练数据，也就是鼠标输入蓝色的点
   	CLibsvm csvm(1);
	csvm.TrainModel(m_controlpoint);//二维数据点
/*
	CLibsvm csvm2(1,1);
	csvm2.TrainModel(m_controlpoint);*/
	float minx=1e10;
	float maxx=0;
	for (int i=0;i<m_controlpoint.size();i++)
	{
		if (m_controlpoint[i][0]<minx)
		{
			minx=m_controlpoint[i][0];
		}
		if (m_controlpoint[i][0]>maxx)
		{
			maxx=m_controlpoint[i][0];
		}
	}
	m_resultcurve.clear();
	for (int i=minx;i<maxx;i++)
	{
		float y=0;
		csvm.Predict(i,y);
		m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线

		float y2=0;
/*
		csvm2.Predict(i,y2);
		m_resultcurve2.push_back(vec2(i,y2));*/
	}

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

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

	//m_controlpoint为训练数据，也就是鼠标输入蓝色的点
   	CLibsvm csvm(1);
	csvm.TrainModel(m_controlpoint);//二维数据点

	CLibsvm csvm2(100);
	csvm2.TrainModel(m_controlpoint);
	float minx=1e10;
	float maxx=0;
	for (int i=0;i<m_controlpoint.size();i++)
	{
		if (m_controlpoint[i][0]<minx)
		{
			minx=m_controlpoint[i][0];
		}
		if (m_controlpoint[i][0]>maxx)
		{
			maxx=m_controlpoint[i][0];
		}
	}
	m_resultcurve.clear();
	for (int i=minx;i<maxx;i++)
	{
		float y=0;
		csvm.Predict(i,y);
		m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线

		float y2=0;

		csvm2.Predict(i,y2);
		m_resultcurve2.push_back(vec2(i,y2));
	}

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

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

   	CLibsvm csvm(1,1);
	csvm.TrainModel(m_controlpoint);//二维数据点

	CLibsvm csvm2(1,100);
	csvm2.TrainModel(m_controlpoint);
	float minx=1e10;
	float maxx=0;
	for (int i=0;i<m_controlpoint.size();i++)
	{
		if (m_controlpoint[i][0]<minx)
		{
			minx=m_controlpoint[i][0];
		}
		if (m_controlpoint[i][0]>maxx)
		{
			maxx=m_controlpoint[i][0];
		}
	}
	m_resultcurve.clear();
	for (int i=minx;i<maxx;i++)
	{
		float y=0;
		csvm.Predict(i,y);
		m_resultcurve.push_back(vec2(i,y));//绘制拟合曲线

		float y2=0;

		csvm2.Predict(i,y2);
		m_resultcurve2.push_back(vec2(i,y2));
	}

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

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

**********作者：hjimce     联系qq：1393852684   更多资源请关注我的博客：http://blog.youkuaiyun.com/hjimce                原创文章，转载请保留本行信息。******************

参考文献：

1、http://blog.youkuaiyun.com/liulina603/article/details/8532837