# libsvm

**Repository Path**: dengly/libsvm

## Basic Information

- **Project Name**: libsvm
- **Description**: https://github.com/cjlin1/libsvm.git 副本
- **Primary Language**: Unknown
- **License**: BSD-3-Clause
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No

## Statistics

- **Stars**: 2
- **Forks**: 1
- **Created**: 2018-05-16
- **Last Updated**: 2024-05-16

## Categories & Tags

**Categories**: Uncategorized

**Tags**: None

## README

Libsvm是一个简单，易于使用和高效的SVM软件分类和回归。它解决了C-SVM分类，nu-SVM分类，one-class-SVM，epsilon-SVM回归和nu-SVM回归。它还提供了一个自动模型选择工具C-SVM分类。本文档解释了libsvm的使用。

Libsvm可在 http://www.csie.ntu.edu.tw/~cjlin/libsvm 在使用libsvm之前，请阅读COPYRIGHT文件。

目录
=================

- 快速开始
- 安装和数据格式
- 'svm-train'用法
- `svm-predict'用法
- `svm-scale'用法
- 实用技巧
- 例子
- 预计算的内核
- 库的使用
- Java版本
- 构建Windows二进制文件
- 附加工具：子采样，参数选择，格式检查等。
- MATLAB/OCTAVE接口
- Python接口
- 附加信息

快速开始
===========

如果您对SVM不熟悉，并且数据量不大，请转到`tools'目录并在安装后使用easy.py。它的确如此一切都自动 -- 从数据缩放到参数选择。

用法：easy.py training_file [testing_file]

有关参数选择的更多信息可以在`tools/README'中找到。

安装和数据格式
============================

在Unix系统上，输入`make'来构建`svm-train'和`svm-predict'程式。运行它们而不带任何参数来显示它们的用法。

在其他系统上，请查阅`Makefile'来构建它们（例如，参见'Building Windows binaries'）或者使用预先建立的文件二进制文件（Windows二进制文件位于`windows'目录中）。

训练和测试数据文件的格式是：

<label> <index1>:<value1> <index2>:<value2> ...
.
.
.

每行包含一个实例，并以'\n'字符结尾。对于分类，<label>是指示类标签的整数（支持多类）。对于回归，<label>是目标值可以是任何实数。对于一类SVM，它不被使用所以可以是任何数字。这对<index>:<value>给出了一个特性（属性）值：<index>是一个从1开始并且<value>的整数是一个真实的数字。唯一的例外是预先计算的内核，其中<index>从0开始;请参阅预先计算的内核部分。指数必须按照升序（ASCENDING）排列。仅使用测试文件中的标签来计算准确度或错误。如果他们不明，只需填写与任何数字的第一列。

包中包含的样本分类数据是`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-train'会发出警告信息：`Warning: training data in only one class. See README for details,'(警告：只能在一个类里训练数据。 有关详细信息，请参阅README)。这意味着训练数据非常不平衡。 训练数据中的标签在测试时直接返回。

这个软件包还有其他一些有用的程序。

svm-scale:

	这是一个缩放输入数据文件的工具。

svm-toy:

	这是一个简单的图形界面，显示了SVM如何在平面中分离数据。 您可以单击窗口绘制数据点。 使用"change"按钮选择1,2,3类（即最多支持三个类），"load"按钮从文件加载数据，"save"按钮将数据保存到文件，"run"按钮来获得SVM模型，并通过"clear"按钮清除窗口。

	您可以在窗口底部输入选项，选项的语法与`svm-train'相同。

	请注意，"load"和"save"在分类和回归情况下均考虑密集的数据格式。对于分类，每个数据点在[0,1）中有一个标签（颜色）必须是1,2或3以及两个属性（x轴和y轴值）。对于回归，每个数据点在[0，1）中有一个目标值（y轴）和一个属性（x轴值）。

	在相应的目录中输入`make'来构建它们。

	你需要Qt库来构建Qt版本。
	（可从http://www.trolltech.com获得）
	
	您需要GTK+库来构建GTK版本。
	（可从http://www.gtk.org获得）

	预建的Windows二进制文件位于`windows'目录中。 我们在64位机器上使用Visual C++。

'svm-train'用法
=================

用法: svm-train [options] training_set_file [model_file]
options:
-s svm_type : 设置SVM的类型（默认值为0）
	0 -- C-SVC		（多级分类）
	1 -- nu-SVC		（多级分类）
	2 -- one-class SVM	
	3 -- epsilon-SVR	（回归）
	4 -- nu-SVR		（回归）
-t kernel_type : 设置内核函数的类型（默认2）
	0 -- 线性（linear）: u'*v
	1 -- 多项式（polynomial）: (gamma*u'*v + coef0)^degree
	2 -- 径向基函数（radial basis function）: exp(-gamma*|u-v|^2)
	3 -- S状弯曲（sigmoid）: tanh(gamma*u'*v + coef0)
	4 -- 预计算内核(training_set_file中的内核值)
-d 角度 : 内核函数的设定角度（默认值3）
-g gamma : 在内核函数中设置gamma (默认 1/num_features)
-r coef0 : 在内核函数中设置coef0 (默认 0)
-c cost : 设置C-SVC的参数C，epsilon-SVR和nu-SVR（默认值为1）
-n nu : 设置nu-SVC，one-class SVM和nu-SVR的参数nu（默认值为0.5）
-p epsilon : 设置epsilon-SVR的损失函数中的epsilon（默认值为0.1）
-m cachesize : 以MB为单位设置缓存大小（默认值为100）
-e epsilon : 设置终止标准的容差（默认值为0.001）
-h shrinking : 是否使用缩小的启发式，0或1（默认值1）
-b probability_estimates : 是否为概率估计值训练SVC或SVR模型，0或1（默认值为0）
-wi weight : 对于C-SVC，将类别i的参数C设置为weight*C（默认值为1）
-v n: n倍交叉验证模式
-q : 安静模式（无输出）

-g选项中的k表示输入数据中的属性数量。

选项-v将数据随机分成n个部分，并计算交叉验证准确度/平均平方误差。

有关输出的含义，请参阅libsvm FAQ。

`svm-predict' 用法
===================

用法: svm-predict [options] test_file model_file output_file
options:
-b probability_estimates: 是否预测概率估计值，0或1（默认为0）; 对于one-class SVM，仅支持0

model_file 是由svm-train生成的模型文件。
test_file is 是您想要预测的测试数据。
svm-predict 将在 output_file 中产生输出。

`svm-scale' 用法
=================

用法: svm-scale [options] data_filename
options:
-l lower : x缩放下限（默认-1）
-u upper : x缩放上限（默认+1）
-y y_lower y_upper : y缩放限制（默认：y不缩放）
-s save_filename : 将缩放参数保存到save_filename
-r restore_filename : 从restore_filename恢复缩放参数

有关示例，请参阅此文件中的'例子'。

实用技巧
=====================

* 扩展您的数据。 例如，将每个属性缩放为[0,1]或[-1,+1]。
* 对于C-SVC，请考虑在工具目录中使用模型选择工具。
* nu-SVC/one-class-SVM/nu-SVR中的nu接近训练错误和支持向量的比例。
* 如果用于分类的数据不平衡（例如，许多正数和负数），尝试使用不同的-wi的来设置参数C（请参见下面的示例）。
* 指定较大的缓存大小（即较大的-m）以解决大问题。

例子
========

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

将训练数据的每个特征缩放到[-1,1]中。 缩放因子存储在文件范围内，然后用于缩放测试数据。

> 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回归。

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

通过设置1类为10 = 1 * 10，-2类为50 = 5 * 10，4类为20 = 2 * 10，来训练一个分类器。

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

Do five-fold cross validation for the classifier using
the parameters C = 100 and gamma = 0.1
使用参数C = 100和gamma = 0.1对分类器进行5倍交叉验证

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

获得具有概率信息的模型并用概率估计预测测试数据

预计算的内核 
===================

用户可以预计算内核值并将其输入为训练和测试文件。然后libsvm不需要原始的训练/测试集。

假设有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必须是的"i"。在测试中，?可以是任何值。

所有内核值（包括ZERO）都必须明确提供。训练/测试文件的任何置换或随机子集也是有效的（请参见下面的示例）。

注意：格式与之前在libsvmtools中发布的预计算的内核包略有不同。

例子:

	假设原始训练数据有三个四特征实例，测试数据有一个实例：

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

	15  1:1     3:1

	如果使用线性（linear）内核，我们有以下新的训练/测试集：

	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]

库的使用
=============

这些函数和结构在头文件`svm.h'中声明。 您需要在C/C++源文件中#include "svm.h"，并将其与`svm.cpp'链接。 你可以看到`svm-train.c'和`svm-predict.c'来显示如何使用它们的例子。 在svm.h中，我们定义LIBSVM_VERSION并声明`extern int libsvm_version; '，所以你可以检查版本号。

在分类测试数据之前，您需要使用训练数据构建SVM模型（`svm_model'）。 模型也可以保存在文件中供以后使用。 一旦SVM模型可用，您可以使用它来分类新数据。

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

    该函数根据给定的训练数据和参数构造并返回一个SVM模型。

    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,?)

    其中(index,value)存储在`svm_node'结构体中:

	struct svm_node
	{
		int index;
		double value;
	};

    index = -1表示一个向量的结束。注意，索引必须按升序（ASCENDING）排列。
 
    svm_parameter结构体详情，SVM模型的参数：

	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: training_set_file中的内核值

    cache_size 是内核缓存的大小，以MB为单位。
    C 是违反约束的成本。 
    eps 是停止标准。（我们通常在nu-SVC中使用0.00001，其他值为0.001）。 
    nu 是nu-SVM，nu-SVR和one-class-SVM中的参数。 
    p 是epsilon-SVM回归的epsilon-insensitive损失函数中的epsilon。shrinking = 1意味着在收缩; 否则为0。probability = 1表示具有概率信息的模型; 否则为0。

    nr_weight，weight_label和weight用于更改某些类的值（如果某个类的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()。

    svm_model结构体存储从训练过程中获得的模型。
    不建议直接访问此结构体中的条目。
    程序员应该使用接口函数来获取值。

	struct svm_model
	{
		struct svm_parameter param;	/* parameter */
		int nr_class;		/* number of classes, = 2 in regression/one class svm */
		int l;			/* total #SV */
		struct svm_node **SV;		/* SVs (SV[l]) */
		double **sv_coef;	/* coefficients for SVs in decision functions (sv_coef[k-1][l]) */
		double *rho;		/* constants in decision functions (rho[k*(k-1)/2]) */
		double *probA;		/* pairwise probability information */
		double *probB;
		int *sv_indices;        /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */

		/* for classification only */

		int *label;		/* label of each class (label[k]) */
		int *nSV;		/* number of SVs for each class (nSV[k]) */
					/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
		/* XXX */
		int free_sv;		/* 1 if svm_model is created by svm_load_model*/
					/* 0 if svm_model is created by svm_train */
	};

    param 描述了用于获取模型的参数。

    nr_class 是类的数量。 回归和one-class SVM分别为2。

    l is the number of support vectors. SV and sv_coef are support
    vectors and the corresponding coefficients, respectively. Assume there are
    k classes. For data in class j, the corresponding sv_coef includes (k-1) y*alpha vectors,
    where alpha's are solutions of the following two class problems:
    1 vs j, 2 vs j, ..., j-1 vs j, j vs j+1, j vs j+2, ..., j vs k
    and y=1 for the first j-1 vectors, while y=-1 for the remaining k-j 
    vectors. For example, if there are 4 classes, sv_coef and SV are like:

    l 是支持向量的数量。 SV和sv_coef分别是支持向量和相应的系数。 假设有k个类。 对于类j中的数据，相应的sv_coef包含(k-1) y*alpha向量，其中alpha是以下两个类问题的解：1 vs j, 2 vs j, ..., j-1 vs j, j vs j+1, j vs j+2, ..., j vs k。前j-1个向量，y = 1，后k-j个向量，y=-1。例如，如果有4个类，sv_coef和SV就是这样：

        +-+-+-+--------------------+
        |1|1|1|                    |
        |v|v|v|  SVs from class 1  |
        |2|3|4|                    |
        +-+-+-+--------------------+
        |1|2|2|                    |
        |v|v|v|  SVs from class 2  |
        |2|3|4|                    |
        +-+-+-+--------------------+
        |1|2|3|                    |
        |v|v|v|  SVs from class 3  |
        |3|3|4|                    |
        +-+-+-+--------------------+
        |1|2|3|                    |
        |v|v|v|  SVs from class 4  |
        |4|4|4|                    |
        +-+-+-+--------------------+

    有关将值分配给sv_coef的示例，请参阅svm_train()。

    rho 是偏差项(-b)。 probA和probB是概率输出中使用的参数。 如果有k个类别，则存在k*(k-1)/2个二元问题以及rho，probA和probB值。 它们按照二元问题的顺序排列：
    1 vs 2, 1 vs 3, ..., 1 vs k, 2 vs 3, ..., 2 vs k, ..., k-1 vs k.

    sv_indices[0,...,nSV-1]是[1,...,num_traning_data]中的值，用于指示训练集中的支持向量。

    free_sv is a flag used to determine whether the space of SV should 
    be released in free_model_content(struct svm_model*) and 
    free_and_destroy_model(struct svm_model**). If the model is
    generated by svm_train(), then SV points to data in svm_problem
    and should not be removed. For example, free_sv is 0 if svm_model
    is created by svm_train, but is 1 if created by svm_load_model.

    label 在训练数据中包含的标签。

    nSV 是每个类中支持向量的数量。

    free_sv 是一个标志，用于确定是否应该在free_model_content(struct svm_model*)和free_and_destroy_model(struct svm_model**)中释放SV的空间。 如果模型由svm_train()生成，则SV指向svm_problem中的数据，不应删除。 例如，如果svm_train创建svm_model，则free_sv为0，如果由svm_load_model创建，则free_sv为1。

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

    该函数对给定model的测试向量x进行分类或回归。

    对于分类模型，返回预测的x类。
    对于回归模型，返回使用model计算的x的函数值。对于单类模型，返回+1或-1。

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

    该功能进行交叉验证。数据分为nr_fold倍数。在给定的参数下，依次使用来自训练剩余的模型验证每个倍数。 验证过程中的预测标签（所有问题的实例）存储在target数组中。

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

- 函数: int svm_get_svm_type(const struct svm_model *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数组中。 对于回归和单类模型，标签不变。

- 函数: void svm_get_sv_indices(const struct svm_model *model, int *sv_indices)

    该函数将支持向量的索引输出到sv_indices数组中。
    sv_indices的大小是支持向量的数量，可以通过调用svm_get_nr_sv来获得。
    每个sv_indices[i]在[1, ..., num_traning_data]的范围内。

- 函数: int svm_get_nr_sv(const struct svm_model *model) 

    该函数返回支持向量的数量。

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

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

    如果该模型不适用于svr或不包含所需的信息，则返回0。

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

    该函数在给定model的情况下给出测试向量x上的决策值，并返回预测标签（分类）或函数值（回归）。

    对于具有nr_class类的分类模型，此函数在数组dec_values中给出nr_class*(nr_class-1)/2个决策值，其中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[nr_class-1]，其中label可以从函数svm_get_labels中获得。 返回的值是x的预测类。请注意，当nr_class = 1时，此函数不会给出任何决策值。

    对于回归模型，dec_values[0]和返回值都是使用model计算的x的函数值。对于one-class模型，dec_values[0]是x的决策值，而返回值是+1/-1。

- 函数: double svm_predict_probability(const struct svm_model *model, 
	    const struct svm_node *x, double* prob_estimates);
    
    该函数对给定具有概率信息的model的测试向量x进行分类或回归。

    对于具有概率信息的分类模型，该函数在数组prob_estimates中给出nr_class概率估计。 nr_class可以从函数svm_get_nr_class中获得。返回概率最高的类。对于回归/one-class SVM，数组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);

    该函数检查model是否包含进行概率估计所需的信息。如果是，则返回+1。否则，返回0。 在调用svm_get_svr_probability和svm_predict_probability之前，应调用此函数。

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

    该功能将model保存到文件中;成功返回0，如果发生错误则返回-1。

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

    该函数返回一个指向从文件中读取的模型的指针，如果模型不能被加载，则返回一个空指针。

- 函数: void svm_free_model_content(struct svm_model *model_ptr);

    该函数释放模型结构中条目使用的内存。

- 函数: void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);

    该函数释放模型使用的内存并销毁模型结构。它相当于svm_destroy_model，它在版本3.0之后弃用。

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

    该函数释放参数集所使用的内存。

- 函数: void svm_set_print_string_function(void (*print_func)(const char *));

    用户可以通过函数指定其输出格式。 使用
    	svm_set_print_string_function(NULL);
    默认打印到标准输出。

Java版本
============

预编译的java类档案`libsvm.jar'及其源文件位于java目录中。 要运行程序，请使用

java -classpath libsvm.jar svm_train <arguments>
java -classpath libsvm.jar svm_predict <arguments>
java -classpath libsvm.jar svm_toy
java -classpath libsvm.jar svm_scale <arguments>

请注意，您需要Java 1.5（5.0）或更高版本才能运行它。

您可能需要将Java运行时库（如classes.zip）添加到类路径中。
您可能需要增加最大Java堆大小。

库使用情况与C版本类似。 这些函数可用：

public class svm {
	public static final int LIBSVM_VERSION=322; 
	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 void svm_get_sv_indices(svm_model model, int[] indices);
	public static int svm_get_nr_sv(svm_model model);
	public static double svm_get_svr_probability(svm_model model);
	public static double 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);
	public static void svm_set_print_string_function(svm_print_interface print_func);
}

该库位于"libsvm"包中。
请注意，在Java版本中，svm_node[]不以index = -1的节点结束。

用户可以通过指定他们的输出格式

	your_print_func = new svm_print_interface()
	{ 
		public void print(String s)
		{
			// your own format
		}
	};
	svm.svm_set_print_string_function(your_print_func);

构建Windows二进制文件
=========================

Windows二进制文件在`windows'目录中可用。 要通过Visual C++重新构建它们，请使用以下步骤：

1. 打开DOS命令框（或Visual Studio命令提示符）并切换到libsvm目录。如果VC++的环境变量尚未设置，请键入

""C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\amd64\vcvars64.bat""

您可能需要根据VC++的版本或安装位置来修改上述命令。

2. 请键入

nmake -f Makefile.win clean all

3.（可选）要构建共享库libsvm.dll，请键入

nmake -f Makefile.win lib

4.（可选）要构建32位Windows二进制文件，您必须
	(1) 安装 "C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat" 而不是 vcvars64.bat
	(2) 修改Makefile.win中的CFLAGS值，由/D _WIN64 改为 /D _WIN32
	
另一种方法是从Visual C++环境构建它们。 请参阅libsvm常见问题中的详细信息。

- 附加工具：子采样，参数选择，格式检查等。
============================================================================

请参阅工具目录中的README文件。

MATLAB/OCTAVE接口
=======================

请检查`matlab'目录中的README文件。

Python接口
================

请参阅python目录中的README文件。

附加信息
======================

If you find LIBSVM helpful, please cite it as

Chih-Chung Chang and Chih-Jen Lin, LIBSVM : a library for support
vector machines. ACM Transactions on Intelligent Systems and
Technology, 2:27:1--27:27, 2011. Software available at
http://www.csie.ntu.edu.tw/~cjlin/libsvm

LIBSVM implementation document is available at
http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf

For any questions and comments, please email cjlin@csie.ntu.edu.tw

Acknowledgments:
This work was supported in part by the National Science 
Council of Taiwan via the grant NSC 89-2213-E-002-013.
The authors thank their group members and users
for many helpful discussions and comments. They are listed in
http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements