liblinear-ruby 1.0.1 → 1.0.2

data/liblinear-2.1/predict.c

@@ -1,243 +0,0 @@
-#include <stdio.h>
-#include <ctype.h>
-#include <stdlib.h>
-#include <string.h>
-#include <errno.h>
-#include "linear.h"
-
-int print_null(const char *s,...) {return 0;}
-
-static int (*info)(const char *fmt,...) = &printf;
-
-struct feature_node *x;
-int max_nr_attr = 64;
-
-struct model* model_;
-int flag_predict_probability=0;
-
-void exit_input_error(int line_num)
-{
-	fprintf(stderr,"Wrong input format at line %d\n", line_num);
-	exit(1);
-}
-
-static char *line = NULL;
-static int max_line_len;
-
-static char* readline(FILE *input)
-{
-	int len;
-
-	if(fgets(line,max_line_len,input) == NULL)
-		return NULL;
-
-	while(strrchr(line,'\n') == NULL)
-	{
-		max_line_len *= 2;
-		line = (char *) realloc(line,max_line_len);
-		len = (int) strlen(line);
-		if(fgets(line+len,max_line_len-len,input) == NULL)
-			break;
-	}
-	return line;
-}
-
-void do_predict(FILE *input, FILE *output)
-{
-	int correct = 0;
-	int total = 0;
-	double error = 0;
-	double sump = 0, sumt = 0, sumpp = 0, sumtt = 0, sumpt = 0;
-
-	int nr_class=get_nr_class(model_);
-	double *prob_estimates=NULL;
-	int j, n;
-	int nr_feature=get_nr_feature(model_);
-	if(model_->bias>=0)
-		n=nr_feature+1;
-	else
-		n=nr_feature;
-
-	if(flag_predict_probability)
-	{
-		int *labels;
-
-		if(!check_probability_model(model_))
-		{
-			fprintf(stderr, "probability output is only supported for logistic regression\n");
-			exit(1);
-		}
-
-		labels=(int *) malloc(nr_class*sizeof(int));
-		get_labels(model_,labels);
-		prob_estimates = (double *) malloc(nr_class*sizeof(double));
-		fprintf(output,"labels");
-		for(j=0;j<nr_class;j++)
-			fprintf(output," %d",labels[j]);
-		fprintf(output,"\n");
-		free(labels);
-	}
-
-	max_line_len = 1024;
-	line = (char *)malloc(max_line_len*sizeof(char));
-	while(readline(input) != NULL)
-	{
-		int i = 0;
-		double target_label, predict_label;
-		char *idx, *val, *label, *endptr;
-		int inst_max_index = 0; // strtol gives 0 if wrong format
-
-		label = strtok(line," \t\n");
-		if(label == NULL) // empty line
-			exit_input_error(total+1);
-
-		target_label = strtod(label,&endptr);
-		if(endptr == label || *endptr != '\0')
-			exit_input_error(total+1);
-
-		while(1)
-		{
-			if(i>=max_nr_attr-2)	// need one more for index = -1
-			{
-				max_nr_attr *= 2;
-				x = (struct feature_node *) realloc(x,max_nr_attr*sizeof(struct feature_node));
-			}
-
-			idx = strtok(NULL,":");
-			val = strtok(NULL," \t");
-
-			if(val == NULL)
-				break;
-			errno = 0;
-			x[i].index = (int) strtol(idx,&endptr,10);
-			if(endptr == idx || errno != 0 || *endptr != '\0' || x[i].index <= inst_max_index)
-				exit_input_error(total+1);
-			else
-				inst_max_index = x[i].index;
-
-			errno = 0;
-			x[i].value = strtod(val,&endptr);
-			if(endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
-				exit_input_error(total+1);
-
-			// feature indices larger than those in training are not used
-			if(x[i].index <= nr_feature)
-				++i;
-		}
-
-		if(model_->bias>=0)
-		{
-			x[i].index = n;
-			x[i].value = model_->bias;
-			i++;
-		}
-		x[i].index = -1;
-
-		if(flag_predict_probability)
-		{
-			int j;
-			predict_label = predict_probability(model_,x,prob_estimates);
-			fprintf(output,"%g",predict_label);
-			for(j=0;j<model_->nr_class;j++)
-				fprintf(output," %g",prob_estimates[j]);
-			fprintf(output,"\n");
-		}
-		else
-		{
-			predict_label = predict(model_,x);
-			fprintf(output,"%g\n",predict_label);
-		}
-
-		if(predict_label == target_label)
-			++correct;
-		error += (predict_label-target_label)*(predict_label-target_label);
-		sump += predict_label;
-		sumt += target_label;
-		sumpp += predict_label*predict_label;
-		sumtt += target_label*target_label;
-		sumpt += predict_label*target_label;
-		++total;
-	}
-	if(check_regression_model(model_))
-	{
-		info("Mean squared error = %g (regression)\n",error/total);
-		info("Squared correlation coefficient = %g (regression)\n",
-			((total*sumpt-sump*sumt)*(total*sumpt-sump*sumt))/
-			((total*sumpp-sump*sump)*(total*sumtt-sumt*sumt))
-			);
-	}
-	else
-		info("Accuracy = %g%% (%d/%d)\n",(double) correct/total*100,correct,total);
-	if(flag_predict_probability)
-		free(prob_estimates);
-}
-
-void exit_with_help()
-{
-	printf(
-	"Usage: predict [options] test_file model_file output_file\n"
-	"options:\n"
-	"-b probability_estimates: whether to output probability estimates, 0 or 1 (default 0); currently for logistic regression only\n"
-	"-q : quiet mode (no outputs)\n"
-	);
-	exit(1);
-}
-
-int main(int argc, char **argv)
-{
-	FILE *input, *output;
-	int i;
-
-	// parse options
-	for(i=1;i<argc;i++)
-	{
-		if(argv[i][0] != '-') break;
-		++i;
-		switch(argv[i-1][1])
-		{
-			case 'b':
-				flag_predict_probability = atoi(argv[i]);
-				break;
-			case 'q':
-				info = &print_null;
-				i--;
-				break;
-			default:
-				fprintf(stderr,"unknown option: -%c\n", argv[i-1][1]);
-				exit_with_help();
-				break;
-		}
-	}
-	if(i>=argc)
-		exit_with_help();
-
-	input = fopen(argv[i],"r");
-	if(input == NULL)
-	{
-		fprintf(stderr,"can't open input file %s\n",argv[i]);
-		exit(1);
-	}
-
-	output = fopen(argv[i+2],"w");
-	if(output == NULL)
-	{
-		fprintf(stderr,"can't open output file %s\n",argv[i+2]);
-		exit(1);
-	}
-
-	if((model_=load_model(argv[i+1]))==0)
-	{
-		fprintf(stderr,"can't open model file %s\n",argv[i+1]);
-		exit(1);
-	}
-
-	x = (struct feature_node *) malloc(max_nr_attr*sizeof(struct feature_node));
-	do_predict(input, output);
-	free_and_destroy_model(&model_);
-	free(line);
-	free(x);
-	fclose(input);
-	fclose(output);
-	return 0;
-}
-

data/liblinear-2.1/python/Makefile

@@ -1,4 +0,0 @@
-all = lib
-
-lib:
-	make -C .. lib

data/liblinear-2.1/python/README

@@ -1,380 +0,0 @@
--------------------------------------
---- Python interface of 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
->>> 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
->>> 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
-
-    issparse: if issparse == True, zero feature values are removed. The default
-              value is True for the sparsity.
-
-    feature_max: if feature_max is assigned, features with indices larger than
-                 feature_max are removed.
-
-- 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