In the package there is a README file which details all options, data format, and library calls. The model selection tool and the python interface have a separate README under the directory python. The guide A practical guide to support vector classification shows beginners how to train/test their data. The paper LIBSVM : a library for support vector machines discusses the implementation of libsvm in detail.
See the change log.
You can download earlier versions here.
Please cite the following document:
Chih-Chung Chang and Chih-Jen Lin, LIBSVM : a library for support vector machines, 2001. Software available at http://www.csie.ntu.edu.tw/~cjlin/libsvm
The bibtex format is as follows
@Manual{CC01a,
author = {Chih-Chung Chang and Chih-Jen Lin},
title = {{LIBSVM}: a library for support vector machines},
year = {2001},
note = {Software available at \url{http://www.csie.ntu.edu.tw/~cjlin/libsvm}}
}
The libsvm license ("the modified BSD license") is compatible with many free software licenses such as GPL. Hence, it is very easy to use libsvm in your software. It can also be used in commercial products.
Yes, see libsvm tools
This usually happens if you compile the code on one machine and run it on another which has incompatible libraries. Try to recompile the program on that machine or use static linking.
Build it as a project by choosing "Win32 Project." On the other hand, for "svm-train" and "svm-predict" you want to choose "Win32 Console Project." After libsvm 2.5, you can also use the file Makefile.win. See details in README.
If you are not using Makefile.win and see the following link error
LIBCMTD.lib(wwincrt0.obj) : error LNK2001: unresolved external symbol _wWinMain@16you may have selected a wrong project type.
You need to open a command window and type svmtrain.exe to see all options. Some examples are in README file.
libsvm uses the so called "sparse" format where zero values do not need to be stored. Hence a data with attributes
1 0 2 0is represented as
1:1 3:2
Currently libsvm supports only numerical data. You may have to change non-numerical data to numerical. For example, you can use several binary attributes to represent a categorical attribute.
This is a controversial issue. The kernel evaluation (i.e. inner product) of sparse vectors is slower so the total training time can be at least twice or three times of that using the dense format. However, we cannot support only dense format as then we CANNOT handle extremely sparse cases. Simplicity of the code is another concern. Right now we decide to support the sparse format only.
obj is the optimal objective value of the dual SVM problem. rho is the bias term in the decision function sgn(w^Tx - rho). nSV and nBSV are number of support vectors and bounded support vectors (i.e., alpha_i = C). nu-svm is a somewhat equivalent form of C-SVM where C is replaced by nu. nu simply shows the corresponding parameter. More details are in libsvm document.
After the parameters, each line represents a support vector.
Support vectors are listed in the order of "labels" listed earlier.
(i.e., those from the first class in the "labels" list are
grouped first, and so on.)
If k is the total number of classes,
in front of each support vector, there are
k-1 coefficients
y*alpha where alpha are dual solution 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 in first j-1 coefficients, y=-1 in the remaining
k-j coefficients.
For example, if there are 4 classes, the file looks like:
+-+-+-+--------------------+ |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| | +-+-+-+--------------------+
We have float as the default as you can store more numbers in the cache. In general this is good enough but for few difficult cases (e.g. C very very large) where solutions are huge numbers, it might be possible that the numerical precision is not enough using only float.
In general we suggest you to try the RBF kernel first. A recent result by Keerthi and Lin ( download paper here) shows that if RBF is used with model selection, then there is no need to consider the linear kernel. The kernel matrix using sigmoid may not be positive definite and in general it's accuracy is not better than RBF. (see the paper by Lin and Lin ( download paper here). Polynomial kernels are ok but if a high degree is used, numerical difficulties tend to happen (thinking about dth power of (<1) goes to 0 and (>1) goes to infinity).
No, at this point libsvm solves linear/nonlinear SVMs by the same way. Note that there are some possible tricks to save training/testing time if the linear kernel is used. Hence libsvm is NOT particularly efficient for linear SVM, especially for using large C on problems whose number of data is much larger than number of attributes. You can
S. S. Keerthi and C.-J. Lin. Asymptotic behaviors of support vector machines with Gaussian kernel . Neural Computation, 15(2003), 1667-1689.
K.-M. Chung, W.-C. Kao, T. Sun, and C.-J. Lin. Decomposition Methods for Linear Support Vector Machines. Neural Computation, 16(2004), 1689-1704.
On the other hand, you do not really need to solve linear SVMs. See the previous question about choosing kernels for details.
This usually happens when the data are overfitted. If attributes of your data are in large ranges, try to scale them. Then the region of appropriate parameters may be larger. Note that there is a scale program in libsvm.
Yes, you can do the following:
svm-scale -s scaling_parameters train_data > scaled_train_data
svm-scale -r scaling_parameters test_data > scaled_test_data
For the linear scaling method, if the RBF kernel is used and parameter selection is conducted, there is no difference. Assume Mi and mi are respectively the maximal and minimal values of the ith attribute. Scaling to [0,1] means
x'=(x-mi)/(Mi-mi)
For [-1,1],
x''=2(x-mi)/(Mi-mi)-1.
In the RBF kernel,
x'-y'=(x-y)/(Mi-mi), x''-y''=2(x-y)/(Mi-mi).
Hence, using (C,g) on the [0,1]-scaled data is the
same as (C,g/2) on the [-1,1]-scaled data.
Though the performance is the same, the computational time may be different. For data with many zero entries, [0,1]-scaling keeps the sparsity of input data and hence may save the time.
Try to use the model selection tool grid.py in the python directory find out good parameters. To see the importance of model selection, please see my talk: A practical guide to support vector classification
Yes, there is a -wi options. For example, if you use
svm-train -s 0 -c 10 -w1 1 -w-1 5 data_file
the penalty for class "-1" is larger. Note that this -w option is for C-SVC only.
Basically they are the same thing but with different parameters. The range of C is from zero to infinity but nu is always between [0,1]. A nice property of nu is that it is related to the ratio of support vectors and the ratio of the training error.
You may want to check your data. Each training/testing data must be in one line. It cannot be separated. In addition, you have to remove empty lines.
In theory libsvm guarantees to converge if the kernel matrix is positive semidefinite. After version 2.4 it can also handle non-PSD kernels such as the sigmoid (tanh). Therefore, this means you are handling ill-conditioned situations (e.g. too large/small parameters) so numerical difficulties occur.
For large problems, please specify enough cache size (i.e., -m). Slow convergence may happen for some difficult cases (e.g. -c is large). You can try to use a looser stopping tolerance with -e. If that still doesn't work, you may want to train only a subset of the data. You can use the program subset.py in the directory "tools" to obtain a random subset.
If you are using polynomial kernels, please check the question on the pow() function.
We print out decision values for regression. For classification, we solve several binary SVMs for multi-class cases. You can obtain values by easily calling the subroutine svm_predict_values. Their corresponding labels can be obtained from svm_get_labels. Details are in README of libsvm package.
We do not recommend the following. But if you would like to get values for TWO-class classification with labels +1 and -1 (note: +1 and -1 but not things like 5 and 10) in the easiest way, simply add
printf("%f\n", dec_values[0]*model->label[0]);
after the line
svm_predict_values(model, x, dec_values);of the file svm.cpp. Positive (negative) decision values correspond to data predicted as +1 (-1).
The distance is |decision_value| / |w|. We have |w|^2 = w^Tw = alpha^T Q alpha = 2*(dual_obj + sum alpha_i). Thus in svm.cpp please find the place where we calculate the dual objective value (i.e., the subroutine Solve()) and add a statement to print w^Tw.
On 32-bit machines, the maximum addressable memory is 4GB. The Linux kernel uses 3:1 split which means user space is 3G and kernel space is 1G. Although there are 3G user space, the maximum dynamic allocation memory is 2G. So, if you specify -m near 2G, the memory will be exhausted. And svm-train will fail when it asks more memory. For more details, please read this article.
The easiest solution is to switch to a 64-bit machine. Otherwise, there are two ways to solve this. If your machine supports Intel's PAE (Physical Address Extension), you can turn on the option HIGHMEM64G in Linux kernel which uses 4G:4G split for kernel and user space. If you don't, you can try a software `tub' which can eliminate the 2G boundary for dynamic allocated memory. The `tub' is available at http://www.bitwagon.com/tub.html.
Simply update svm.cpp:
#if 1 void info(char *fmt,...)to
#if 0 void info(char *fmt,...)
The reason why we have two functions is as follows: For the RBF kernel exp(-g |xi - xj|^2), if we calculate xi - xj first and then the norm square, there are 3n operations. Thus we consider exp(-g (|xi|^2 - 2dot(xi,xj) +|xj|^2)) and by calculating all |xi|^2 in the beginning, the number of operations is reduced to 2n. This is for the training. For prediction we cannot do this so a regular subroutine using that 3n operations is needed. The easiest way to have your own kernel is to put the same code in these two subroutines by replacing any kernel.
It is one-against-one. We chose it after doing the following comparison: C.-W. Hsu and C.-J. Lin. A comparison of methods for multi-class support vector machines , IEEE Transactions on Neural Networks, 13(2002), 415-425.
"1-against-the rest" is a good method whose performance is comparable to "1-against-1." We do the latter simply because its training time is shorter.
Cross validation is used for selecting good parameters. After finding them, you want to re-train the whole data without the -v option.
If you use GNU C library, the default seed 1 is considered. Thus you always get the same result of running svm-train -v. To have different seeds, you can add the following code in svm-train.c:
#include <time.h>and in the beginning of the subroutine do_cross_validation(),
srand(time(0));
It is extremely easy. Taking c-svc for example, only two places of svm.cpp have to be changed. First, modify the following line of solve_c_svc from
s.Solve(l, SVC_Q(*prob,*param,y), minus_ones, y, alpha, Cp, Cn, param->eps, si, param->shrinking);to
s.Solve(l, SVC_Q(*prob,*param,y), minus_ones, y, alpha, INF, INF, param->eps, si, param->shrinking);Second, in the class of SVC_Q, declare C as a private variable:
double C;In the constructor we assign it to param.C:
this->C = param.C;
Than in the the subroutine get_Q, after the for loop, add
if(i >= start && i < len)
data[i] += 1/C;
For one-class svm, the modification is exactly the same. For SVR, you don't need an if statement like the above. Instead, you only need a simple assignment:
data[real_i] += 1/C;
You have pre-specified true positive rate in mind and then search for parameters which achieve similar cross-validation accuracy.
This rarely happens, but few users reported the problem. It seems that their computers for training libsvm have the VPN client running. The VPN software has some bugs and causes this problem. Please try to close or disconnect the VPN client.
The error message is probably
Traceback (most recent call last):
File "grid.py", line 349, in ?
main()
File "grid.py", line 344, in main
redraw(db)
File "grid.py", line 132, in redraw
gnuplot.write("set term windows\n")
IOError: [Errno 22] Invalid argument
There are some problems about using gnuplot on windows. So far we have not found a good solution. Please try to close gnuplot windows and rerun. If the problem still occurs, comment the following two lines in grid.py by inserting "#" in the beginning:
redraw(db)
redraw(db,1)
Then you get accuracy only but not cross validation contours.
Warning: empty z range [62.5:62.5], adjusting to [61.875:63.125] Notice: cannot contour non grid data!
Nothing is wrong and please disregard the message. It is from gnuplot when drawing the contour.
Nothing is wrong. Very likely you have two labels +1/-1 and the first instance in your data has -1. Think about the case of labels +5/+10. Since SVM needs to use +1/-1, internally we map +5/+10 to +1/-1 according to which label appears first. Hence a positive decision value implies that we should predict the "internal" +1, which may not be the +1 in the input file.
To construct this probability model, we internally conduct a cross validation, which is more time consuming than a regular training. Hence, in general you do parameter selection first without -b 1. You only use -b 1 when good parameters have been selected. In other words, you avoid using -b 1 and -v together.
There is absolutely no reason the probability outputs guarantee you better accuracy. The main purpose of this option is to provide you the probability estimates, but not to boost prediction accuracy. From our experience, after proper parameter selections, in general with and without -b have similar accuracy. Occasionally there are some differences. It is not recommended to compare the two under just a fixed parameter set as more differences will be observed.
After probability information is obtained in training, we do not have
prob > = 0.5 if and only if decision value >= 0.
So predictions may be different with -b 0 and 1.
For Microsoft windows, first press the "print screen" key on the keyboard. Open "Microsoft Paint" (included in Windows) and press "ctrl-v." Then you can clip the part of picture which you want. For X windows, you can use the program "xv" or "import" to grab the picture of the svm-toy window.
The program svm-toy assumes both attributes (i.e. x-axis and y-axis values) are in (0,1). Hence you want to scale your data to between a small positive number and a number less than but very close to 1. Moreover, class labels must be 1, 2, or 3 (not 1.0, 2.0 or anything else).
Taking windows/svm-toy.cpp as an example, you need to modify it and the difference from the original file is as the following: (for five classes of data)
30,32c30 < RGB(200,0,200), < RGB(0,160,0), < RGB(160,0,0) --- > RGB(200,0,200) 39c37 < HBRUSH brush1, brush2, brush3, brush4, brush5; --- > HBRUSH brush1, brush2, brush3; 113,114d110 < brush4 = CreateSolidBrush(colors[7]); < brush5 = CreateSolidBrush(colors[8]); 155,157c151 < else if(v==3) return brush3; < else if(v==4) return brush4; < else return brush5; --- > else return brush3; 325d318 < int colornum = 5; 327c320 < svm_node *x_space = new svm_node[colornum * prob.l]; --- > svm_node *x_space = new svm_node[3 * prob.l]; 333,338c326,331 < x_space[colornum * i].index = 1; < x_space[colornum * i].value = q->x; < x_space[colornum * i + 1].index = 2; < x_space[colornum * i + 1].value = q->y; < x_space[colornum * i + 2].index = -1; < prob.x[i] = &x_space[colornum * i]; --- > x_space[3 * i].index = 1; > x_space[3 * i].value = q->x; > x_space[3 * i + 1].index = 2; > x_space[3 * i + 1].value = q->y; > x_space[3 * i + 2].index = -1; > prob.x[i] = &x_space[3 * i]; 397c390 < if(current_value > 5) current_value = 1; --- > if(current_value > 3) current_value = 1;
They are the same thing. We just rewrote the C++ code in Java.
This depends on the VM you used. We have seen good VM which leads the Java version to be quite competitive with the C++ code. (though still slower)
You should try to increase the maximum Java heap size. For example,
java -Xmx2048m -classpath libsvm.jar svm_train ...sets the maximum heap size to 2048M.
Unlike C, Java does not have a preprocessor built-in. However, we need some macros (see first 3 lines of svm.m4).
It seems the pyd file is version dependent. So far we haven't found out a good solution. Please email us if you have any good suggestions.
To modify the interface, follow the instructions given in http://www.swig.org/Doc1.3/Python.html#Python
If you just want to build .pyd for a different python version, after libsvm 2.5, you can easily use the file Makefile.win. See details in README. Alternatively, you can use Visual C++:
Yes, here are some examples:
$ export CLASSPATH=$CLASSPATH:~/libsvm-2.4/java/libsvm.jar
$ ./jython
Jython 2.1a3 on java1.3.0 (JIT: jitc)
Type "copyright", "credits" or "license" for more information.
>>> from libsvm import *
>>> dir()
['__doc__', '__name__', 'svm', 'svm_model', 'svm_node', 'svm_parameter',
'svm_problem']
>>> x1 = [svm_node(index=1,value=1)]
>>> x2 = [svm_node(index=1,value=-1)]
>>> param = svm_parameter(svm_type=0,kernel_type=2,gamma=1,cache_size=40,eps=0.001,C=1,nr_weight=0,shrinking=1)
>>> prob = svm_problem(l=2,y=[1,-1],x=[x1,x2])
>>> model = svm.svm_train(prob,param)
*
optimization finished, #iter = 1
nu = 1.0
obj = -1.018315639346838, rho = 0.0
nSV = 2, nBSV = 2
Total nSV = 2
>>> svm.svm_predict(model,x1)
1.0
>>> svm.svm_predict(model,x2)
-1.0
>>> svm.svm_save_model("test.model",model)
Instead of LDFLAGS = -shared in the Makefile, you need
LDFLAGS = -framework Python -bundleThe problem is that under MacOs there is no "shared libraries." Instead they use "dynamic libraries."
Even though you may have python on your system, very likely python development tools are not installed. Please check with your system administrator.
Your compiler version may not be supported/compatible for MATLAB. Please check this MATLAB page first and then specify the version number. For example, if g++ 3.3 is supported, replace
CXX = g++in the Makefile with
CXX = g++-3.3
It is extremely easy to do scaling under MATLAB. The following one-line code scale each feature to the range of [0.1]:
(data - repmat(min(data,[],1),size(data,1),1))./(repmat(max(data,[],1)-min(data,[],1),size(data,1),1))