liblinear-ruby 0.0.1

data/liblinear-1.93/linear.def

@@ -0,0 +1,18 @@
+LIBRARY liblinear
+EXPORTS
+	train	@1
+	cross_validation	@2
+	save_model	@3
+	load_model	@4
+	get_nr_feature	@5
+	get_nr_class	@6
+	get_labels	@7
+	predict_values	@8
+	predict	@9
+	predict_probability	@10
+	free_and_destroy_model	@11
+	free_model_content	@12
+	destroy_param	@13
+	check_parameter	@14
+	check_probability_model	@15
+	set_print_string_function	@16

data/liblinear-1.93/linear.h

@@ -0,0 +1,74 @@
+#ifndef _LIBLINEAR_H
+#define _LIBLINEAR_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct feature_node
+{
+	int index;
+	double value;
+};
+
+struct problem
+{
+	int l, n;
+	double *y;
+	struct feature_node **x;
+	double bias;            /* < 0 if no bias term */  
+};
+
+enum { L2R_LR, L2R_L2LOSS_SVC_DUAL, L2R_L2LOSS_SVC, L2R_L1LOSS_SVC_DUAL, MCSVM_CS, L1R_L2LOSS_SVC, L1R_LR, L2R_LR_DUAL, L2R_L2LOSS_SVR = 11, L2R_L2LOSS_SVR_DUAL, L2R_L1LOSS_SVR_DUAL }; /* solver_type */
+
+struct parameter
+{
+	int solver_type;
+
+	/* these are for training only */
+	double eps;	        /* stopping criteria */
+	double C;
+	int nr_weight;
+	int *weight_label;
+	double* weight;
+	double p;
+};
+
+struct model
+{
+	struct parameter param;
+	int nr_class;		/* number of classes */
+	int nr_feature;
+	double *w;
+	int *label;		/* label of each class */
+	double bias;
+};
+
+struct model* train(const struct problem *prob, const struct parameter *param);
+void cross_validation(const struct problem *prob, const struct parameter *param, int nr_fold, double *target);
+
+double predict_values(const struct model *model_, const struct feature_node *x, double* dec_values);
+double predict(const struct model *model_, const struct feature_node *x);
+double predict_probability(const struct model *model_, const struct feature_node *x, double* prob_estimates);
+
+int save_model(const char *model_file_name, const struct model *model_);
+struct model *load_model(const char *model_file_name);
+
+int get_nr_feature(const struct model *model_);
+int get_nr_class(const struct model *model_);
+void get_labels(const struct model *model_, int* label);
+
+void free_model_content(struct model *model_ptr);
+void free_and_destroy_model(struct model **model_ptr_ptr);
+void destroy_param(struct parameter *param);
+
+const char *check_parameter(const struct problem *prob, const struct parameter *param);
+int check_probability_model(const struct model *model);
+void set_print_string_function(void (*print_func) (const char*));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBLINEAR_H */
+

data/liblinear-1.93/matlab/Makefile

@@ -0,0 +1,58 @@
+# This Makefile is used under Linux
+
+MATLABDIR ?= /usr/local/matlab
+CXX ?= g++
+#CXX = g++-3.3
+CC ?= gcc
+CFLAGS = -Wall -Wconversion -O3 -fPIC -I$(MATLABDIR)/extern/include -I..
+
+MEX = $(MATLABDIR)/bin/mex
+MEX_OPTION = CC\#$(CXX) CXX\#$(CXX) CFLAGS\#"$(CFLAGS)" CXXFLAGS\#"$(CFLAGS)"
+# comment the following line if you use MATLAB on a 32-bit computer
+MEX_OPTION += -largeArrayDims
+MEX_EXT = $(shell $(MATLABDIR)/bin/mexext)
+
+OCTAVEDIR ?= /usr/include/octave
+OCTAVE_MEX = env CC=$(CXX) mkoctfile
+OCTAVE_MEX_OPTION = --mex
+OCTAVE_MEX_EXT = mex
+OCTAVE_CFLAGS = -Wall -O3 -fPIC -I$(OCTAVEDIR) -I..
+
+all:	matlab
+
+matlab:	binary
+
+octave:
+	@make MEX="$(OCTAVE_MEX)" MEX_OPTION="$(OCTAVE_MEX_OPTION)" \
+	MEX_EXT="$(OCTAVE_MEX_EXT)" CFLAGS="$(OCTAVE_CFLAGS)" \
+	binary
+
+binary: train.$(MEX_EXT) predict.$(MEX_EXT) libsvmread.$(MEX_EXT) libsvmwrite.$(MEX_EXT)
+
+train.$(MEX_EXT): train.c ../linear.h ../tron.o ../linear.o linear_model_matlab.o ../blas/blas.a
+	$(MEX) $(MEX_OPTION) train.c ../tron.o ../linear.o linear_model_matlab.o ../blas/blas.a
+
+predict.$(MEX_EXT): predict.c ../linear.h ../tron.o ../linear.o linear_model_matlab.o ../blas/blas.a
+	$(MEX) $(MEX_OPTION) predict.c ../tron.o ../linear.o linear_model_matlab.o ../blas/blas.a
+
+libsvmread.$(MEX_EXT):	libsvmread.c
+	$(MEX) $(MEX_OPTION) libsvmread.c
+
+libsvmwrite.$(MEX_EXT):	libsvmwrite.c
+	$(MEX) $(MEX_OPTION) libsvmwrite.c
+
+linear_model_matlab.o: linear_model_matlab.c ../linear.h
+	$(CXX) $(CFLAGS) -c linear_model_matlab.c
+
+../linear.o: ../linear.cpp ../linear.h
+	make -C .. linear.o
+
+../tron.o: ../tron.cpp ../tron.h 
+	make -C .. tron.o
+
+../blas/blas.a: ../blas/*.c ../blas/*.h
+	make -C ../blas OPTFLAGS='$(CFLAGS)' CC='$(CC)';
+
+clean:
+	make -C ../blas clean
+	rm -f *~ *.o *.mex* *.obj ../linear.o ../tron.o

data/liblinear-1.93/matlab/README

@@ -0,0 +1,197 @@
+--------------------------------------------
+--- MATLAB/OCTAVE interface of LIBLINEAR ---
+--------------------------------------------
+
+Table of Contents
+=================
+
+- Introduction
+- Installation
+- Usage
+- Returned Model Structure
+- Other Utilities
+- Examples
+- Additional Information
+
+
+Introduction
+============
+
+This tool provides a simple interface to LIBLINEAR, a library for
+large-scale regularized linear classification and regression
+(http://www.csie.ntu.edu.tw/~cjlin/liblinear).  It is very easy to use
+as the usage and the way of specifying parameters are the same as that
+of LIBLINEAR.
+
+Installation
+============
+
+On Windows systems, pre-built binary files are already in the
+directory '..\windows', so no need to conduct installation. Now we
+provide binary files only for 64bit MATLAB on Windows. If you would
+like to re-build the package, please rely on the following steps.
+
+We recommend using make.m on both MATLAB and OCTAVE. Just type 'make'
+to build 'libsvmread.mex', 'libsvmwrite.mex', 'train.mex', and
+'predict.mex'.
+
+On MATLAB or Octave:
+
+        >> make
+
+If make.m does not work on MATLAB (especially for Windows), try 'mex
+-setup' to choose a suitable compiler for mex. Make sure your compiler
+is accessible and workable. Then type 'make' to start the
+installation.
+
+Example:
+
+        matlab>> mex -setup
+        (ps: MATLAB will show the following messages to setup default compiler.)
+        Please choose your compiler for building external interface (MEX) files:
+        Would you like mex to locate installed compilers [y]/n? y
+        Select a compiler:
+        [1] Microsoft Visual C/C++ version 7.1 in C:\Program Files\Microsoft Visual Studio
+        [0] None
+        Compiler: 1
+        Please verify your choices:
+        Compiler: Microsoft Visual C/C++ 7.1
+        Location: C:\Program Files\Microsoft Visual Studio
+        Are these correct?([y]/n): y
+
+        matlab>> make
+
+On Unix systems, if neither make.m nor 'mex -setup' works, please use
+Makefile and type 'make' in a command window. Note that we assume
+your MATLAB is installed in '/usr/local/matlab'. If not, please change
+MATLABDIR in Makefile.
+
+Example:
+        linux> make
+
+To use octave, type 'make octave':
+
+Example:
+        linux> make octave
+
+For a list of supported/compatible compilers for MATLAB, please check
+the following page:
+
+http://www.mathworks.com/support/compilers/current_release/
+
+Usage
+=====
+
+matlab> model = train(training_label_vector, training_instance_matrix [,'liblinear_options', 'col']);
+
+        -training_label_vector:
+            An m by 1 vector of training labels. (type must be double)
+        -training_instance_matrix:
+            An m by n matrix of m training instances with n features.
+            It must be a sparse matrix. (type must be double)
+        -liblinear_options:
+            A string of training options in the same format as that of LIBLINEAR.
+        -col:
+            if 'col' is set, each column of training_instance_matrix is a data instance. Otherwise each row is a data instance.
+
+matlab> [predicted_label, accuracy, decision_values/prob_estimates] = predict(testing_label_vector, testing_instance_matrix, model [, 'liblinear_options', 'col']);
+
+        -testing_label_vector:
+            An m by 1 vector of prediction labels. If labels of test
+            data are unknown, simply use any random values. (type must be double)
+        -testing_instance_matrix:
+            An m by n matrix of m testing instances with n features.
+            It must be a sparse matrix. (type must be double)
+        -model:
+            The output of train.
+        -liblinear_options:
+            A string of testing options in the same format as that of LIBLINEAR.
+        -col:
+            if 'col' is set, each column of testing_instance_matrix is a data instance. Otherwise each row is a data instance.
+
+Returned Model Structure
+========================
+
+The 'train' function returns a model which can be used for future
+prediction.  It is a structure and is organized as [Parameters, nr_class,
+nr_feature, bias, Label, w]:
+
+        -Parameters: Parameters
+        -nr_class: number of classes; = 2 for regression
+        -nr_feature: number of features in training data (without including the bias term)
+        -bias: If >= 0, we assume one additional feature is added to the end
+            of each data instance.
+        -Label: label of each class; empty for regression
+        -w: a nr_w-by-n matrix for the weights, where n is nr_feature
+            or nr_feature+1 depending on the existence of the bias term.
+            nr_w is 1 if nr_class=2 and -s is not 4 (i.e., not
+            multi-class svm by Crammer and Singer). It is
+            nr_class otherwise.
+
+If the '-v' option 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.
+
+Result of Prediction
+====================
+
+The function 'predict' has three outputs. The first one,
+predicted_label, is a vector of predicted labels. The second output,
+accuracy, is a vector including accuracy (for classification), mean
+squared error, and squared correlation coefficient (for regression).
+The third is a matrix containing decision values or probability
+estimates (if '-b 1' is specified). If k is the number of classes
+and k' is the number of classifiers (k'=1 if k=2, otherwise k'=k), for decision values,
+each row includes results of k' binary linear classifiers. For probabilities,
+each row 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 'Label'
+field in the model structure.
+
+Other Utilities
+===============
+
+A matlab function libsvmread reads files in LIBSVM format: 
+
+[label_vector, instance_matrix] = libsvmread('data.txt'); 
+
+Two outputs are labels and instances, which can then be used as inputs
+of svmtrain or svmpredict. 
+
+A matlab function libsvmwrite writes Matlab matrix to a file in LIBSVM format:
+
+libsvmwrite('data.txt', label_vector, instance_matrix]
+
+The instance_matrix must be a sparse matrix. (type must be double)
+For windows, `libsvmread.mexw64' and `libsvmwrite.mexw64' are ready in 
+the directory `..\windows'.
+
+These codes are prepared by Rong-En Fan and Kai-Wei Chang from National
+Taiwan University.
+
+Examples
+========
+
+Train and test on the provided data heart_scale:
+
+matlab> [heart_scale_label, heart_scale_inst] = libsvmread('../heart_scale');
+matlab> model = train(heart_scale_label, heart_scale_inst, '-c 1');
+matlab> [predict_label, accuracy, dec_values] = predict(heart_scale_label, heart_scale_inst, model); % test the training data
+
+Note that for testing, you can put anything in the testing_label_vector.
+
+For probability estimates, you need '-b 1' only in the testing phase:
+
+matlab> [predict_label, accuracy, prob_estimates] = predict(heart_scale_label, heart_scale_inst, model, '-b 1');
+
+Additional Information
+======================
+
+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>.
+

data/liblinear-1.93/matlab/libsvmread.c

@@ -0,0 +1,212 @@
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <ctype.h>
+#include <errno.h>
+
+#include "mex.h"
+
+#ifdef MX_API_VER
+#if MX_API_VER < 0x07030000
+typedef int mwIndex;
+#endif 
+#endif 
+#ifndef max
+#define max(x,y) (((x)>(y))?(x):(y))
+#endif
+#ifndef min
+#define min(x,y) (((x)<(y))?(x):(y))
+#endif
+
+void exit_with_help()
+{
+	mexPrintf(
+	"Usage: [label_vector, instance_matrix] = libsvmread('filename');\n"
+	);
+}
+
+static void fake_answer(mxArray *plhs[])
+{
+	plhs[0] = mxCreateDoubleMatrix(0, 0, mxREAL);
+	plhs[1] = mxCreateDoubleMatrix(0, 0, mxREAL);
+}
+
+static char *line;
+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;
+}
+
+// read in a problem (in libsvm format)
+void read_problem(const char *filename, mxArray *plhs[])
+{
+	int max_index, min_index, inst_max_index, i;
+	long elements, k;
+	FILE *fp = fopen(filename,"r");
+	int l = 0;
+	char *endptr;
+	mwIndex *ir, *jc;
+	double *labels, *samples;
+	
+	if(fp == NULL)
+	{
+		mexPrintf("can't open input file %s\n",filename);
+		fake_answer(plhs);
+		return;
+	}
+
+	max_line_len = 1024;
+	line = (char *) malloc(max_line_len*sizeof(char));
+
+	max_index = 0;
+	min_index = 1; // our index starts from 1
+	elements = 0;
+	while(readline(fp) != NULL)
+	{
+		char *idx, *val;
+		// features
+		int index = 0;
+
+		inst_max_index = -1; // strtol gives 0 if wrong format, and precomputed kernel has <index> start from 0
+		strtok(line," \t"); // label
+		while (1)
+		{
+			idx = strtok(NULL,":"); // index:value
+			val = strtok(NULL," \t");
+			if(val == NULL)
+				break;
+
+			errno = 0;
+			index = (int) strtol(idx,&endptr,10);
+			if(endptr == idx || errno != 0 || *endptr != '\0' || index <= inst_max_index)
+			{
+				mexPrintf("Wrong input format at line %d\n",l+1);
+				fake_answer(plhs);
+				return;
+			}
+			else
+				inst_max_index = index;
+
+			min_index = min(min_index, index);
+			elements++;
+		}
+		max_index = max(max_index, inst_max_index);
+		l++;
+	}
+	rewind(fp);
+
+	// y
+	plhs[0] = mxCreateDoubleMatrix(l, 1, mxREAL);
+	// x^T
+	if (min_index <= 0)
+		plhs[1] = mxCreateSparse(max_index-min_index+1, l, elements, mxREAL);
+	else
+		plhs[1] = mxCreateSparse(max_index, l, elements, mxREAL);
+
+	labels = mxGetPr(plhs[0]);
+	samples = mxGetPr(plhs[1]);
+	ir = mxGetIr(plhs[1]);
+	jc = mxGetJc(plhs[1]);
+
+	k=0;
+	for(i=0;i<l;i++)
+	{
+		char *idx, *val, *label;
+		jc[i] = k;
+
+		readline(fp);
+
+		label = strtok(line," \t\n");
+		if(label == NULL)
+		{
+			mexPrintf("Empty line at line %d\n",i+1);
+			fake_answer(plhs);
+			return;
+		}
+		labels[i] = strtod(label,&endptr);
+		if(endptr == label || *endptr != '\0')
+		{
+			mexPrintf("Wrong input format at line %d\n",i+1);
+			fake_answer(plhs);
+			return;
+		}
+
+		// features
+		while(1)
+		{
+			idx = strtok(NULL,":");
+			val = strtok(NULL," \t");
+			if(val == NULL)
+				break;
+
+			ir[k] = (mwIndex) (strtol(idx,&endptr,10) - min_index); // precomputed kernel has <index> start from 0
+
+			errno = 0;
+			samples[k] = strtod(val,&endptr);
+			if (endptr == val || errno != 0 || (*endptr != '\0' && !isspace(*endptr)))
+			{
+				mexPrintf("Wrong input format at line %d\n",i+1);
+				fake_answer(plhs);
+				return;
+			}
+			++k;
+		}
+	}
+	jc[l] = k;
+
+	fclose(fp);
+	free(line);
+
+	{
+		mxArray *rhs[1], *lhs[1];
+		rhs[0] = plhs[1];
+		if(mexCallMATLAB(1, lhs, 1, rhs, "transpose"))
+		{
+			mexPrintf("Error: cannot transpose problem\n");
+			fake_answer(plhs);
+			return;
+		}
+		plhs[1] = lhs[0];
+	}
+}
+
+void mexFunction( int nlhs, mxArray *plhs[],
+		int nrhs, const mxArray *prhs[] )
+{
+	if(nrhs == 1)
+	{
+		char filename[256];
+
+		mxGetString(prhs[0], filename, mxGetN(prhs[0]) + 1);
+
+		if(filename == NULL)
+		{
+			mexPrintf("Error: filename is NULL\n");
+			return;
+		}
+
+		read_problem(filename, plhs);
+	}
+	else
+	{
+		exit_with_help();
+		fake_answer(plhs);
+		return;
+	}
+}
+