Python interface of LIBLINEAR

copy自liblinear

Table of Contents

• Introduction
• Installation
• Quick Start
• Design Description
• Data Structures
• Utility Functions
• Additional Information

Introduction

Python (http://www.python.org/) is a programming language suitable for rapid
development. This tool provides a simple Python interface to LIBLINEAR, a library
for support vector machines (http://www.csie.ntu.edu.tw/~cjlin/liblinear). The
interface is very easy to use as the usage is the same as that of LIBLINEAR. The
interface is developed with the built-in Python library “ctypes.”

Installation

On Unix systems, type

make

The interface needs only LIBLINEAR shared library, which is generated by
the above command. We assume that the shared library is on the LIBLINEAR
main directory or in the system path.

For windows, the shared library liblinear.dll is ready in the directory
..\windows'. You can also copy it to the system directory (e.g.,
C:\WINDOWS\system32\’ for Windows XP). To regenerate the shared library,
please follow the instruction of building windows binaries in LIBLINEAR README.

Quick Start

There are two levels of usage. The high-level one uses utility functions
in liblinearutil.py and the usage is the same as the LIBLINEAR MATLAB interface.

from liblinearutil import *

Read data in LIBSVM format

默认输入格式

最左边的一列是label， 其他的为特征，冒号前面的是特征的col_idx后面的是特征number
+1 1:0.708333 2:1 3:1 4:-0.320755 5:-0.105023 6:-1 7:1 8:-0.419847 9:-1 10:-0.225806 12:1 13:-1 
-1 1:0.583333 2:-1 3:0.333333 4:-0.603774 5:1 6:-1 7:1 8:0.358779 9:-1 10:-0.483871 12:-1 13:1 
+1 1:0.166667 2:1 3:-0.333333 4:-0.433962 5:-0.383562 6:-1 7:-1 8:0.0687023 9:-1 10:-0.903226 11:-1 12:-1 13:1 
-1 1:0.458333 2:1 3:1 4:-0.358491 5:-0.374429 6:-1 7:-1 8:-0.480916 9:1 10:-0.935484 12:-0.333333 13:1 
-1 1:0.875 2:-1 3:-0.333333 4:-0.509434 5:-0.347032 6:-1 7:1 8:-0.236641 9:1 10:-0.935484 11:-1 12:-0.333333 13:-1 
-1 1:0.5 2:1 3:1 4:-0.509434 5:-0.767123 6:-1 7:-1 8:0.0534351 9:-1 10:-0.870968 11:-1 12:-1 13:1 

y, x = svm_read_problem(‘../heart_scale’)
m = train(y[:200], x[:200], ‘-c 4’)
p_label, p_acc, p_val = predict(y[200:], x[200:], m)

Construct problem in python format

Dense data稠密矩阵

y, x = [1,-1], [[1,0,1], [-1,0,-1]]

Sparse data稀疏矩阵

y, x = [1,-1], [{1:1, 3:1}, {1:-1,3:-1}]
prob = problem(y, x)
param = parameter(‘-s 0 -c 4 -B 1’)
m = train(prob, param)

Other utility functions模型的保存与加载

save_model(‘heart_scale.model’, m)
m = load_model(‘heart_scale.model’)
p_label, p_acc, p_val = predict(y, x, m, ‘-b 1’)
ACC, MSE, SCC = evaluations(y, p_label)

Getting online help

help(train)

The low-level use directly calls C interfaces imported by liblinear.py. Note that
all arguments and return values are in ctypes format. You need to handle them
carefully.

from liblinear import *
prob = problem([1,-1], [{1:1, 3:1}, {1:-1,3:-1}])
param = parameter(‘-c 4’)
m = liblinear.train(prob, param) # m is a ctype pointer to a model

Convert a Python-format instance to feature_nodearray, a ctypes structure |python的格式转换和预测

x0, max_idx = gen_feature_nodearray({1:1, 3:1})
label = liblinear.predict(m, x0)

Design Description

There are two files liblinear.py and liblinearutil.py, which respectively correspond to
low-level and high-level use of the interface.

In liblinear.py, we adopt the Python built-in library “ctypes,” so that
Python can directly access C structures and interface functions defined
in linear.h.

While advanced users can use structures/functions in liblinear.py, to
avoid handling ctypes structures, in liblinearutil.py we provide some easy-to-use
functions. The usage is similar to LIBLINEAR MATLAB interface.

Data Structures数据构造

Three data structures derived from linear.h are **node, problem, and
parameter**. They all contain fields with the same names in
linear.h. Access these fields carefully because you directly use a C structure
instead of a Python object. The following description introduces additional
fields and methods.

Before using the data structures, execute the following command to load the
LIBLINEAR shared library:

>>> from liblinear import *

• class feature_node:

  Construct a feature_node.构造特征

  node = feature_node(idx, val)

  idx: an integer indicates the feature index.

  val: a float indicates the feature value.

  Show the index and the value of a node.

  print(node)

• Function: gen_feature_nodearray(xi [,feature_max=None [,issparse=True]])

  Generate a feature vector from a Python list/tuple or a dictionary:

  xi, max_idx = gen_feature_nodearray({1:1, 3:1, 5:-2})

  xi: the returned feature_nodearray (a ctypes structure)

  max_idx: the maximal feature index of xi

>>> xi
<liblinear.feature_node_Array_5 object at 0x7f468b74e050>
>>> max_idx
5

issparse: if issparse == True, zero feature values are removed. The default
          value is True for the sparsity.如果是稀疏的0特征只去除，默认是稀疏的

feature_max: if feature_max is assigned, features with indices larger than
             feature_max are removed.如果最大特征数已经设置，那么大于最大特征的feature会被删除。

• class problem:

  Construct a problem instance

  prob = problem(y, x [,bias=-1])

  y: a Python list/tuple of l labels (type must be int/double).

  x: a Python list/tuple of l data instances. Each element of x must be
  an instance of list/tuple/dictionary type.

  bias: if bias >= 0, instance x becomes [x; bias]; if < 0, no bias term
  added (default -1)

  You can also modify the bias value by

  prob.set_bias(1)

  Note that if your x contains sparse data (i.e., dictionary), the internal
  ctypes data format is still sparse.

• class parameter:

  Construct a parameter instance

  param = parameter(‘training_options’)

  If ‘training_options’ is empty, LIBLINEAR default values are applied.

  Set param to LIBLINEAR default values.

  param.set_to_default_values()

  Parse a string of options.

  param.parse_options(‘training_options’)

  Show values of parameters.

  print(param)

• class model:

  There are two ways to obtain an instance of model:

  model_ = train(y, x)
  model_ = load_model(‘model_file_name’)

  **Note that the returned structure of interface functions
  liblinear.train and liblinear.load_model is a ctypes pointer of
  model**, which is different from the model object returned
  by train and load_model in liblinearutil.py. We provide a
  function toPyModel for the conversion:

  model_ptr = liblinear.train(prob, param)
  model_ = toPyModel(model_ptr)

  If you obtain a model in a way other than the above approaches,
  handle it carefully to avoid memory leak or segmentation fault.

  Some interface functions to access LIBLINEAR models are wrapped as
  members of the class model:

  nr_feature = model_.get_nr_feature()
  nr_class = model_.get_nr_class()
  class_labels = model_.get_labels()
  is_prob_model = model_.is_probability_model()
  is_regression_model = model_.is_regression_model()

  The decision function is W*x + b, where
  W is an nr_class-by-nr_feature matrix, and
  b is a vector of size nr_class.
  To access W_kj (i.e., coefficient for the k-th class and the j-th feature)
  and b_k (i.e., bias for the k-th class), use the following functions.

  W_kj = model_.get_decfun_coef(feat_idx=j, label_idx=k)
  b_k = model_.get_decfun_bias(label_idx=k)

  We also provide a function to extract w_k (i.e., the k-th row of W) and
  b_k directly as follows.

  [w_k, b_k] = model_.get_decfun(label_idx=k)

  Note that w_k is a Python list of length nr_feature, which means that
  w_k[0] = W_k1.
  For regression models, W is just a vector of length nr_feature. Either
  set label_idx=0 or omit the label_idx parameter to access the coefficients.

  W_j = model_.get_decfun_coef(feat_idx=j)
  b = model_.get_decfun_bias()
  [W, b] = model_.get_decfun()

  Note that in get_decfun_coef, get_decfun_bias, and get_decfun, feat_idx
  starts from 1, while label_idx starts from 0. If label_idx is not in the
  valid range (0 to nr_class-1), then a NaN will be returned; and if feat_idx
  is not in the valid range (1 to nr_feature), then a zero value will be
  returned. For regression models, label_idx is ignored.

Utility Functions

To use utility functions, type

>>> from liblinearutil import *

The above command loads
train() : train a linear model
predict() : predict testing data
svm_read_problem() : read the data from a LIBSVM-format file.
load_model() : load a LIBLINEAR model.
save_model() : save model to a file.
evaluations() : evaluate prediction results.

• Function: train

  There are three ways to call train()

  model = train(y, x [, ‘training_options’])
  model = train(prob [, ‘training_options’])
  model = train(prob, param)

  y: a list/tuple of l training labels (type must be int/double).

  x: a list/tuple of l training instances. The feature vector of
  each training instance is an instance of list/tuple or dictionary.

  training_options: a string in the same form as that for LIBLINEAR command
  mode.

  prob: a problem instance generated by calling
  problem(y, x).

  param: a parameter instance generated by calling
  parameter(‘training_options’)

  model: the returned model instance. See linear.h for details of this
  structure. If ‘-v’ is specified, cross validation is
  conducted and the returned model is just a scalar: cross-validation
  accuracy for classification and mean-squared error for regression.
  If the ‘-C’ option is specified, the best parameter C is found
  by cross validation. The returned model is a tuple of the best C
  and the corresponding cross-validation accuracy. The parameter
  selection utility is supported by only -s 0 and -s 2.

  To train the same data many times with different
  parameters, the second and the third ways should be faster..

  Examples:

  y, x = svm_read_problem(‘../heart_scale’)
  prob = problem(y, x)
  param = parameter(‘-s 3 -c 5 -q’)
  m = train(y, x, ‘-c 5’)
  m = train(prob, ‘-w1 5 -c 5’)
  m = train(prob, param)
  CV_ACC = train(y, x, ‘-v 3’)
  best_C, best_rate = train(y, x, ‘-C -s 0’)
  m = train(y, x, ‘-c {0} -s 0’.format(best_C)) # use the same solver: -s 0

• Function: predict

  To predict testing data with a model, use

  p_labs, p_acc, p_vals = predict(y, x, model [,’predicting_options’])

  y: a list/tuple of l true labels (type must be int/double). It is used
  for calculating the accuracy. Use [] if true labels are
  unavailable.

  x: a list/tuple of l predicting instances. The feature vector of
  each predicting instance is an instance of list/tuple or dictionary.

  predicting_options: a string of predicting options in the same format as
  that of LIBLINEAR.

  model: a model instance.

  p_labels: a list of predicted labels

  p_acc: a tuple including accuracy (for classification), mean
  squared error, and squared correlation coefficient (for
  regression).

  p_vals: a list of decision values or probability estimates (if ‘-b 1’
  is specified). If k is the number of classes, for decision values,
  each element includes results of predicting k binary-class
  SVMs. If k = 2 and solver is not MCSVM_CS, only one decision value
  is returned. For probabilities, each element contains k values
  indicating the probability that the testing instance is in each class.
  Note that the order of classes here is the same as ‘model.label’
  field in the model structure.

  Example:

  m = train(y, x, ‘-c 5’)
  p_labels, p_acc, p_vals = predict(y, x, m)

• Functions: svm_read_problem/load_model/save_model

  See the usage by examples:

  y, x = svm_read_problem(‘data.txt’)
  m = load_model(‘model_file’)
  save_model(‘model_file’, m)

• Function: evaluations

  Calculate some evaluations using the true values (ty) and predicted
  values (pv):

  (ACC, MSE, SCC) = evaluations(ty, pv)

  ty: a list of true values.

  pv: a list of predict values.

  ACC: accuracy.

  MSE: mean squared error.

  SCC: squared correlation coefficient.

Additional Information

This interface was written by Hsiang-Fu Yu from Department of Computer
Science, National Taiwan University. If you find this tool useful, please
cite LIBLINEAR as follows

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. Software available at
http://www.csie.ntu.edu.tw/~cjlin/liblinear

For any question, please contact Chih-Jen Lin cjlin@csie.ntu.edu.tw,
or check the FAQ page:

http://www.csie.ntu.edu.tw/~cjlin/liblinear/faq.html