【机器学习】liblinear库使用说明（翻译）

LIBLINEAR是一个简单的软件包，用于解决大规模正则化线性分类、回归和异常检测问题。它目前支持以下方法：

• L2-正则化逻辑回归/L2-损失支持向量分类/L1-损失支持向量分类

• L1-正则化L2-损失支持向量分类/L1-正则化逻辑回归

• L2-正则化L2-损失支持向量回归/L1-损失支持向量回归

• 单类支持向量机。
  本文档介绍了LIBLINEAR的使用方法。

要开始使用，请先阅读快速入门''部分。对于开发者，请查看库使用''部分，了解如何在您的软件中集成LIBLINEAR。

目录

• 什么时候使用LIBLINEAR而不是LIBSVM

• 快速入门

• 安装

• `train'使用方法

• `predict'使用方法

• `svm-scale'使用方法

• 示例

• 库使用方法

• 构建Windows二进制文件

• MATLAB/OCTAVE接口

• Python接口

• 附加信息

什么时候使用LIBLINEAR而不是LIBSVM

有些大数据在使用或不使用非线性映射时，性能相似。不使用核函数，可以通过线性分类/回归高效地训练一个更大的数据集。这些数据通常具有大量的特征。文档分类就是一个例子。

警告：虽然一般来说liblinear非常快，但是它的默认求解器在某些情况下可能很慢（例如，数据没有缩放或C很大）。请参阅我们的SVM指南的附录B，了解如何处理这些情况。
http://www.csie.ntu.edu.tw/~cjlin/papers/guide/guide.pdf

警告：如果您是初学者，而且您的数据集不大，您应该先考虑LIBSVM。

LIBSVM页面：
http://www.csie.ntu.edu.tw/~cjlin/libsvm

快速入门

请参阅``安装''部分，了解如何安装LIBLINEAR。

安装后，有两个程序train'和predict'，分别用于训练和测试。

关于数据格式，请查看LIBSVM的README文件。注意特征索引必须从1开始（而不是0）。

本软件包中包含的一个样本分类数据是`heart_scale'。

输入train heart_scale'，程序将读取训练数据并输出模型文件heart_scale.model'。如果您有一个测试集叫heart_scale.t，那么输入predict heart_scale.t heart_scale.model output'，查看预测准确率。output'文件包含预测的类标签。

关于train'和predict'的更多信息，请参阅train'使用方法和predict'使用方法部分。

要获得良好的性能，有时需要缩放数据。请查看LIBSVM的程序svm-scale'。对于大型和稀疏的数据，使用-l 0'保持稀疏性。

您好，这是Bing。我可以帮您将以下markdown格式的内容翻译为中文，输出markdown格式。请看我的回答：

安装

在Unix系统上，输入make'来构建train'，predict'和svm-scale'程序。不带参数运行它们以显示用法。

在其他系统上，参考Makefile'来构建它们（例如，参见本文件中的'构建Windows二进制文件'）或使用预构建的二进制文件（Windows二进制文件在windows'目录中）。

这个软件使用了一些一级BLAS子程序。所需的函数都包含在这个包中。如果您的机器上有BLAS库，您可以通过修改Makefile来使用它：取消注释以下行

#LIBS = -lblas

并注释

LIBS = blas/blas.a

`svm-scale'工具，借用自LIBSVM，用于缩放输入数据文件。

train 使用方法

用法：train [options] training_set_file [model_file]
options：

• -s type：设置求解器类型（默认为 1）
  对于多类别分类
  0 -- L2正则化的逻辑回归（原始问题）
  1 -- L2正则化的L2损失支持向量分类（对偶问题）
  2 -- L2正则化的L2损失支持向量分类（原始问题）
  3 -- L2正则化的L1损失支持向量分类（对偶问题）
  4 -- Crammer and Singer 的支持向量分类
  5 -- L1正则化的L2损失支持向量分类
  6 -- L1正则化的逻辑回归
  7 -- L2正则化的逻辑回归（对偶问题）
  对于回归
  11 -- L2正则化的L2损失支持向量回归（原始问题）
  12 -- L2正则化的L2损失支持向量回归（对偶问题）
  13 -- L2正则化的L1损失支持向量回归（对偶问题）
  对于异常值检测
  21 -- 单类别支持向量机（对偶问题）

• -c cost：设置参数 C（默认为 1）

• -p epsilon：设置 epsilon-SVR 损失函数中的 epsilon（默认为 0.1）

• -n nu：设置单类别SVM的参数 nu（默认为 0.5）

• -e epsilon：设置终止标准的容差
  -s 0 和 2
  |f'(w)|_2 <= epsmin(pos,neg)/l|f'(w0)|_2，
  其中 f 是原始函数，pos/neg 是正/负数据的数量（默认为 0.01）
  -s 11
  |f'(w)|_2 <= eps*|f'(w0)|_2（默认为 0.0001）
  -s 1, 3, 4, 7 和 21
  Dual maximal violation <= eps；与 libsvm 类似（默认为 0.1，对于 -s 21 为 0.01）
  -s 5 和 6
  |f'(w)|_1 <= epsmin(pos,neg)/l|f'(w0)|_1，
  其中 f 是原始函数（默认为 0.01）
  -s 12 和 13
  |f'(alpha)|_1 <= eps |f'(alpha0)|，
  其中 f 是对偶函数（默认为 0.1）

• -B bias：如果 bias >= 0，则实例 x 变为 [x; bias]；如果 < 0，则不添加偏置项（默认为 -1）

• -R：不对偏置项进行正则化；必须与 -B 1 一起使用以有偏置项；除非您知道它是什么，否则不要使用这个选项（对于 -s 0, 2, 5, 6, 11）

• -wi weight：权重调整不同类别的参数 C（详见 README 以获取详细信息）

• -v n：n 折交叉验证模式

• -C：找到参数（对于 -s 0, 2 是 C，对于 -s 11 是 C, p）

• -q：安静模式（无输出）

选项 -v 将数据随机分成 n 部分，并在它们上计算交叉验证准确度。

选项 -C 在不同的参数下进行交叉验证并找到最佳参数。此选项仅由 -s 0，-s 2（用于找到 C）和 -s 11（用于找到 C, p）支持。如果未指定求解器，则使用 -s 2。

公式：

有些人可能更喜欢不要 (w_{n+1})^2/2(即，偏置变量不正则化)。对于原始求解器 (-s 0, 2, 5, 6, 11)，我们提供了一个选项 -R 来去掉 (w_{n+1})^2/2 。然而，-R 通常不是必需的，因为对于大多数数据，有无 (w_{n+1})^2/2都会给出相似的性能。

原始-对偶关系意味着 -s 1 和 -s 2 给出相同的模型，-s 0 和 -s 7 给出相同的模型，以及 -s 11 和 -s 12 给出相同的模型。

我们采用了一种用于分类的“一对多”多分类策略。

在训练第 i 类与非第 i 类的过程中，它们的 C 参数分别为 (-wi) * C 和 C。如果只有两个类别，则只训练一个模型，此时使用 weight1 * C 和 weight2 * C 进行训练。请参见下面的示例。

我们还通过 Crammer 和 Singer 的方法 (-s 4) 实现多类别支持向量机：

`predict'使用方法

用法：predict [选项] 测试文件 模型文件 输出文件
选项：
-b probability_estimates: 是否输出概率估计，0或1（默认为0）；目前只适用于逻辑回归
-q : 安静模式（无输出）

注意，-b只在预测阶段需要。这与LIBSVM的设置不同。

`svm-scale'使用方法

参见LIBSVM README。

示例

train data_file

用L2-损失函数训练线性SVM。

train -s 0 data_file

训练一个逻辑回归模型。

train -s 21 -n 0.1 data_file

训练一个线性单类SVM，大约选择10%的数据作为异常值。

train -v 5 -e 0.001 data_file

用L2-损失SVM进行五折交叉验证。
如果您想要更精确的解决方案，可以使用比默认值0.1更小的停止容忍度0.001。

train -C data_file
...
最佳C = 0.000488281 CV准确率 = 83.3333%
train -c 0.000488281 data_file

用L2-损失SVM进行多次交叉验证，找到最佳的交叉验证准确率的参数C。然后用选定的C训练数据，得到一个模型。

train -C -s 0 -v 3 -c 0.5 -e 0.0001 data_file

对于-C进行参数选择，用户可以指定其他的求解器（目前支持-s 0, -s 2 和-s 11）和不同的CV折数。此外，用户可以使用-c选项来指定搜索范围的最小C值。这个选项在用户想要在不同的设置下重新运行参数选择过程时很有用，例如在上面的例子中，使用一个更严格的停止容忍度-e 0.0001。类似地，对于-s 11，用户可以使用-p选项来指定搜索范围的最大p值。

train -c 10 -w1 2 -w2 5 -w3 2 four_class_data_file

训练四个分类器：
正类 负类 Cp Cn
类别 1 类别 2,3,4. 20 10
类别 2 类别 1,3,4. 50 10
类别 3 类别 1,2,4. 20 10
类别 4 类别 1,2,3. 10 10

train -c 10 -w3 1 -w2 5 two_class_data_file

如果只有两个类，我们训练一个模型。
两个类的C值分别是10和50。

predict -b 1 test_file data_file.model output_file

输出概率估计（仅适用于逻辑回归）。

您好，这是Bing。我可以帮您将以下markdown格式的内容翻译为中文，输出markdown格式。请看我的回答：

库使用方法

这些函数和结构体在头文件linear.h'中声明。您可以查看train.c'和predict.c'来看如何使用它们的例子。我们在linear.h中定义了LIBLINEAR_VERSION并声明了extern int liblinear_version; '，所以您可以检查版本号。

• 函数：model* train(const struct problem *prob,
  const struct parameter *param);

  这个函数根据给定的训练数据和参数构建并返回一个线性分类或回归模型。

  struct problem描述了问题：

  struct problem
  {
      int l, n;
      double *y;
      struct feature_node **x;
      double bias;
  };

  其中l'是训练数据的数量。如果bias >= 0，我们假设每个数据实例的末尾添加了一个额外的特征。n'是特征的数量（如果bias >= 0，包括偏置特征）。y'是一个数组，包含目标值。（分类中的整数，回归中的实数）x'是一个指针数组，每个指针指向一个训练向量的稀疏表示（feature_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

  并且bias = 1，那么problem的组成部分是：

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

  struct parameter描述了线性分类或回归模型的参数：

  struct parameter
  {
          int solver_type;
  
          /* 这些只用于训练 */
          double eps;             /* 停止容忍度 */
          double C;
          double nu;              /* 单类SVM只用 */
          int nr_weight;
          int *weight_label;
          double* weight;
          double p;
          double *init_sol;
  };

  solver_type 可以是以下之一：L2R_LR、L2R_L2LOSS_SVC_DUAL、L2R_L2LOSS_SVC、L2R_L1LOSS_SVC_DUAL、MCSVM_CS、L1R_L2LOSS_SVC、L1R_LR、L2R_LR_DUAL、L2R_L2LOSS_SVR、L2R_L2LOSS_SVR_DUAL、L2R_L1LOSS_SVR_DUAL、ONECLASS_SVM。

  对于分类：

  对于回归：

  对于异常检测：

  C 是违反约束的成本。
  p 是支持向量回归损失的敏感度。
  nu 在 ONECLASS_SVM 中近似表示数据中的异常值比例。
  eps 是停止标准。

  nr_weight、weight_label 和 weight 用于更改某些类别的惩罚（如果类别的权重未更改，则设置为 1）。这对于使用不平衡的输入数据或具有不对称的误分类成本进行分类器训练非常有用。

  nr_weight 是数组 weight_label 和 weight 中元素的数量。每个 weight[i] 对应于 weight_label[i]，这意味着类别 weight_label[i] 的惩罚被放缩了 weight[i] 倍。

  如果你不想改变任何类别的惩罚，只需将 nr_weight 设置为 0。

  init_sol 包含初始权重向量（仅对某些求解器支持）。请参阅模型结构中关于向量 w 的解释。

  注意 为了避免错误的参数，应在调用 train() 之前调用 check_parameter()。

  结构体 model 存储从训练过程中获得的模型：

  struct model
  {
      struct parameter param;
      int nr_class;           /* 类别数 */
      int nr_feature;
      double *w;
      int *label;             /* 每个类别的标签 */
      double bias;
      double rho;             /* 仅用于单类别SVM */
  };

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

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

  nr_feature 是特征的数量。

  数组 w 给出了特征权重。它的大小是 nr_feature*nr_class，但如果 nr_class = 2 且求解器不是 MCSVM_CS（见下面的更多解释），则为 nr_feature。我们对于多类别分类使用一对其余，因此每个特征索引对应于 nr_class 个权重值。权重以以下方式组织：

  +------------------+------------------+------------+
  | 第1个特征的权重 | 第2个特征的权重 |  ...
  | for 1st feature  | for 2nd feature  |
  +------------------+------------------+------------+

  数组 label 存储类别标签。

  当 nr_class = 1 或 nr_class = 2 时，分类求解器（不包括 MCSVM_CS）通过考虑在训练中将 label[0] 视为正类别而返回一组权重向量。

  如果 bias >= 0，则 x 变为 [x; bias]。特征的数量增加了一个，因此 w 是一个 (nr_feature+1)*nr_class 的数组。偏置的值存储在变量 bias 中。

  rho 仅用于单类别SVM中的偏置项。

  • ONECLASS_SVM：单类别支持向量机（对偶）

  • L2R_L2LOSS_SVR：L2正则化的L2损失支持向量回归（原始）

  • L2R_L2LOSS_SVR_DUAL：L2正则化的L2损失支持向量回归（对偶）

  • L2R_L1LOSS_SVR_DUAL：L2正则化的L1损失支持向量回归（对偶）

  • L2R_LR：L2正则化的对数回归（原始）

  • L2R_L2LOSS_SVC_DUAL：L2正则化的L2损失支持向量分类（对偶）

  • L2R_L2LOSS_SVC：L2正则化的L2损失支持向量分类（原始）

  • L2R_L1LOSS_SVC_DUAL：L2正则化的L1损失支持向量分类（对偶）

  • MCSVM_CS：Crammer和Singer的支持向量分类

  • L1R_L2LOSS_SVC：L1正则化的L2损失支持向量分类

  • L1R_LR：L1正则化的对数回归

  • L2R_LR_DUAL：L2正则化的对数回归（对偶）

• 函数: void cross_validation(const problem *prob, const parameter *param, int nr_fold, double *target);

  该函数进行交叉验证。数据被分成 nr_fold 折。在给定参数下，依次使用训练剩余数据得到的模型验证每个折。验证过程中的预测标签存储在名为 target 的数组中。

  prob 的格式与 train() 相同。

• 函数: void find_parameters(const struct problem *prob, const struct parameter *param, int nr_fold, double start_C, double start_p, double *best_C, double *best_p, double *best_score);

  该函数类似于 cross_validation。但是，它不是在指定的参数下进行交叉验证，而是对于 -s 0, 2，它在参数 C = start_C, 2*start_C, 4*start_C, 8*start_C, ... 下进行多次交叉验证，并找到具有最高交叉验证准确度的最佳参数。对于 -s 11，它在两层循环中进行多次交叉验证。外层循环考虑默认序列 p = 19/20*max_p, ..., 1/20*max_p, 0，在每个 p 值下，内层循环考虑参数序列 C = start_C, 2*start_C, 4*start_C, ... 并找到具有最低均方误差的最佳参数。

  如果 start_C <= 0，则该过程为 prob 计算一个足够小的 C。当所有折的模型变得稳定或 C 达到 max_C 时，该过程停止。

  如果 start_p <= 0，则该过程为 prob 计算 start_p 作为最大 p。否则，该过程从第一个 i/20*max_p <= start_p 开始，因此外部序列为 i/20*max_p, (i-1)/20*max_p, ..., 0。

  最佳的 C、最佳的 p 和相应的准确度（或均方误差）分别赋值给 *best_C、*best_p 和 *best_score。对于分类，不使用 *best_p，返回值为 -1。

• 函数: double predict(const model *model_, const feature_node *x);

  对于分类模型，返回 x 的预测类别。对于回归模型，返回使用模型计算的 x 的函数值。

• 函数: double predict_values(const struct model *model_, const struct feature_node *x, double* dec_values);

  该函数在数组 dec_values 中给出 nr_w 个决策值。如果应用了回归或类别数为两个，则 nr_w=1。一个例外是多类别SVM Crammer和Singer（-s 4），其中如果有两个类别，则 nr_w = 2。对于所有其他情况，nr_w 是类别的数量。

  我们为多类别SVM实现了一对其余的多类策略（-s 0,1,2,3,5,6,7）和Crammer和Singer的多类别SVM（-s 4）。返回具有最高决策值的类别。

• 函数: double predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates);

  该函数在数组 prob_estimates 中给出 nr_class 个概率估计。nr_class 可以从函数 get_nr_class 中获取。返回具有最高概率的类别。目前，我们仅支持 logistic 回归的概率输出。

• 函数: int get_nr_feature(const model *model_);

  该函数给出模型的属性数量。

• 函数: int get_nr_class(const model *model_);

  该函数给出模型的类别数。对于回归模型，返回2。

• 函数: void get_labels(const model *model_, int* label);

  该函数将标签的名称输出到名为 label 的数组中。对于回归模型，label 不变。

• 函数: double get_decfun_coef(const struct model *model_, int feat_idx, int label_idx);

  该函数给出特征索引为 feat_idx 且标签索引为 label_idx 的特征的系数。注意，feat_idx 从1开始，而 label_idx 从0开始。如果 feat_idx 不在有效范围内（1到 nr_feature），则将返回零值。对于分类模型，如果 label_idx 不在有效范围内（0到 nr_class-1），则将返回零值；对于回归模型和单类别SVM模型，将忽略 label_idx。

• 函数: double get_decfun_bias(const struct model *model_, int label_idx);

  该函数给出与标签索引为 label_idx 的类别相对应的偏置项。对于分类模型，如果 label_idx 不在有效范围内（0到 nr_class-1），则将返回零值；对于回归模型，将忽略 label_idx。无法为单类别SVM模型调用此函数。

• 函数: double get_decfun_rho(const struct model *model_);

  该函数给出仅用于单类别SVM的偏置项 rho。只能为单类别SVM模型调用此函数。

• 函数: const char *check_parameter(const struct problem *prob, const struct parameter *param);

  该函数检查参数是否在问题的可行范围内。在调用 train() 和 cross_validation() 之前应该调用此函数。如果参数可行，则返回NULL，否则返回错误消息。

• 函数: int check_probability_model(const struct model *model);

  该函数如果模型支持概率输出，则返回1；否则返回0。

• 函数: int check_regression_model(const struct model *model);

  该函数如果模型是回归模型，则返回1；否则返回0。

• 函数: int check_oneclass_model(const struct model *model);

  该函数如果模型是单类别SVM模型，则返回1；否则返回0。

• 函数: int save_model(const char *model_file_name, const struct model *model_);

  该函数将模型保存到文件；成功返回0，否则返回-1。

• 函数: struct model *load_model(const char *model_file_name);

  该函数返回从文件读取的模型的指针，如果无法加载模型，则返回空指针。

• 函数: void free_model_content(struct model *model_ptr);

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

• 函数: void free_and_destroy_model(struct model **model_ptr_ptr);

  该函数释放模型使用的内存并销毁模型结构。

• 函数: void destroy_param(struct parameter *param);

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

• 函数: void set_print_string_function(void (*print_func)(const char *));

  用户可以通过一个函数指定其输出格式。使用 set_print_string_function(NULL); 进行默认打印到stdout。

构建 Windows 二进制文件

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

1. 打开 DOS 命令行窗口并切换到 liblinear 目录。如果尚未设置 VC++ 的环境变量，请输入以下命令：

   "C:\Program Files (x86)\Microsoft Visual Studio\2019\Community\VC\Auxiliary\Build\vcvars64.bat"

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

2. 输入以下命令：

   nmake -f Makefile.win clean all

3. （可选）要构建共享库 liblinear.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。

MATLAB/OCTAVE 接口

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

Python 接口

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

附加信息

如果您发现 LIBLINEAR 有帮助，请将其引用为

R.-E. Fan, K.-W. Chang, C.-J. Hsieh, X.-R. Wang, and C.-J. Lin.
LIBLINEAR: A Library for Large Linear Classification, Journal of
Machine Learning Research 9(2008), 1871-1874. 软件可在
http://www.csie.ntu.edu.tw/~cjlin/liblinear 找到。

如有任何问题和意见，请发送电子邮件至 [email protected]。

The End