Libsvm的一些说明帮助吧

欢迎关注我的博客晨凫追风,转载请注明出处http://blog.csdn.net/hit2015spring
hit2015spring

这是一篇翻译文章吧,主要是对libsvm里面所带的一些函数进行说明。
下载完libsvm的包,解压缩之后,主要就是一个readme文件,这个文件说明的了这个包该如何使用,还有一个Makefile文件,这个文件说明了libsvm源码里面各个程序之间的依赖关系,当然这里面需要的一些makefile文件的知识,见makefile文件的一些解读当然了忽略文件里面的一些编译选项,上面是授人渔的部分。接下来是授人鱼的部分

它主要可以编译出三个可执行文件,分别用于预测,训练,归一化,最主要的便是依赖一个文件svm.cpp这个文件,这个文件包含了svm里面训练,预测的方法,如果要自己调用svm的话,只要搞清楚svm.cpp这个文件里头的函数方法就ok了,svm-predict.c和svm-train.c这两个文件主要是提供两个例子供大家参考,是怎么调用svm.cpp的。当然svm.cpp这个文件的说明在readme里面已经说的比较明白了,下面就是readme的一些翻译说明。所以一开头就说了,我这篇文章主要是算一篇翻译文章吧:

接下来有用的部分主要是在库的调用的那一部分,其他的就是原文了

Libsvm is a simple, easy-to-use, and efficient software for SVM
classification and regression. It solves C-SVM classification, nu-SVM
classification, one-class-SVM, epsilon-SVM regression, and nu-SVM
regression. It also provides an automatic model selection tool for
C-SVM classification. This document explains the use of libsvm.

Libsvm is available at
http://www.csie.ntu.edu.tw/~cjlin/libsvm
Please read the COPYRIGHT file before using libsvm.

Table of Contents

  • Quick Start
  • Installation and Data Format
  • `svm-train’ Usage
  • `svm-predict’ Usage
  • `svm-scale’ Usage
  • Tips on Practical Use
  • Examples
  • Precomputed Kernels
  • Library Usage
  • Java Version
  • Building Windows Binaries
  • Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc.
  • MATLAB/OCTAVE Interface
  • Python Interface
  • Additional Information

Quick Start

If you are new to SVM and if the data is not large, please go to
`tools’ directory and use easy.py after installation. It does
everything automatic – from data scaling to parameter selection.

Usage: easy.py training_file [testing_file]

More information about parameter selection can be found in
`tools/README.’

Installation and Data Format

On Unix systems, type make' to build thesvm-train’ and `svm-predict’
programs. Run them without arguments to show the usages of them.

On other systems, consult Makefile' to build them (e.g., see
'Building Windows binaries' in this file) or use the pre-built
binaries (Windows binaries are in the directory
windows’).

The format of training and testing data file is:

Each line contains an instance and is ended by a ‘\n’ character. For
classification,

A sample classification data included in this package is
heart_scale'. To check if your data is in a correct form, use
tools/checkdata.py’ (details in `tools/README’).

Type svm-train heart_scale', and the program will read the training
data and output the model file
heart_scale.model’. If you have a test
set called heart_scale.t, then type svm-predict heart_scale.t
heart_scale.model output' to see the prediction accuracy. The
output’
file contains the predicted class labels.

For classification, if training data are in only one class (i.e., all
labels are the same), then svm-train' issues a warning message:
Warning: training data in only one class. See README for details,’
which means the training data is very unbalanced. The label in the
training data is directly returned when testing.

There are some other useful programs in this package.

svm-scale:

This is a tool for scaling input data file.

svm-toy:

This is a simple graphical interface which shows how SVM
separate data in a plane. You can click in the window to 
draw data points. Use "change" button to choose class 
1, 2 or 3 (i.e., up to three classes are supported), "load"
button to load data from a file, "save" button to save data to
a file, "run" button to obtain an SVM model, and "clear"
button to clear the window.

You can enter options in the bottom of the window, the syntax of
options is the same as `svm-train'.

Note that "load" and "save" consider dense data format both in
classification and the regression cases. For classification,
each data point has one label (the color) that must be 1, 2,
or 3 and two attributes (x-axis and y-axis values) in
[0,1). For regression, each data point has one target value
(y-axis) and one attribute (x-axis values) in [0, 1).

Type `make' in respective directories to build them.

You need Qt library to build the Qt version.
(available from http://www.trolltech.com)

You need GTK+ library to build the GTK version.
(available from http://www.gtk.org)

The pre-built Windows binaries are in the `windows'
directory. We use Visual C++ on a 64-bit machine.


这是一个简单的图形界面,显示SVM如何在平面中分离数据。
您可以在窗口中点击绘制数据点。使用“更改”按钮选择1,2或3类(即最多支持三个类),
“加载”按钮从文件加载数据,“保存”按钮将数据保存到文件中,“运行”按钮获取SVM模型,
并“清除”按钮来清除窗口。您可以在窗口底部输入选项,选项的语法与`svm-train'相同。
请注意,“加载”和“保存”在分类和回归情况下均考虑密集数据格式。对于分类,
每个数据点都有一个标签(颜色)必须为1,2或3,并且[0,1]中有两个属性(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’ Usage

Usage: svm-train [options] training_set_file [model_file]
options:
-s svm_type : set type of SVM (default 0)
0 – C-SVC (multi-class classification)
1 – nu-SVC (multi-class classification)
2 – one-class SVM
3 – epsilon-SVR (regression)
4 – nu-SVR (regression)
-t kernel_type : set type of kernel function (default 2)
0 – linear: u’*v
1 – polynomial: (gamma*u’*v + coef0)^degree
2 – radial basis function: exp(-gamma*|u-v|^2)
3 – sigmoid: tanh(gamma*u’*v + coef0)
4 – precomputed kernel (kernel values in training_set_file)
-d degree : set degree in kernel function (default 3)
-g gamma : set gamma in kernel function (default 1/num_features)
-r coef0 : set coef0 in kernel function (default 0)
-c cost : set the parameter C of C-SVC, epsilon-SVR, and nu-SVR (default 1)
-n nu : set the parameter nu of nu-SVC, one-class SVM, and nu-SVR (default 0.5)
-p epsilon : set the epsilon in loss function of epsilon-SVR (default 0.1)
-m cachesize : set cache memory size in MB (default 100)
-e epsilon : set tolerance of termination criterion (default 0.001)
-h shrinking : whether to use the shrinking heuristics, 0 or 1 (default 1)
-b probability_estimates : whether to train a SVC or SVR model for probability estimates, 0 or 1 (default 0)
-wi weight : set the parameter C of class i to weight*C, for C-SVC (default 1)
-v n: n-fold cross validation mode
-q : quiet mode (no outputs)

The k in the -g option means the number of attributes in the input data.

option -v randomly splits the data into n parts and calculates cross
validation accuracy/mean squared error on them.

See libsvm FAQ for the meaning of outputs.

`svm-predict’ Usage

Usage: svm-predict [options] test_file model_file output_file
options:
-b probability_estimates: whether to predict probability estimates, 0 or 1 (default 0); for one-class SVM only 0 is supported

model_file is the model file generated by svm-train.
test_file is the test data you want to predict.
svm-predict will produce output in the output_file.

`svm-scale’ Usage

Usage: svm-scale [options] data_filename
options:
-l lower : x scaling lower limit (default -1)
-u upper : x scaling upper limit (default +1)
-y y_lower y_upper : y scaling limits (default: no y scaling)
-s save_filename : save scaling parameters to save_filename
-r restore_filename : restore scaling parameters from restore_filename

See ‘Examples’ in this file for examples.

Tips on Practical Use

  • Scale your data. For example, scale each attribute to [0,1] or [-1,+1].
  • For C-SVC, consider using the model selection tool in the tools directory.
    对于C-SVC,请考虑在tools目录中使用模型选择工具。
  • nu in nu-SVC/one-class-SVM/nu-SVR approximates the fraction of training
    errors and support vectors.
  • If data for classification are unbalanced (e.g. many positive and
    few negative), try different penalty parameters C by -wi (see
    examples below).

    如果用于分类的数据不平衡(例如,许多正数和少量负数),请尝试使用-wi的不同惩罚参数C(参见下面的示例)。

  • Specify larger cache size (i.e., larger -m) for huge problems.
    为巨大的问题指定较大的缓存大小(即,较大的-m)

Examples

//归一化

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

Scale each feature of the training data to be in [-1,1]. Scaling
factors are stored in the file range and then used for scaling the
test data.

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

Train a classifier with RBF kernel exp(-0.5|u-v|^2), C=10, and
stopping tolerance 0.1.

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

Solve SVM regression with linear kernel u’v and epsilon=0.1
in the loss function.

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

Train a classifier with penalty 10 = 1 * 10 for class 1, penalty 50 =
5 * 10 for class -2, and penalty 20 = 2 * 10 for class 4.

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

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

Obtain a model with probability information and predict test data with
probability estimates

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

Precomputed Kernels

Users may precompute kernel values and input them as training and
testing files. Then libsvm does not need the original
training/testing sets.

Assume there are L training instances x1, …, xL and.
Let K(x, y) be the kernel
value of two instances x and y. The input formats
are:

New training instance for xi:

New testing instance for any x:

That is, in the training file the first column must be the “ID” of
xi. In testing, ? can be any value.

All kernel values including ZEROs must be explicitly provided. Any
permutation or random subsets of the training/testing files are also
valid (see examples below).

Note: the format is slightly different from the precomputed kernel
package released in libsvmtools earlier.

Examples:

Assume the original training data has three four-feature
instances and testing data has one instance:

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

15  1:1     3:1

If the linear kernel is used, we have the following new
training/testing sets:

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

? can be any value.

Any subset of the above training file is also valid. For example,

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

implies that the kernel matrix is

    [K(2,2) K(2,3)] = [18 0]
    [K(3,2) K(3,3)] = [0  1]

Library Usage

These functions and structures are declared in the header file
svm.h'. You need to #include "svm.h" in your C/C++ source files and
link your program with
svm.cpp’. You can see svm-train.c' and
svm-predict.c’ for examples showing how to use them. We define
LIBSVM_VERSION and declare `extern int libsvm_version; ’ in svm.h, so
you can check the version number.

Before you classify test data, you need to construct an SVM model
(`svm_model’) using training data. A model can also be saved in
a file for later use. Once an SVM model is available, you can use it
to classify new data.

  • Function: struct svm_model *svm_train(const struct svm_problem *prob,
    const struct svm_parameter *param);

    This function constructs and returns an SVM model according to
    the given training data and parameters.

这个函数用来构建一个训练模型

struct svm_problem describes the problem:

  结构体svm_problem的定义

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

where `l' is the number of training data, and `y' is an array containing
their target values. (integers in classification, real numbers in
regression) `x' is an array of pointers, each of which points to a sparse
representation (array of svm_node) of one training vector. 

'l'是训练数据的个数,'y'是一个数组,包含着目标值,就是标签(分类的时候为整形,回归的时候为实数)
'x'是一个结构体型的数组的指针,每一个是指向一个训练向量的稀疏表示,这个结构体定义为svm_node,前面表示索引,后面表示该索引位置的值


For example, if we have the following training data:

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

then the components of svm_problem are:

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

where (index,value) is stored in the structure `svm_node':

struct svm_node
{
    int index;
    double value;
};

前面表示索引,后面表示索引的值,是一个数据集的特征值

index = -1 indicates the end of one vector. Note that indices must
be in ASCENDING order.


-1表示这个向量的结束,索引必须以增量形式

struct svm_parameter describes the parameters of an SVM model:


训练参数的一个结构体定义

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 can be one of C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR.


svm_type表示用哪一种svm

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 can be one of 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 is the size of the kernel cache, specified in megabytes.//指定的缓存的大小,以M为单位
C is the cost of constraints violation.                            //惩罚参数
eps is the stopping criterion. (we usually use 0.00001 in nu-SVC,   
0.001 in others). nu is the parameter in nu-SVM, nu-SVR, and
one-class-SVM. p is the epsilon in epsilon-insensitive loss function
of epsilon-SVM regression. shrinking = 1 means shrinking is conducted;
= 0 otherwise. probability = 1 means model with probability
information is obtained; = 0 otherwise.

 eps是停止标准。 (我们通常在nu-SVC中使用0.00001,其他人使用0.001)。 
 nu是nu-SVM,nu-SVR和one-class-SVM中的参数。
 p是ε-SVM回归的ε不敏感损失函数中的ε。 
 收缩= 1表示进行收缩;否则为0。 
 概率= 1表示获得具有概率信息的模型; = 0否则。



nr_weight, weight_label, and weight are used to change the penalty
for some classes (If the weight for a class is not changed, it is
set to 1). This is useful for training classifier using unbalanced
input data or with asymmetric misclassification cost.

nr_weight,weight_label和weight用于改变某些类的惩罚(如果一个类的权重没有改变,它被设置为1)。
 这对于使用不平衡输入数据或不对称错误分类成本的训练分类器很有用。





nr_weight is the number of elements in the array weight_label and
weight. Each weight[i] corresponds to weight_label[i], meaning that
the penalty of class weight_label[i] is scaled by a factor of weight[i].

nr_weight是数组中的元素数量weight_label和权重。 每个权重[i]对应于weight_label [i],
这意味着类wight_label [i]的惩罚按比例[i]进行缩放。


If you do not want to change penalty for any of the classes,
just set nr_weight to 0.

如果您不想更改任何类的惩罚,只需将nr_weight设置为0。

*NOTE* Because svm_model contains pointers to svm_problem, you can
not free the memory used by svm_problem if you are still using the
svm_model produced by svm_train(). 

*注意*由于svm_model包含指向svm_problem的指针,如果仍使用svm_train()生成的svm_model,则无法释放svm_problem使用的内存。


*NOTE* To avoid wrong parameters, svm_check_parameter() should be
called before svm_train().

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

struct svm_model stores the model obtained from the training procedure.
It is not recommended to directly access entries in this structure.
Programmers should use the interface functions to get the values.


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 *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 describes the parameters used to obtain the model.

param描述了用于获取模型的参数。 上面训练模型时的参数


nr_class is the number of classes. It is 2 for regression and one-class SVM.

类别数,对于回归和one-class来说是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向量,其中α是以下两个类问题的解:
 1对j,2对j,...,j-1对j,j对j + 1,j对j + 2,...,j对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|                    |
    +-+-+-+--------------------+

See svm_train() for an example of assigning values to sv_coef.

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



rho is the bias term (-b). probA and probB are parameters used in
probability outputs. If there are k classes, there are k*(k-1)/2
binary problems as well as rho, probA, and probB values. They are
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.

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] are values in [1,...,num_traning_data] to
indicate support vectors in the training set.


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


label contains labels in the training data.

nSV is the number of support vectors in each class.
每一类支持向量的个数

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.

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

  • Function: double svm_predict(const struct svm_model *model,
    const struct svm_node *x);

    This function does classification or regression on a test vector x
    given a model.

    For a classification model, the predicted class for x is returned.
    For a regression model, the function value of x calculated using
    the model is returned. For an one-class model, +1 or -1 is
    returned.

此函数对给定模型的测试向量x执行分类或回归。
对于分类模型,返回x的预测类。
对于回归模型,返回使用模型计算的x的函数值。 对于一级模型,返回+1或-1。

  • Function: void svm_cross_validation(const struct svm_problem *prob,
    const struct svm_parameter *param, int nr_fold, double *target);

    This function conducts cross validation. Data are separated to
    nr_fold folds. Under given parameters, sequentially each fold is
    validated using the model from training the remaining. Predicted
    labels (of all prob’s instances) in the validation process are
    stored in the array called target.

    此功能进行交叉验证。 数据被分隔成nr_fold折叠。下给定的参数,依次各个折叠使用来自训练的剩余的模型验证。
    验证过程中的预测标签(所有prob的实例)都存储在名为target的数组中。

    The format of svm_prob is same as that for svm_train().

  • Function: int svm_get_svm_type(const struct svm_model *model);

    This function gives svm_type of the model. Possible values of
    svm_type are defined in svm.h.

    该函数给出了模型的svm_type。 svm_h的值可以在svm.h中定义。

  • Function: int svm_get_nr_class(const svm_model *model);

    For a classification model, this function gives the number of
    classes. For a regression or an one-class model, 2 is returned.

    对于分类模型,该函数给出了类的数量。 对于回归或一类模型,返回2。

  • Function: void svm_get_labels(const svm_model model, int label)

    For a classification model, this function outputs the name of
    labels into an array called label. For regression and one-class
    models, label is unchanged.

    对于分类模型,该函数将标签的名称输出到名为标签的数组中。 对于回归和一类模型,标签不变。

  • Function: void svm_get_sv_indices(const struct svm_model *model, int *sv_indices)

    This function outputs indices of support vectors into an array called sv_indices.
    The size of sv_indices is the number of support vectors and can be obtained by calling svm_get_nr_sv.
    Each sv_indices[i] is in the range of [1, …, num_traning_data].

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

  • Function: int svm_get_nr_sv(const struct svm_model *model)

    This function gives the number of total support vector.
    该函数给出了总支持向量的数量。

  • Function: double svm_get_svr_probability(const struct svm_model *model);

    For a regression model with probability information, this function
    outputs a value sigma > 0. For test data, we consider the
    probability model: target value = predicted value + z, z: Laplace
    distribution e^(-|z|/sigma)/(2sigma)

    If the model is not for svr or does not contain required
    information, 0 is returned.

对于具有概率信息的回归模型,该函数输出一个值σ> 0.对于测试数据,我们考虑概率模型:
目标值=预测值+ z,z:拉普拉斯分布e ^( - | z | / sigma)/ (2sigma)如果模型不适用于svr或不包含所需信息,则返回0。

  • Function: double svm_predict_values(const svm_model *model,
    const svm_node x, double dec_values)

    This function gives decision values on a test vector x given a
    model, and return the predicted label (classification) or
    the function value (regression).

该函数给出给定模型的测试向量x上的决策值,并转动预测标签(分类)或函数值(回归)。

For a classification model with nr_class classes, this function
gives nr_class*(nr_class-1)/2 decision values in the array
dec_values, where nr_class can be obtained from the function
svm_get_nr_class. The order is 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], where label can be
obtained from the function svm_get_labels. The returned value is
the predicted class for x. Note that when nr_class = 1, this 
function does not give any decision value.

对于具有r_class类的分类模型,该函数在数组dec_values中给出nr_class *(nr_class-1)/ 2个决策值,
其中可以从函数svm_get_nr_class获取nr_class。
顺序是标签[0]与标签[1],…,标签[0]对标签[nr_class-1],
标签[1]对标签[2],…,标签[nr_class- 2]对标签[nr_class-1],
其中可以从函数svm_get_labels获取标签。 返回的值是x的预测类。
请注意,当nr_class = 1时,此函数不给出任何决策值。

For a regression model, dec_values[0] and the returned value are
both the function value of x calculated using the model. For a
one-class model, dec_values[0] is the decision value of x, while
the returned value is +1/-1.

对于回归模型,dec_values [0]和返回值都是使用模型计算的x的函数值。 
对于一类模型,dec_values [0]是x的决策值,返回值为+ 1 / -1。
  • Function: double svm_predict_probability(const struct svm_model *model,
    const struct svm_node x, double prob_estimates);

    This function does classification or regression on a test vector x
    given a model with probability information.

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

For a classification model with probability information, this
function gives nr_class probability estimates in the array
prob_estimates. nr_class can be obtained from the function
svm_get_nr_class. The class with the highest probability is
returned. For regression/one-class SVM, the array prob_estimates
is unchanged and the returned value is the same as that of
svm_predict.

对于具有概率信息的分类模型,该函数在阵列prob_estimates中给出nr_class概率估计。
 nr_class可以从函数svm_get_nr_class获取。 返回最高概率的类。 
 对于回归/一类SVM,数组prob_estimates不变,返回值与svm_predict相同。
  • Function: const char *svm_check_parameter(const struct svm_problem *prob,
    const struct svm_parameter *param);

    This function checks whether the parameters are within the feasible
    range of the problem. This function should be called before calling
    svm_train() and svm_cross_validation(). It returns NULL if the
    parameters are feasible, otherwise an error message is returned.

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

  • Function: int svm_check_probability_model(const struct svm_model *model);

    This function checks whether the model contains required
    information to do probability estimates. If so, it returns
    +1. Otherwise, 0 is returned. This function should be called
    before calling svm_get_svr_probability and
    svm_predict_probability.

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

  • Function: int svm_save_model(const char *model_file_name,
    const struct svm_model *model);

    This function saves a model to a file; returns 0 on success, or -1
    if an error occurs.

此功能将模型保存到文件中; 成功返回0,否则发生错误。

  • Function: struct svm_model *svm_load_model(const char *model_file_name);

    This function returns a pointer to the model read from the file,
    or a null pointer if the model could not be loaded.

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

  • Function: void svm_free_model_content(struct svm_model *model_ptr);

    This function frees the memory used by the entries in a model structure.

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

  • Function: void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);

    This function frees the memory used by a model and destroys the model
    structure. It is equivalent to svm_destroy_model, which
    is deprecated after version 3.0.

    此函数释放模型使用的内存并销毁模型结构。 它相当于svm_destroy_model,它在版本3.0之后不推荐使用。

  • Function: void svm_destroy_param(struct svm_parameter *param);

    This function frees the memory used by a parameter set.

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

  • Function: void svm_set_print_string_function(void (print_func)(const char ));

    Users can specify their output format by a function. Use
    svm_set_print_string_function(NULL);
    for default printing to stdout.

    用户可以通过功能指定其输出格式。 使用svm_set_print_string函数(NULL); 默认打印到stdout。

Java Version

The pre-compiled java class archive `libsvm.jar’ and its source files are
in the java directory. To run the programs, use

java -classpath libsvm.jar svm_train
java -classpath libsvm.jar svm_predict
java -classpath libsvm.jar svm_toy
java -classpath libsvm.jar svm_scale

Note that you need Java 1.5 (5.0) or above to run it.

You may need to add Java runtime library (like classes.zip) to the classpath.
You may need to increase maximum Java heap size.

Library usages are similar to the C version. These functions are available:

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);
}

The library is in the “libsvm” package.
Note that in Java version, svm_node[] is not ended with a node whose index = -1.

Users can specify their output format by

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

Building Windows Binaries

Windows binaries are available in the directory `windows’. To re-build
them via Visual C++, use the following steps:

  1. Open a DOS command box (or Visual Studio Command Prompt) and change
    to libsvm directory. If environment variables of VC++ have not been
    set, type

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

You may have to modify the above command according which version of
VC++ or where it is installed.

  1. Type

nmake -f Makefile.win clean all

  1. (optional) To build shared library libsvm.dll, type

nmake -f Makefile.win lib

  1. (optional) To build 32-bit windows binaries, you must
    (1) Setup “C:\Program Files (x86)\Microsoft Visual Studio 12.0\VC\bin\vcvars32.bat” instead of vcvars64.bat
    (2) Change CFLAGS in Makefile.win: /D _WIN64 to /D _WIN32

Another way is to build them from Visual C++ environment. See details
in libsvm FAQ.

- Additional Tools: Sub-sampling, Parameter Selection, Format checking, etc.

See the README file in the tools directory.

MATLAB/OCTAVE Interface

Please check the file README in the directory `matlab’.

Python Interface

See the README file in python directory.

Additional Information

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

福利答谢大家!

感谢您阅读本篇文章,对此特别发放一个无门槛的现金红包,打开支付宝扫码领取!
这里写图片描述

©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页