Felomeng翻译：libsvm2.88之中文文档完全翻译版（单文档）

最新推荐文章于 2025-11-25 20:02:40 发布

最新推荐文章于 2025-11-25 20:02:40 发布 · 202 阅读

文章标签：

本文介绍了一个高效的支持向量机工具包libsvm，该工具包提供C-SVM分类功能，并附带模型自动选择工具。文章还介绍了如何使用libsvm进行交叉验证以及获取分类模型的标签。

本译文还有<a href="http://download.youkuaiyun.com/source/1190636">word（.doc）版</a>和<a href="http://blog.youkuaiyun.com/Felomeng/archive/2009/04/09/4058711.aspx">在线版</a>。

支持向量机工具包（libsvm）是简单、高效、易用的支持向量机（SVM）分类与回归软件。它可以解决C-SVM分类，工具包还为C-SVM分类提供了模型自动选择工具。本文档将介绍支持向量机工具包的用法。

支持向量机工具包可以从<a href="http://www.csie.ntu.edu.tw/~cjlin/libsvm">http://www.csie.ntu.edu.tw/~cjlin/libsvm</a>下载。在使用支持向量机工具包之前请先阅读文件COPYRIGHT（版权协议）。

目录
=================
快速入门
安装和数据格式
“svm-train”的使用
“svm-predict”的使用
“svm-scale”的使用
实际使用中的技巧
示例
预先计算好的内核
函数库的使用
Java版本
生成windows下的二进制文件（二进行文件就是通常所说的exe文件，即可执行文件）
附加工具：子取样器，参数选择器，数据格式较验器等
Python接口
附录

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E5%BF%AB%E9%80%9F%E5%85%A5%E9%97%A8"></a>快速入门
</h1>
===========

如果你没有接触过支持向量机，且要处理的数据量并不大，那么请在安装完成之后使用“tools”文件夹下的easy.py。它可以自动完成从数据数值化到参数选择的一切工作。

语法：easy.py 训练文件[测试文件]

更多关于参数选择的信息见文件“tools/README”。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E5%AE%89%E8%A3%85%E5%92%8C%E6%95%B0%E6%8D%AE%E6%A0%BC%E5%BC%8F"></a>安装和数据格式
</h1>
============================

在Unix系统中，键入“make”来生成“svm-train”和“svm-predict”程序。不带参数运行它们，可以查看它们的语法。 
在其它的操作系统中，请参考“Makefile”文件来生成它们（例如，查看本文档中的“生成Windows二进制文件”，或者直接使用已经生成的二进制文件（Windows二进制文件在文件夹“windows”中）。 
训练与测试数据文件的格式如下所示 
<label> <index1>:<value1> <index2>:<value2>…
.
.
. 
每行包含一个实例，并且以字符’\n’结束。对于分类来讲，<label>是整型数据，表示类别（支持多分类）。对于回归来讲，<label>是任意实数（浮点数），表示目标值。one-class SVM并不使用这个参数，所以使用什么数值都可以。除非使用预计算好的内核（稍候章节介绍），否则<index>:<value>是描述属性值的。<index>（索引）是从1开始的整型数据，而<value>（值）是实数（浮点型）。索引必须升序排列。在测试文件中的标签只是用于计算精确度或错误率。如果它们是未知的，那么只要将第一列赋任意数值。 
本包含有一个用于分类的示例数据文件，文件名是“heart_scale”。要验证你的数据格式的正确性，请使用“tools/checkdata.py”工具（详见文件“tools/README”）。 
键入“svm-train heart_scale”，程序会读读入训练数据并生成模型文件“heart_scale.model”。假设你有一个名为“heart_scale.t”的测试集，那么键入“svm-predict heart_scale.t heart_scale.model output”以测试预测精确度。文件“output”中含有预测的分类标签。 
本包中还有一些别的实用程序： 
svm-scale: 
 将输入数据数值化的工具。
svm-toy:
 简单的图形界面工具，它可以展示支持向量机怎样在二维空间（即平面）上将数据分类。你可以在该窗口上面单击以绘制数据点。使用“change”按钮来选择类别1，2或3（也就是说，最多支持三类），按“load”按钮可以从文件载入数据，按“save”按钮可以将数据保存到文件，按“run”按钮可以获得一个SVM模型（根据绘制的点集或从文件载入的数据），按“clear”按钮可以清屏。

 在该窗口的底部文本框内，你可以输入参数，参数的句法和“svm-train”一样。

 注意：“load”和“save”只考虑数据分类而不考虑回归的情况。每个数据点拥有一个标签（颜色，必须是1，2或3）和两个属性（横坐标和纵座标），取值区间[0,1]。

 在相应目录键入“make”来生成这些程序。

 如果要生成Qt版本，那么需要有Qt库的支持。 （可以从<a href="http://www.trolltech.com/">http://www.trolltech.com</a>下载）

 如果要生成GTK+版本，那么需要有GTK+库的支持。（可以从<a href="http://www.gtk.org/">http://www.gtk.org</a>下载）
 
 已编译二的Windows二进行文件在“windows”文件夹中。我们是在32位的机器上使用Visual C++生成的这些二进制文件，所以最大可以缓存是2G。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E2%80%9Csvm-train%E2%80%9D%E7%9A%84%E4%BD%BF%E7%94%A8"></a>“svm-train”的使用
</h1>
=================

语法：svm-train [参数表] 训练数据集文件 [模型文件] 
参数：
-s 支持向量机类型：支持向量机类型集合（默认值0）
 0 -- C-SVC
 1 -- nu-SVC
 2 -- one-class SVM
 3 -- epsilon-SVR
 4 -- nu-SVR
-t 内核类型：内核函数集合（默认值2）
 0 -- 线性函数：u'*v
 1 --多项式函数：(gamma*u'*v + coef0)^degree
 2 --径向基函数：exp(-gamma*|u-v|^2)
 3 – sigmoid函数：tanh(gamma*u'*v + coef0)
 4 – 预先计算好的内核函数 (训练文件中的内核数值)
-d degree值：设定内核函数的degree值（默认值3）
-g gamma值：设定内核函数的gamma值（默认值1/k）
-r coef0值：设定内核函数的coef0值（默认值0）
-c cost值：设定C-SVC、epsilon-SVR、和nu-SVR中的参数C的值（默认值1）
-n nu值：设定nu-SVC、one-class SVM、和nu-SVR中的参数nu的值（默认值0.5）
-p epsilon值：设定epsilon-SVR中损失函数的epsilon值（默认值0.1）
-m 缓存大小：设定缓存内存大小，以MB为单位（默认值100）
-e epsilon值：设定结束条件（默认值0.001）
-h 压缩：是否启用启发式压缩，值为0或1（默认1）
-b 概率期望：在训练SVC或SVR模型时是否启用概率期望，值为0或1（默认值0）
-wi 权重：设定C-SVC中类i的参数C为权重*C（默认值1）
-v n：n重交叉验证模式

-g参数的k值表示输入数据的属性数量。

参数-v随机切分数据为n个部分，然后计算它们之间交叉验证的精确度/平均方差。

输出内容的含义参见libsvm常见问题（FAQ）。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E2%80%9Csvm-predict%E2%80%9D%E7%9A%84%E4%BD%BF%E7%94%A8"></a>“svm-predict”的使用
</h1>
===================

语法：svm-predict [参数表] 测试文件 模型文件 输出文件
参数：
-b 概率期望：是否启用概率期望，值为0或1（默认值0）；one-class SVM只支持0。

参数中的模型文件是使用svm-train生成的模型文件。
测试文件是你想测试的数据文件。
svm-predict会把结果输出到输出文件。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E2%80%9Csvm-scale%E2%80%9D%E7%9A%84%E4%BD%BF%E7%94%A8"></a>“svm-scale”的使用
</h1>
=================

语法：svm-scale [参数表] 数据文件
参数：
-l 下限：x坐标数值化最低下限（默认值-1）
-u 上限：x坐标数值化最高上限（默认值+1）
-y y_lower y_upper：y坐标数值化区间（默认值：不使用y坐标值）
-s 保存文件名：将数值化参数保存到指定文件。
-r 恢复文件名：从指定文件重新得到数值化的参数。

参见本文档中“示例”部分的例子

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E5%AE%9E%E9%99%85%E4%BD%BF%E7%94%A8%E4%B8%AD%E7%9A%84%E6%8A%80%E5%B7%A7"></a>实际使用中的技巧
</h1>
=====================

数值化你的数据。例如，将所有的属性用区间[0,1]或[-1,+1]中的数值表示。
*使用C-SVC模型时，可以考虑选用“tools”文件夹中的模型选择工具。
*在nu-SVC/one-class-SVM/nu-SVR模型中的nu参数接近训练错误和支持向量的商。
*如果分类的目标数据是不均衡的（比如正数很多，且很少有负数），试着通过-wi参数调整惩罚因子C（参见下面的示例）。
*处理较大规模问题时设定较大的缓存大小（也就是扩大参数-m的数值）。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E7%A4%BA%E4%BE%8B"></a>示例
</h1>
========

> svm-scale -l -1 -u 1 -s range train > train.scale
> svm-scale -r range test > test.scale

将训练数据中的每个属性都在区间[-1,1]中数值化。先将数据化因子保存到文件range中，然后再用于数值化测试数据。

> svm-train -s 0 -c 5 -t 2 -g 0.5 -e 0.1 data_file

使用RBF内核函数exp(-0.5|u-v|^2)，C=10，并且设定结束条件为0.1来训练分类器

> svm-train -s 3 -p 0.1 -t 0 data_file

使用线性内核函数u'v，设定损失方程中epsilon=0.1解决支持向量机回归问题。

> svm-train -c 10 -w1 1 -w-1 5 data_file

对类1使用惩罚因子10=1*10，而对类-1使用惩罚因子50=5*50来训练分类器。

> svm-train -s 0 -c 100 -g 0.1 -v 5 data_file

使用参数C=100和gamma=0.1对分类器进行五次交叉验证。

> svm-train -s 0 -b 1 data_file
> svm-predict -b 1 test_file data_file.model output_file

根据概率信息和有概率期望的预测数据获得一个模型。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E9%A2%84%E5%85%88%E8%AE%A1%E7%AE%97%E5%A5%BD%E7%9A%84%E5%86%85%E6%A0%B8"></a>预先计算好的内核
</h1>
===================

用户可以预告计算好核心数值并将它们作为训练和测试文件输入。这样支持向量机工具包就不需要原始的训练/测试数据集了。

假设有L个训练实例，x1,…,xL。设K(x,y)为实例x与y的内核值。则输入数据格式为：

xi的新训练实例：

<label>0:I 1:K(xi,x1)…L:K(xi,xL)

x的新测试实例：

<label>0:?1:K(x,x1)…L:K(x,xL)

也就是说，在训练文件中，第一列必须是xi的“ID”。在测试实例中，?表示任意值。

包括“±0”在内的所有内核数值都必须明确给定。训练/测试文件的任何排列或随机子集都是合法的（见下面的例子）。

注意：与支持向量机工具包的早期发行版本中工具的预先计算好核心集的格式略有不同

示例：

 假设原始训练数据有三个实例，每个实例有四种属性，而测试数据有一个实例：

 15 1:1 2:1 3:1 4:1
 45 2:3 4:3
 25 3:1

 15 1:1 3:1

 如果使用线性核心，那么我们会得到如下的训练与测试集合：

 15 0:1 1:4 2:6 3:1
 45 0:2 1:6 2:18 3:0 
 25 0:3 1:1 2:0 3:1

 15 0:? 1:2 2:0 3:1

 ? 表示任意值

 以上训练文件中的任意子集也都是合法的。例如：
 25 0:3 1:1 2:0 3:1
 45 0:2 1:6 2:18 3:0 

 意味着核心矩阵是
 [K(2,2) K(2,3)] = [18 0]
 [K(3,2) K(3,3)] = [0 1]

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E5%87%BD%E6%95%B0%E5%BA%93%E7%9A%84%E4%BD%BF%E7%94%A8"></a>函数库的使用
</h1>
=============

这些函数和结构都在头文件“svm.h”中有声名。你需要在你的C/C++源文件中添加#include “svm.h”语句，在连接时需要将你的程序与svm.cpp连接。具体使用方法可以参考“svm-train.c”和“svm-predict.c”的使用示例。在文件svm.h中使用LIBSVM_VERSION定义了版本号，以便读者查阅。

在对测试数据进行分类之前，需要先使用训练数据建立一个支持向量模型。模型可以以文件的形式存储以备以后使用。一旦建立好了支持向量机模型，就可以用它来对新的数据进行分类了。

-函数：struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);

这个函数根据给定的参数和训练数据构建并返回一个支持向量机模型。

结构体svm_problem将问题形式化：
 
 struct svm_problem
 {
 int l;
 double *y;
 struct svm_node **x;
 };

其中“l”表示训练数据的实例数，而“y”是一个数组，用于存放它们的目标值。（类型值用整型数据，回归值用实数）“x”是一个数组指针，每一个指针指向一个稀疏的训练向量（即一个svm_node数组）。 

例如，如果我们有如下的训练数据：

LABEL ATTR1 ATTR2 ATTR3 ATTR4 ATTR5
 ----- ----- ----- ----- ----- -----
 1 0 0.1 0.2 0 0
 2 0 0.1 0.3 -1.2 0
 1 0.4 0 0 0 0
 2 0 0.1 0 1.4 0.5
 3 -0.1 -0.2 0.1 1.1 0.1

于是svm_problem的构成如下：

l = 5

y -> 1 2 1 2 3

x -> [ ] -> (2,0.1) (3,0.2) (-1,?)
 [ ] -> (2,0.1) (3,0.3) (4,-1.2) (-1,?)
 [ ] -> (1,0.4) (-1,?)
 [ ] -> (2,0.1) (4,1.4) (5,0.5) (-1,?)
 [ ] -> (1,-0.1) (2,-0.2) (3,0.1) (4,1.1) (5,0.1) (-1,?)

其中（索引，值）存储在结构“svm_node”中：

 struct svm_node
 {
 int index;
 double value;
 };

当索引为-1时表示已经到达向量的末端。注意索引必须“升序”排列。

结构体svm_parameter描述了一个支持向量机的参数：

 struct svm_parameter
 {
 int svm_type;
 int kernel_type;
 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_type可以是C_SVC、NU_SVC、ONE_CLASS、EPSILON_SVR或NU_SVR其中的一种。

C_SVC: C-SVM 分类
NU_SVC: nu-SVM 分类
ONE_CLASS: one-class-SVM
EPSILON_SVR: epsilon-SVM回归
NU_SVR: nu-SVM回归

kernel_type可以是LINEAR、POLY、RBF、SIGMOID其中一种。

LINEAR: u'*v
POLY: (gamma*u'*v + coef0)^degree
RBF: exp(-gamma*|u-v|^2)
SIGMOID: tanh(gamma*u'*v + coef0)
PRECOMPUTED:训练集文件中的核心值

cache_size是核心缓存的大小，单位为MB。C是违背约束成本（惩罚值）。eps是结束条件。（一般地，我们在nu-SVC模型中使用0.00001，在其它模型中使用0.001）。nu是nu-SVM、nu-SVR与one-class-SVM中的一个参数。p 是epsilon-SVM回归中对epsilon不敏感函数的epsilon值。shirnking = 1表示使用压缩，否则 = 0。 probability = 1表示得到带概率信息的模型，否则 = 0。

nr_weight、weight_label和weight（权重）用于改变某些类的惩罚因子（如果一个类的权重不变，则将权重值设定为1）这在使用不均衡输入数据或使用不均匀错误成本训练分类器时尤其有用。

nr_weight是数组weight_label和weight中的元素个数。每个weight[i]对应一个weight_label[i]，表示类weight_label[i]的惩罚是由因子weight[i]确定的。
 
如果不想改变任何类的惩罚因子，那么只需要将nr_weight设定为0。

*注意*因为svm_model含有指向svm_problem的指针，如果仍要使用由svm_train()产生的svm_model，那么就不要释放svm_problem的内存。 

*注意*为了避免错误的参数，在调用svm_train()之前应该先调用svm_check_parameter()。

-函数：double svm_predict(const struct svm_model *model,
const struct svm_node *x);

在给定模型的前提下，这个函数可以用来对测试向量x进行分类或回归。

分类模型返回的是x的预测类。
回归模型返回使用该模型计算所得的x函数值。one-class模型返回+1或-1。

-函数：void svm_cross_validation(const struct svm_problem *prob,
 const struct svm_parameter *param, int nr_fold, double *target);

这个函数用于交叉验证。数据会分成nr_fold个部分。在给定的参数下，顺序地对每一部分数据用其余部分数据训练成的模型进行验证。在验证过程中，预测标签（所有prob的实例）存放到一个名为target（目标）的数组。

svm_prob的格式与svm_train()的相同。 

-函数：int svm_get_svm_type(const struct svm_model *model);

这个函数用于确定模型的svm_type。可能的svm_type值已在svm.h中定义。

-函数：int svm_get_nr_class(const svm_model *model);

对于分类模型，本函数用于得到类的数量。回归或one-class模型的返回值是2。

-函数：void svm_get_labels(const svm_model *model, int* label)
 
对于分类模型，这个函数输出名称标签到一个名为label的数组。对于回归或one-class模型，label的值保护不变。

-函数：double svm_get_svr_probability(const struct svm_model *model);

对于带有概率信息的回归模型，此函数将输出一个值sigma>0。对于测试数据，我们考虑概率模型：目标值 = 预测值 + z，z：拉普拉斯分布e^(-|z|/sigma)/(2sigma)

如果不是svr模型，或者不含有需要的信息，则返回0。

-函数：void svm_predict_values(const svm_model *model,
 const svm_node *x, double* dec_values)

在给定模型的前提下，这个函数可以用来给出测试向量x的决策值。

对于有nr_class个类的分类模型，这个函数给出nr_class*(nr_class-1)/2个决策值，并存到数组dec_values中，其中nr_class可以通过函数svm_get_nr_class得到。序列是label[0] vs. label[1], …, label[0] vs. label[nr_class – 1], label[1] vs. label[2], …, label[nr_class-2] vs. label[nar_class-1], 其中label可以通过函数svm_get_lables得到。

回归模型中，label[0]表示使用该模型计算所得的x函数值。one-class模型中，label[0]是+1或-1。

-函数：double svm_predict_probability(const struct svm_model *model,
 const struct svm_node *x, double* prob_estimates);
 
在给定带概率信息的模型的前提下，这个函数可以用来对测试向量x进行分类或回归。

对于带有概率信息的分类模型，这个函数会把nr_class概率期望输出到数组prob_estimates中。 nr_class可以通过函数svm_get_nr_class得到。返回值是概率值最高的类。对于回归或one-class支持向量机，数组prob_estimates保持不变，而返回值与svm_predict的返回值相同。

-函数：const char *svm_check_parameter(const struct svm_problem *prob,
const struct svm_parameter *param);

本函数检验对于当前问题，参数是否合法。在调用svm_train()和svm_cross_validation()之前应该调用此函数。如果参数合法，则返回NULL，如果不合法，则返回错误信息。

-函数：int svm_check_probability_model(const struct svm_model *model);

此函数用于判断当前模型是否含有进行概率期望运算所需要的信息。如果含有则返回+1。否则返回0。在调用sv svm_get_svr_probability和svm_predict_probability之前应该调用此函数。

-函数：int svm_save_model(const char *model_file_name,
 const struct svm_model *model);

此函数用于将训练好的模型保存到文件中，如果保存成功则返回0，如果发生错误则返回-1。

-函数：struct svm_model *svm_load_model(const char *model_file_name);

此函数从文件中读取模型并返回指向该模型的指针，如果读取失败则回返空指针。

-函数：void svm_destroy_model(struct svm_model *model);

此函数用于释放指定模型的内存。

-函数：void svm_destroy_param(struct svm_parameter *param);

此函数用于释放指定参数集的内存。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_Java%E7%89%88%E6%9C%AC"></a>Java版本
</h1>
============

java预编译类包“libsvm.jar”以及源代码文件都在文件夹java中。要运行程序，使用下列命令：
java -classpath libsvm.jar svm_train <参数表>
java -classpath libsvm.jar svm_predict <参数表>
java -classpath libsvm.jar svm_toy <参数表>
java -classpath libsvm.jar svm_scale <参数表>

注意：程序运行需要java 1.5（5.0）支持。

需要把java运行时库（如classes.zip）添加到类路径。
需要将java最大堆容量调大。

类库的使用方法与C版本类似。可用的方程如下：

public class svm {
 public static final int LIBSVM_VERSION=288;
 public static svm_model svm_train(svm_problem prob, svm_parameter param);
 public static void svm_cross_validation(svm_problem prob, svm_parameter param, int nr_fold, double[] target);
 public static int svm_get_svm_type(svm_model model);
 public static int svm_get_nr_class(svm_model model);
 public static void svm_get_labels(svm_model model, int[] label);
 public static double svm_get_svr_probability(svm_model model);
 public static void svm_predict_values(svm_model model, svm_node[] x, double[] dec_values);
 public static double svm_predict(svm_model model, svm_node[] x);
 public static double svm_predict_probability(svm_model model, svm_node[] x, double[] prob_estimates);
 public static void svm_save_model(String model_file_name, svm_model model) throws IOException
 public static svm_model svm_load_model(String model_file_name) throws IOException
 public static String svm_check_parameter(svm_problem prob, svm_parameter param);
 public static int svm_check_probability_model(svm_model model);
}

“libsvm”包中含有该类库。
注意在java版本中，svm_node[]不以索引值=-1的结点结束。


<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E7%94%9F%E6%88%90windows%E4%B8%8B%E7%9A%84%E4%BA%8C%E8%BF%9B%E5%88%B6%E6%96%87%E4%BB%B6%EF%BC%88%E4%BA%8C%E8%BF%9B%E8%A1%8C%E6%96%87%E4%BB%B6%E5%B0%B1%E6%98%AF%E9%80%9A%E5%B8%B8%E6%89%80%E8%AF%B4%E7%9A%84exe%E6%96%87%E4%BB%B6%EF%BC%8C"></a>生成windows下的二进制文件（二进行文件就是通常所说的exe文件，即可执行文件）
</h1>
=========================

windows二进制文件在文件夹“windows”中。可以使用visual C++制成这些文件，步骤如下：

1. 打开一个DOS命令窗（或者visual studio命令提示）并到libsvm文件夹中。如果尚未设置VC++的环境变量，那么可以键入“C:\Program Files\Microsoft Visual Studio 8.0\VC\bin\vcvars32.bat”。

可以根据VC++的版本及安装目录改变上面的目录。

2. 键入

nmake -f Makefile.win clean all

3. （可选）要生成python接口，下载并安装Python。
打开Makefile.win文件，将PYTHON_INC和PYTHON_LIB设置为python安装目录。键入
nmake -f Makefile.win python
然后将windows\python\svmc.pyd拷贝到python文件夹下。

还可以在Visual C++ 环境下生成这些文件。详情请见支持向量机工具包常见问题（FAQ）。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E9%99%84%E5%8A%A0%E5%B7%A5%E5%85%B7%EF%BC%9A%E5%AD%90%E5%8F%96%E6%A0%B7%E5%99%A8%EF%BC%8C%E5%8F%82%E6%95%B0%E9%80%89%E6%8B%A9%E5%99%A8%EF%BC%8C%E6%95%B0%E6%8D%AE%E6%A0%BC%E5%BC%8F%E8%BE%83%E9%AA%8C%E5%99%A8%E7%AD%89"></a>附加工具：子取样器，参数选择器，数据格式较验器等
</h1>
============================================================================

参见tools文件夹下的README文件。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_Python%E6%8E%A5%E5%8F%A3"></a>Python接口
</h1>
================

参见python文件夹下的README文件。

<h1 style="margin: 17pt 0cm 16.5pt;">
<a name="_%E9%99%84%E5%BD%95"></a>附录
</h1>
======================

如果您认为支持向量机工具包对您有帮助，那么请标明引自Chih-Chung Chang和Chih-Jen Lin的支持向量机工具包：支持向量机的一个类库，2001年。
软件可以从<a href="http://www.csie.ntu.edu.tw/~cjlin/libsvm">http://www.csie.ntu.edu.tw/~cjlin/libsvm</a>下载。

支持向量机工具包的使用文档可以从<a href="http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf">http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf</a>下载。

如果您有任何问题或建议，请发电子邮件到<a href="mailto:cjlin@csie.ntu.edu.tw">cjlin@csie.ntu.edu.tw</a>。

致谢：
这项工作得到了台湾行政院国家科学委员会的NSC 89-2213-E-002-013许可的部分支持。
作者在些向于开发团队成员及参与了建设性讨论与评论的广大用户致以诚挚的谢意！开发团队及建设性建议提出者列于：<a href="http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements">http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements</a>