liblinear-ruby 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: e70466e2b89a0daa504f9dd8a655d759beb40260
-  data.tar.gz: e414010bb3853f7d2609e9e5a2fe34474d86e784
+  metadata.gz: ac700b40f9f8bc42fbb319f6d510b150740556e7
+  data.tar.gz: 1027bf69f4ab2a882c12b0d569ce952a2729c350
 SHA512:
-  metadata.gz: 208a81ca1d8ebe5aaf221797417fbb3501a88f3a3d40310c65691980e3808463f5dc67c04cdea3ecf676b46b824d6506d9bfe0fb0f0d123094f39ae391454ec3
-  data.tar.gz: 848111ae60b0ae8422550f719fdf60d2ad701ee07a723da1c9e4c58e50dbce73f977a52eb1dc5ef8b981102d65d606e6333a15fa84fe1e5759f8852a35066ff9
+  metadata.gz: 4ea3e62ea0b3977d0a49f5ed700f7e40079c99b144eda439a384cb04de644d21355db4e032f150430c3abc9df4cfea1fdd3828409f119a636dd01fbcc63b254e
+  data.tar.gz: 610cf9eab7d391d5c4ee1767e28accc957c158402a15d5bd637c55eaa1bf960218f5d52581752499ffbb77dab3bd5e65a0e8d14a12ee9772047d14ac76077269

data/README.md

@@ -1,8 +1,8 @@
 # Liblinear-Ruby
 [![Gem Version](https://badge.fury.io/rb/liblinear-ruby.png)](http://badge.fury.io/rb/liblinear-ruby)
 
-Liblinear-Ruby is Ruby interface to LIBLINEAR using SWIG.  
-Now, this interface is supporting LIBLINEAR 1.94.
+Liblinear-Ruby is Ruby interface to LIBLINEAR using SWIG.
+Now, this interface is supporting LIBLINEAR 1.95.
 
 ## Installation
 
@@ -39,6 +39,10 @@ model = Liblinear::Model.new(prob, param)
 
 # Predicting phase
 puts model.predict({1=>1, 2=>1, 3=>1, 4=>1, 5=>1}) # => -1.0
+
+# Analyzing phase
+puts model.coefficient
+puts model.bias
 ```
 ## Usage
 
@@ -147,7 +151,6 @@ model = Liblinear::Model.new(prob, param)
 ```
 If you have already had a model file, you can load it as:
 ```ruby
-prob = Liblinear::Problem.new(labels, examples, bias)
 model = Liblinear::Model.new(model_file)
 ```
 In this phase, you can save model as:

data/ext/liblinear_wrap.cxx

@@ -3681,6 +3681,78 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_get_decfun_coef(int argc, VALUE *argv, VALUE self) {
+  model *arg1 = (model *) 0 ;
+  int arg2 ;
+  int arg3 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  int val3 ;
+  int ecode3 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 3) || (argc > 3)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 3)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_model, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "model const *","get_decfun_coef", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< model * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get_decfun_coef", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  ecode3 = SWIG_AsVal_int(argv[2], &val3);
+  if (!SWIG_IsOK(ecode3)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode3), Ruby_Format_TypeError( "", "int","get_decfun_coef", 3, argv[2] ));
+  } 
+  arg3 = static_cast< int >(val3);
+  result = (double)get_decfun_coef((model const *)arg1,arg2,arg3);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
+SWIGINTERN VALUE
+_wrap_get_decfun_bias(int argc, VALUE *argv, VALUE self) {
+  model *arg1 = (model *) 0 ;
+  int arg2 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int val2 ;
+  int ecode2 = 0 ;
+  double result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 2) || (argc > 2)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 2)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_model, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "model const *","get_decfun_bias", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< model * >(argp1);
+  ecode2 = SWIG_AsVal_int(argv[1], &val2);
+  if (!SWIG_IsOK(ecode2)) {
+    SWIG_exception_fail(SWIG_ArgError(ecode2), Ruby_Format_TypeError( "", "int","get_decfun_bias", 2, argv[1] ));
+  } 
+  arg2 = static_cast< int >(val2);
+  result = (double)get_decfun_bias((model const *)arg1,arg2);
+  vresult = SWIG_From_double(static_cast< double >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_free_model_content(int argc, VALUE *argv, VALUE self) {
   model *arg1 = (model *) 0 ;
@@ -3800,6 +3872,30 @@ fail:
 }
 
 
+SWIGINTERN VALUE
+_wrap_check_regression_model(int argc, VALUE *argv, VALUE self) {
+  model *arg1 = (model *) 0 ;
+  void *argp1 = 0 ;
+  int res1 = 0 ;
+  int result;
+  VALUE vresult = Qnil;
+  
+  if ((argc < 1) || (argc > 1)) {
+    rb_raise(rb_eArgError, "wrong # of arguments(%d for 1)",argc); SWIG_fail;
+  }
+  res1 = SWIG_ConvertPtr(argv[0], &argp1,SWIGTYPE_p_model, 0 |  0 );
+  if (!SWIG_IsOK(res1)) {
+    SWIG_exception_fail(SWIG_ArgError(res1), Ruby_Format_TypeError( "", "model const *","check_regression_model", 1, argv[0] )); 
+  }
+  arg1 = reinterpret_cast< model * >(argp1);
+  result = (int)check_regression_model((model const *)arg1);
+  vresult = SWIG_From_int(static_cast< int >(result));
+  return vresult;
+fail:
+  return Qnil;
+}
+
+
 SWIGINTERN VALUE
 _wrap_set_print_string_function(int argc, VALUE *argv, VALUE self) {
   void (*arg1)(char const *) = (void (*)(char const *)) 0 ;
@@ -4622,11 +4718,14 @@ SWIGEXPORT void Init_liblinearswig(void) {
   rb_define_module_function(mLiblinearswig, "get_nr_feature", VALUEFUNC(_wrap_get_nr_feature), -1);
   rb_define_module_function(mLiblinearswig, "get_nr_class", VALUEFUNC(_wrap_get_nr_class), -1);
   rb_define_module_function(mLiblinearswig, "get_labels", VALUEFUNC(_wrap_get_labels), -1);
+  rb_define_module_function(mLiblinearswig, "get_decfun_coef", VALUEFUNC(_wrap_get_decfun_coef), -1);
+  rb_define_module_function(mLiblinearswig, "get_decfun_bias", VALUEFUNC(_wrap_get_decfun_bias), -1);
   rb_define_module_function(mLiblinearswig, "free_model_content", VALUEFUNC(_wrap_free_model_content), -1);
   rb_define_module_function(mLiblinearswig, "free_and_destroy_model", VALUEFUNC(_wrap_free_and_destroy_model), -1);
   rb_define_module_function(mLiblinearswig, "destroy_param", VALUEFUNC(_wrap_destroy_param), -1);
   rb_define_module_function(mLiblinearswig, "check_parameter", VALUEFUNC(_wrap_check_parameter), -1);
   rb_define_module_function(mLiblinearswig, "check_probability_model", VALUEFUNC(_wrap_check_probability_model), -1);
+  rb_define_module_function(mLiblinearswig, "check_regression_model", VALUEFUNC(_wrap_check_regression_model), -1);
   rb_define_module_function(mLiblinearswig, "set_print_string_function", VALUEFUNC(_wrap_set_print_string_function), -1);
   rb_define_module_function(mLiblinearswig, "new_int", VALUEFUNC(_wrap_new_int), -1);
   rb_define_module_function(mLiblinearswig, "delete_int", VALUEFUNC(_wrap_delete_int), -1);

data/ext/linear.cpp

@@ -1010,7 +1010,7 @@ static void solve_l2r_l1l2_svr(
 	double d, G, H;
 	double Gmax_old = INF;
 	double Gmax_new, Gnorm1_new;
-	double Gnorm1_init;
+	double Gnorm1_init = -1.0; // Gnorm1_init is initialized at the first iteration
 	double *beta = new double[l];
 	double *QD = new double[l];
 	double *y = prob->y;
@@ -1409,7 +1409,7 @@ static void solve_l1r_l2_svc(
 	double d, G_loss, G, H;
 	double Gmax_old = INF;
 	double Gmax_new, Gnorm1_new;
-	double Gnorm1_init;
+	double Gnorm1_init = -1.0; // Gnorm1_init is initialized at the first iteration
 	double d_old, d_diff;
 	double loss_old, loss_new;
 	double appxcond, cond;
@@ -1699,7 +1699,7 @@ static void solve_l1r_lr(
 	double sigma = 0.01;
 	double w_norm, w_norm_new;
 	double z, G, H;
-	double Gnorm1_init;
+	double Gnorm1_init = -1.0; // Gnorm1_init is initialized at the first iteration
 	double Gmax_old = INF;
 	double Gmax_new, Gnorm1_new;
 	double QP_Gmax_old = INF;
@@ -2051,8 +2051,8 @@ static void transpose(const problem *prob, feature_node **x_space_ret, problem *
 	int i;
 	int l = prob->l;
 	int n = prob->n;
-	long int nnz = 0;
-	long int *col_ptr = new long int [n+1];
+	size_t nnz = 0;
+	size_t *col_ptr = new size_t [n+1];
 	feature_node *x_space;
 	prob_col->l = l;
 	prob_col->n = n;
@@ -2305,9 +2305,7 @@ model* train(const problem *prob, const parameter *param)
 	model_->param = *param;
 	model_->bias = prob->bias;
 
-	if(param->solver_type == L2R_L2LOSS_SVR ||
-	   param->solver_type == L2R_L1LOSS_SVR_DUAL ||
-	   param->solver_type == L2R_L2LOSS_SVR_DUAL)
+	if(check_regression_model(model_))
 	{
 		model_->w = Malloc(double, w_size);
 		model_->nr_class = 2;
@@ -2512,9 +2510,7 @@ double predict_values(const struct model *model_, const struct feature_node *x,
 
 	if(nr_class==2)
 	{
-		if(model_->param.solver_type == L2R_L2LOSS_SVR ||
-		   model_->param.solver_type == L2R_L1LOSS_SVR_DUAL ||
-		   model_->param.solver_type == L2R_L2LOSS_SVR_DUAL)
+		if(check_regression_model(model_))
 			return dec_values[0];
 		else
 			return (dec_values[0]>0)?model_->label[0]:model_->label[1];
@@ -2764,6 +2760,53 @@ void get_labels(const model *model_, int* label)
 			label[i] = model_->label[i];
 }
 
+// use inline here for better performance (around 20% faster than the non-inline one)
+static inline double get_w_value(const struct model *model_, int idx, int label_idx) 
+{
+	int nr_class = model_->nr_class;
+	int solver_type = model_->param.solver_type;
+	const double *w = model_->w;
+
+	if(idx < 0 || idx > model_->nr_feature)
+		return 0;
+	if(check_regression_model(model_))
+		return w[idx];
+	else 
+	{
+		if(label_idx < 0 || label_idx >= nr_class)
+			return 0;
+		if(nr_class == 2 && solver_type != MCSVM_CS)
+		{
+			if(label_idx == 0)
+				return w[idx];
+			else
+				return -w[idx];
+		}
+		else
+			return w[idx*nr_class+label_idx];
+	}
+}
+
+// feat_idx: starting from 1 to nr_feature
+// label_idx: starting from 0 to nr_class-1 for classification models;
+//            for regression models, label_idx is ignored.
+double get_decfun_coef(const struct model *model_, int feat_idx, int label_idx)
+{
+	if(feat_idx > model_->nr_feature)
+		return 0;
+	return get_w_value(model_, feat_idx-1, label_idx);
+}
+
+double get_decfun_bias(const struct model *model_, int label_idx)
+{
+	int bias_idx = model_->nr_feature;
+	double bias = model_->bias;
+	if(bias <= 0)
+		return 0;
+	else
+		return bias*get_w_value(model_, bias_idx, label_idx);
+}
+
 void free_model_content(struct model *model_ptr)
 {
 	if(model_ptr->w != NULL)
@@ -2824,6 +2867,13 @@ int check_probability_model(const struct model *model_)
 			model_->param.solver_type==L1R_LR);
 }
 
+int check_regression_model(const struct model *model_)
+{
+	return (model_->param.solver_type==L2R_L2LOSS_SVR ||
+			model_->param.solver_type==L2R_L1LOSS_SVR_DUAL ||
+			model_->param.solver_type==L2R_L2LOSS_SVR_DUAL);
+}
+
 void set_print_string_function(void (*print_func)(const char*))
 {
 	if (print_func == NULL)

data/ext/linear.h

@@ -57,6 +57,8 @@ 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);
+double get_decfun_coef(const struct model *model_, int feat_idx, int label_idx);
+double get_decfun_bias(const struct model *model_, int label_idx);
 
 void free_model_content(struct model *model_ptr);
 void free_and_destroy_model(struct model **model_ptr_ptr);
@@ -64,6 +66,7 @@ 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);
+int check_regression_model(const struct model *model);
 void set_print_string_function(void (*print_func) (const char*));
 
 #ifdef __cplusplus

data/lib/liblinear/model.rb

@@ -23,15 +23,26 @@ module Liblinear
     end
 
     # @return [Integer]
-    def nr_class
+    def class_size
       get_nr_class(@model)
     end
 
+    # @return [Integer]
+    def nr_class
+      warn "'nr_class' is deprecated. Please use 'class_size' instead."
+      class_size
+    end
+
+    # @return [Integer]
+    def feature_size
+      get_nr_feature(@model)
+    end
+
     # @return [Array <Integer>]
     def labels
-      c_int_array = new_int(nr_class)
+      c_int_array = new_int(class_size)
       get_labels(@model, c_int_array)
-      labels = int_array_c_to_ruby(c_int_array, nr_class)
+      labels = int_array_c_to_ruby(c_int_array, class_size)
       delete_int(c_int_array)
       labels
     end
@@ -62,14 +73,34 @@ module Liblinear
       save_model(filename, @model)
     end
 
-    private 
+    # @param feature_index [Integer]
+    # @param label_index [Integer]
+    # @return [Double, Array <Double>]
+    def coefficient(feature_index = nil, label_index = 0)
+      return get_decfun_coef(@model, feature_index, label_index) if feature_index
+      coefficients = []
+      feature_size.times.map {|feature_index| get_decfun_coef(@model, feature_index + 1, label_index)}
+    end
+
+    # @param label_index [Integer]
+    # @return [Double]
+    def bias(label_index = 0)
+      get_decfun_bias(@model, label_index)
+    end
+
+    # @return [Boolean]
+    def regression_model?
+      check_regression_model(@model) == 1 ? true : false
+    end
+
+    private
     # @param example [Array, Hash]
     # @return [Hash]
     def predict_prob_val(example, liblinear_func)
       feature_nodes = convert_to_feature_node_array(example, @model.nr_feature, @model.bias)
-      c_double_array = Liblinearswig.new_double(nr_class)
+      c_double_array = new_double(class_size)
       Liblinearswig.send(liblinear_func, @model, feature_nodes, c_double_array)
-      values = double_array_c_to_ruby(c_double_array, nr_class)
+      values = double_array_c_to_ruby(c_double_array, class_size)
       delete_double(c_double_array)
       feature_node_array_destroy(feature_nodes)
       value_list = {}

data/lib/liblinear/version.rb

@@ -1,3 +1,3 @@
 module Liblinear
-  VERSION = '0.0.4'
+  VERSION = '0.0.5'
 end

data/{liblinear-1.94 → liblinear-1.95}/COPYRIGHT

@@ -1,5 +1,5 @@
 
-Copyright (c) 2007-2013 The LIBLINEAR Project.
+Copyright (c) 2007-2014 The LIBLINEAR Project.
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/{liblinear-1.94 → liblinear-1.95}/Makefile

@@ -2,7 +2,7 @@ CXX ?= g++
 CC ?= gcc
 CFLAGS = -Wall -Wconversion -O3 -fPIC
 LIBS = blas/blas.a
-SHVER = 1
+SHVER = 2
 OS = $(shell uname)
 #LIBS = -lblas
 

data/{liblinear-1.94 → liblinear-1.95}/Makefile.win

@@ -5,7 +5,7 @@
 
 ##########################################
 CXX = cl.exe
-CFLAGS = -nologo -O2 -EHsc -I. -D __WIN32__ -D _CRT_SECURE_NO_DEPRECATE
+CFLAGS = /nologo /O2 /EHsc /I. /D _WIN32 /D _CRT_SECURE_NO_DEPRECATE
 TARGET = windows
 
 all: $(TARGET)\train.exe $(TARGET)\predict.exe

data/{liblinear-1.94 → liblinear-1.95}/README

@@ -123,7 +123,7 @@ options:
 	-s 1, 3, 4 and 7
 		Dual maximal violation <= eps; similar to libsvm (default 0.1)
 	-s 5 and 6
-		|f'(w)|_inf <= eps*min(pos,neg)/l*|f'(w0)|_inf,
+		|f'(w)|_1 <= eps*min(pos,neg)/l*|f'(w0)|_1,
 		where f is the primal function (default 0.01)
 	-s 12 and 13\n"
 		|f'(alpha)|_1 <= eps |f'(alpha0)|,
@@ -448,6 +448,24 @@ Library Usage
     This function outputs the name of labels into an array called label.
     For a regression model, label is unchanged.
 
+- Function: double get_decfun_coef(const struct model *model_, int feat_idx,
+            int label_idx);
+
+    This function gives the coefficient for the feature with feature index =
+    feat_idx and the class with label index = label_idx. Note that feat_idx
+    starts from 1, while label_idx starts from 0. If feat_idx is not in the
+    valid range (1 to nr_feature), then a zero value will be returned. For
+    classification models, if label_idx is not in the valid range (0 to
+    nr_class-1), then a zero value will be returned; for regression models,
+    label_idx is ignored.
+
+- Function: double get_decfun_bias(const struct model *model_, int label_idx);
+
+    This function gives the bias term corresponding to the class with the
+    label_idx. For classification models, if label_idx is not in a valid range
+    (0 to nr_class-1), then a zero value will be returned; for regression
+    models, label_idx is ignored.
+
 - Function: const char *check_parameter(const struct problem *prob,
             const struct parameter *param);
 
@@ -456,6 +474,16 @@ Library Usage
     train() and cross_validation(). It returns NULL if the
     parameters are feasible, otherwise an error message is returned.
 
+- Function: int check_probability_model(const struct model *model);
+
+    This function returns 1 if the model supports probability output;
+    otherwise, it returns 0.
+
+- Function: int check_regression_model(const struct model *model);
+
+    This function returns 1 if the model is a regression model; otherwise
+    it returns 0.
+
 - Function: int save_model(const char *model_file_name,
             const struct model *model_);
 
@@ -504,6 +532,9 @@ VC++ or where it is installed.
 
 nmake -f Makefile.win clean all
 
+2. (Optional) To build 64-bit windows binaries, you must
+	(1) Setup vcvars64.bat instead of vcvars32.bat
+	(2) Change CFLAGS in Makefile.win: /D _WIN32 to /D _WIN64
 
 MATLAB/OCTAVE Interface
 =======================