libsvm 是一款简单易用且高效的软件，适用于支持向量机（SVM）分类和回归任务。它可解决 C-SVM 分类、nu-SVM 分类、单类 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 训练文件 [测试文件]

有关参数选择的更多信息，请参阅 tools/README。

安装与数据格式

在 Unix 系统上，输入 make 即可构建 svm-train、svm-predict 和 svm-scale 程序。直接运行这些程序（不带参数）可查看它们的使用说明。

在其他系统上，请参考 Makefile 进行构建（例如，参见本文档中的“构建 Windows 二进制文件”部分），或使用预构建的二进制文件（Windows 二进制文件位于 windows 目录中）。

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

: : ... . . .

每行代表一个样本实例，并以 '\n' 字符结束。样本可以没有特征值（即一行为全零），但 列不能为空。对于训练集中的 ，有以下几种情况：

• 分类： 是表示类别标签的整数（支持多分类）。

• 回归： 是目标值，可以是任意实数。

• 单类 SVM： 无实际作用，可以是任意数值。

在测试集中， 仅用于计算准确率或误差。如果未知，可填写任意数值。对于单类 SVM，如果已知非离群点/离群点，测试文件中它们的标签必须为 +1/-1 以便进行评估。 列使用 C 标准库提供的 strtod() 函数读取。因此，数值上等效的 值将被视为相同（例如，+01e0 和 1 被视为同一类别）。

: 对表示一个特征（属性）值： 是从 1 开始的整数， 是实数。唯一的例外是预计算核函数，此时 从 0 开始；详见预计算核函数部分。特征索引必须按升序排列。

本软件包中包含一个示例分类数据文件 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”在分类和回归情况下均采用稠密数据格式。对于分类，每个数据点有一个标签（颜色），必须为 1、2 或 3，以及两个属性（x 轴和 y 轴值），取值范围在 [0,1) 之间。对于回归，每个数据点有一个目标值（y 轴）和一个属性（x 轴值），取值范围在 [0, 1) 之间。

在相应目录中输入 make 进行构建。

构建 Qt 版本需要 Qt 库。（可从 http://www.trolltech.com 获取）

构建 GTK 版本需要 GTK+ 库。（可从 http://www.gtk.org 获取）

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

svm-train 使用说明

用法：svm-train [选项] 训练集文件 [模型文件] 选项： -s svm_type : 设置 SVM 的类型（默认 0） 0 -- C-SVC （多类分类） 1 -- nu-SVC （多类分类） 2 -- 一类 SVM 3 -- epsilon-SVR （回归） 4 -- nu-SVR （回归） -t kernel_type : 设置核函数的类型（默认 2） 0 -- 线性：u'v 1 -- 多项式：(gammau'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/特征数量） -r coef0 : 设置核函数中的 coef0 参数（默认 0） -c cost : 设置 C-SVC、epsilon-SVR 和 nu-SVR 的参数 C（默认 1） -n nu : 设置 nu-SVC、一类 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 : 是否训练用于概率估计的模型，0 或 1（默认 0） -wi weight : 为 C-SVC 设置第 i 类的参数 C 为 weightC（默认 1） -v n: n 折交叉验证模式 -q : 安静模式（无输出）

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

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

svm-predict 使用说明

用法：svm-predict [选项] 测试文件 模型文件 输出文件 选项： -b probability_estimates: 是否预测概率估计值，0 或 1（默认 0）。

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

svm-scale 使用说明

用法：svm-scale [选项] 数据文件名 选项： -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，考虑使用 tools 目录下的模型选择工具。
• 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] 范围内。缩放因子存储在文件 range 中，随后用于缩放测试数据。

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

训练一个使用 RBF 核函数 exp(-0.5|u-v|²)、C=5 且停止容差为 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

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

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 对应的新训练样本格式：

0:i 1:K(xi,x1) ... L:K(xi,xL)

任意样本 x 对应的新测试样本格式：

0:? 1:K(x,x1) ... L:K(x,xL)

也就是说，在训练文件中，第一列必须是 xi 的 "ID"。在测试文件中，? 可以是任意值。

必须显式提供所有核函数值，包括零值。训练/测试文件的任何排列或随机子集也是有效的（参见下面的示例）。

注意：此格式与早期 libsvmtools 中发布的预计算核函数包略有不同。

示例：

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

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]

库的使用方法

这些函数和结构体在头文件 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 模型。

  struct svm_problem 描述了问题：

  struct svm_problem { int l; double *y; struct svm_node **x; };

  其中，l 是训练数据的数量，y 是一个包含它们目标值的数组（分类问题中为整数，回归问题中为实数）。x 是一个指针数组，每个指针指向一个训练向量的稀疏表示（svm_node 数组）。

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

  标签 属性1 属性2 属性3 属性4 属性5

  ---

  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 表示一个向量的结束。注意，索引必须按升序排列。

  struct svm_parameter 描述了 SVM 模型的参数：

  struct svm_parameter { int svm_type; int kernel_type; int degree; /* 用于多项式核函数 / double gamma; / 用于多项式、RBF、Sigmoid 核函数 / double coef0; / 用于多项式、Sigmoid 核函数 */

    /* 以下仅用于训练 */
    double cache_size; /* 以 MB 为单位 */
    double eps;	/* 停止准则 */
    double C;	/* 用于 C_SVC、EPSILON_SVR 和 NU_SVR */
    int nr_weight;		/* 用于 C_SVC */
    int *weight_label;	/* 用于 C_SVC */
    double* weight;		/* 用于 C_SVC */
    double nu;	/* 用于 NU_SVC、ONE_CLASS 和 NU_SVR */
    double p;	/* 用于 EPSILON_SVR */
    int shrinking;	/* 是否使用启发式收缩 */
    int probability; /* 是否进行概率估计 */
  

  };

  svm_type 可以是 C_SVC、NU_SVC、ONE_CLASS、EPSILON_SVR、NU_SVR 中的一种。

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

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

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

  cache_size 是核缓存的大小，以兆字节为单位。C 是约束违反的惩罚系数。eps 是停止准则（在 nu-SVC 中我们通常使用 0.00001，在其他情况下使用 0.001）。nu 是 nu-SVM、nu-SVR 和单类 SVM 中的参数。p 是 epsilon-SVM 回归中 epsilon 不敏感损失函数的 epsilon 值。shrinking = 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()。

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

  struct svm_model { struct svm_parameter param; /* 参数 / int nr_class; / 类别数量，在回归/单类 SVM 中为 2 / int l; / 支持向量总数 */ struct svm_node *SV; / 支持向量（SV[l]） */ double *sv_coef; / 决策函数中支持向量的系数（sv_coef[k-1][l]） / double rho; / 决策函数中的常数项（rho[k(k-1)/2]） */ double probA; / 成对概率信息 */ double *probB; double prob_density_marks; / 单类 SVM 的概率信息 */ int sv_indices; / sv_indices[0,...,nSV-1] 的值在 [1,...,num_traning_data] 范围内，表示训练集中的支持向量 */

    /* 仅用于分类 */
  
    int *label;		/* 每个类别的标签（label[k]） */
    int *nSV;		/* 每个类别的支持向量数量（nSV[k]） */
    			/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
    /* XXX */
    int free_sv;		/* 1 如果 svm_model 是由 svm_load_model 创建的 */
    			/* 0 如果 svm_model 是由 svm_train 创建的 */
  

  };

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

  nr_class 是分类模型的类别数量。它是一个非负整数，特殊情况为 0（根本没有训练数据）和 1（所有训练数据都属于一个类别）。对于回归和单类 SVM，nr_class = 2。

  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|  来自类别 1 的支持向量 |
    |2|3|4|                    |
    +-+-+-+--------------------+
    |1|2|2|                    |
    |v|v|v|  来自类别 2 的支持向量 |
    |2|3|4|                    |
    +-+-+-+--------------------+
    |1|2|3|                    |
    |v|v|v|  来自类别 3 的支持向量 |
    |3|3|4|                    |
    +-+-+-+--------------------+
    |1|2|3|                    |
    |v|v|v|  来自类别 4 的支持向量 |
    |4|4|4|                    |
    +-+-+-+--------------------+
  

  参见 svm_train() 以获取为 sv_coef 赋值的示例。

  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] 范围内，表示训练集中的支持向量。

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

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

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

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

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

  对于分类模型，返回 x 的预测类别。对于回归模型，返回使用模型计算出的 x 的函数值。对于单类模型，返回 +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);

  对于分类模型，该函数返回类别数量。对于回归或单类模型，返回 2。

• 函数：void svm_get_labels(const svm_model model, int label)

  对于分类模型，该函数将标签名称输出到 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 服从拉普拉斯分布 e^(-|z|/sigma)/(2sigma)。

  如果模型不是 SVR 模型或不包含所需信息，则返回 0。

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

  该函数使用给定的模型对测试向量 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] 和返回值都是使用模型计算出的 x 的函数值。对于单类模型，dec_values[0] 是 x 的决策值，而返回值是 +1/-1。

• 函数：double svm_predict_probability(const struct svm_model *model, const struct svm_node x, double prob_estimates);

  该函数使用带有概率信息的模型对测试向量 x 进行分类或回归。

  对于带有概率信息的分类模型，该函数在 prob_estimates 数组中给出 nr_class 个概率估计值。nr_class 可通过函数 svm_get_nr_class 获得。返回概率最高的类别。对于单类 SVM，prob_estimates 数组包含两个元素，分别为正常实例/异常值的概率；对于回归，该数组不变。对于单类 SVM 和回归，返回值与 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。应在调用 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_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); 可恢复默认的标准输出。

  请注意，此函数不是线程安全的。当多个线程加载或使用同一个动态库（例如 libsvm.so.4）时，它们实际上共享动态库的同一内存空间，这导致当它们调用此函数时，所有线程都会修改 svm.cpp 中的同一个静态函数指针 svm_print_string。

  例如，假设有线程 A 和 B。它们依次调用此函数，并传入各自线程本地的 print_func。之后，它们都调用 (*svm_print_string)(str) 一次。当最后一个线程（假设是 B）完成设置后，svm_print_string 被设置为 B.print_func。现在，如果线程 A 想要访问 svm_print_string，它实际上访问的是 B.print_func 而不是 A.print_func，这是不正确的，因为我们期望使用 A.print_func 的功能。

  即使 A.print_func 和 B.print_func 具有相同的功能，仍然存在风险。假设 svm_print_string 现在被设置为 B.print_func，并且 B 在完成工作后删除了 B.print_func。之后，线程 A 调用 svm_print_string，但它所指向的地址（即 B.print_func）已经被删除。这种无效的内存访问将导致程序崩溃。为了缓解此问题，在此示例中，您应确保 A.print_func 和 B.print_func 在线程完成工作后仍然有效。例如，在 Python 中，您可以将它们分配为全局变量。

Java 版本

预编译的 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=337; 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[] 数组不以索引为 -1 的节点结束。

用户可以通过以下方式指定自己的输出格式：

your_print_func = new svm_print_interface() { public void print(String s) { // 您自己的格式 } }; svm.svm_set_print_string_function(your_print_func);

但是，与 C 版本类似，此方法不是线程安全的。有关详细信息，请查看 C 版本中 svm_set_print_string_function() 的用法。

构建 Windows 二进制文件

Windows 二进制文件位于 windows 目录中。若要通过 Visual C++ 重新构建它们，请按照以下步骤操作：

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

"C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\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\2019\Community\VC\Auxiliary\Build\vcvars32.bat" 而非 vcvars64.bat (2) 修改 Makefile.win 中的 CFLAGS：将 /D _WIN64 改为 /D _WIN32

另一种方法是从 Visual C++ 环境中构建它们。详情请参见 libsvm FAQ。

• 附加工具：子采样、参数选择、格式检查等 ============================================================================

请参见 tools 目录中的 README 文件。

MATLAB/OCTAVE 接口

请查看 matlab 目录中的 README 文件。

Python 接口

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

附加信息

如果您认为 LIBSVM 有帮助，请按以下方式引用：

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 实现文档可在以下地址获取： http://www.csie.ntu.edu.tw/~cjlin/papers/libsvm.pdf

如有任何问题和意见，请发送电子邮件至 cjlin@csie.ntu.edu.tw

致谢： 本研究工作部分由台湾地区科学委员会通过 grant NSC 89-2213-E-002-013 资助。 作者感谢其团队成员和用户的许多有益讨论和意见。他们的名单列于 http://www.csie.ntu.edu.tw/~cjlin/libsvm/acknowledgements