libsvm-3.12中的README（二）

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

这些函数和结构在头文件 ‘svm.h’ 中已声明。你需要在你的 C/C++ 源文件中用  #include "svm.h"  然后用
‘svm.cpp’ 连接你的程序。你可以参见‘svm-train.c’和‘svm-predict.c’为例，它们展示了如何使用。
我们定义了  LIBSVM_VERSION 并在‘svm.h’中用‘extern int libsvm_version;’语句声明了，因此你可以检查你的版本号。
在你为测试数据分类之前，你需要用训练数据构建一个SVM模式（‘svm_model’）。一个模式也可以存储为一个文件为将来使用。一旦SVM模式建立并可用，你可以用它来分类新的数据。

 

- Function：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的数组）。

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

      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 表示这个向量的结束。注意 indices 必须是单调增的顺序。

      struct 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 classification

      NU_SVC:                   nu-SVM classification

      ONE_CLASS:               one-class-SVM

      EPSILON_SVR:            epsilon-SVM regression

      NU_SVR:                   nu-SVM regression

      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: kernel values in 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-不敏感损失函数中的epsilon 。

      shrinking = 1 意为 shrinking 被执行；否则  = 0。
      probability = 1 意为获得有概率信息的模式；否则  = 0 。

      nr_weight，weight_label，weight 用来改变一些类的惩罚值（如果一个类的权重没有改变，那么它被设定       为1）。这对于用不平衡的输入数据训练分类器或者惩罚非对称误分类是十分有用的。

      nr_weight 是 weight_label 和  weight 数组中的元素数。每一个 weight[i] 与 weight_label[i] 对应，       意为  weight_la bel[i] 类的惩罚用 weight[i] 来衡量。

      *注意* 因为 svm_model 包含指向 svm_problem 的指针，如果你仍在使用svm_train()产生的svm_model，       你可以不必释放svm_problem使用的内存。

      

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

      struct 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 *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 /

          

            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 是支持向量的数目。SV 和 sv_coef 是分别是支持向量和相关系数。
      假设有  k 类。对于 j 类中的数据，相应的 sv_coef 包括 (k-1) y*alpha 向量，

      alpha's 是解决下述二分问题的方法：

      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 。
      例如，如果有四类，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 类，有和  rho，probA，probB 的值一样的
       k*(k-1)/2  个二进制问题。它们按照二进制问题顺序排列：

      aligned in the order of binary problems:

      1 vs 2, 1 vs 3, ..., 1 vs k, 2 vs 3, ..., 2 vs k, ..., k-1 vs k.

      label 包含训练数据的 labels。

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

      free_sv 是一个用来确认 SV 的空间是否应该在 free_model_content(struct svm_model*)和
       free_and_destroy_model(struct svm_model**)被释放的标记。
      如果模式产生于svm_train()，那么 SV 指向 svm_problem  中的数据并且不应被删除。 
      例如，free_sv 在 svm_model 是由  svm_train 产生的情况下是0，由 svm_load_model产生的情况下是1 。