numo-libsvm 0.2.0 → 1.0.1

data/ext/numo/libsvm/libsvm/svm.h

@@ -0,0 +1,104 @@
+#ifndef _LIBSVM_H
+#define _LIBSVM_H
+
+#define LIBSVM_VERSION 324
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+extern int libsvm_version;
+
+struct svm_node
+{
+	int index;
+	double value;
+};
+
+struct svm_problem
+{
+	int l;
+	double *y;
+	struct svm_node **x;
+};
+
+enum { C_SVC, NU_SVC, ONE_CLASS, EPSILON_SVR, NU_SVR };	/* svm_type */
+enum { LINEAR, POLY, RBF, SIGMOID, PRECOMPUTED }; /* kernel_type */
+
+struct svm_parameter
+{
+	int svm_type;
+	int kernel_type;
+	int degree;	/* for poly */
+	double gamma;	/* for poly/rbf/sigmoid */
+	double coef0;	/* for poly/sigmoid */
+
+	/* these are for training only */
+	double cache_size; /* in MB */
+	double eps;	/* stopping criteria */
+	double C;	/* for C_SVC, EPSILON_SVR and NU_SVR */
+	int nr_weight;		/* for C_SVC */
+	int *weight_label;	/* for C_SVC */
+	double* weight;		/* for C_SVC */
+	double nu;	/* for NU_SVC, ONE_CLASS, and NU_SVR */
+	double p;	/* for EPSILON_SVR */
+	int shrinking;	/* use the shrinking heuristics */
+	int probability; /* do probability estimates */
+};
+
+//
+// svm_model
+//
+struct svm_model
+{
+	struct svm_parameter param;	/* parameter */
+	int nr_class;		/* number of classes, = 2 in regression/one class svm */
+	int l;			/* total #SV */
+	struct svm_node **SV;		/* SVs (SV[l]) */
+	double **sv_coef;	/* coefficients for SVs in decision functions (sv_coef[k-1][l]) */
+	double *rho;		/* constants in decision functions (rho[k*(k-1)/2]) */
+	double *probA;		/* pariwise probability information */
+	double *probB;
+	int *sv_indices;        /* sv_indices[0,...,nSV-1] are values in [1,...,num_traning_data] to indicate SVs in the training set */
+
+	/* for classification only */
+
+	int *label;		/* label of each class (label[k]) */
+	int *nSV;		/* number of SVs for each class (nSV[k]) */
+				/* nSV[0] + nSV[1] + ... + nSV[k-1] = l */
+	/* XXX */
+	int free_sv;		/* 1 if svm_model is created by svm_load_model*/
+				/* 0 if svm_model is created by svm_train */
+};
+
+struct svm_model *svm_train(const struct svm_problem *prob, const struct svm_parameter *param);
+void svm_cross_validation(const struct svm_problem *prob, const struct svm_parameter *param, int nr_fold, double *target);
+
+int svm_save_model(const char *model_file_name, const struct svm_model *model);
+struct svm_model *svm_load_model(const char *model_file_name);
+
+int svm_get_svm_type(const struct svm_model *model);
+int svm_get_nr_class(const struct svm_model *model);
+void svm_get_labels(const struct svm_model *model, int *label);
+void svm_get_sv_indices(const struct svm_model *model, int *sv_indices);
+int svm_get_nr_sv(const struct svm_model *model);
+double svm_get_svr_probability(const struct svm_model *model);
+
+double svm_predict_values(const struct svm_model *model, const struct svm_node *x, double* dec_values);
+double svm_predict(const struct svm_model *model, const struct svm_node *x);
+double svm_predict_probability(const struct svm_model *model, const struct svm_node *x, double* prob_estimates);
+
+void svm_free_model_content(struct svm_model *model_ptr);
+void svm_free_and_destroy_model(struct svm_model **model_ptr_ptr);
+void svm_destroy_param(struct svm_parameter *param);
+
+const char *svm_check_parameter(const struct svm_problem *prob, const struct svm_parameter *param);
+int svm_check_probability_model(const struct svm_model *model);
+
+void svm_set_print_string_function(void (*print_func)(const char *));
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* _LIBSVM_H */

data/ext/numo/libsvm/libsvmext.c

@@ -16,6 +16,30 @@ void print_null(const char *s) {}
  *   @param y [Numo::DFloat] (shape: [n_samples]) The labels or target values for samples.
  *   @param param [Hash] The parameters of an SVM model.
  *
+ * @example
+ *   require 'numo/libsvm'
+ *
+ *   # Prepare XOR data.
+ *   x = Numo::DFloat[[-0.8, -0.7], [0.9, 0.8], [-0.7, 0.9], [0.8, -0.9]]
+ *   y = Numo::Int32[-1, -1, 1, 1]
+ *
+ *   # Train C-Support Vector Classifier with RBF kernel.
+ *   param = {
+ *     svm_type: Numo::Libsvm::SvmType::C_SVC,
+ *     kernel_type: Numo::Libsvm::KernelType::RBF,
+ *     gamma: 2.0,
+ *     C: 1,
+ *     random_seed: 1
+ *   }
+ *   model = Numo::Libsvm.train(x, y, param)
+ *
+ *   # Predict labels of test data.
+ *   x_test = Numo::DFloat[[-0.4, -0.5], [0.5, -0.4]]
+ *   result = Numo::Libsvm.predict(x_test, param, model)
+ *   p result
+ *   # Numo::DFloat#shape=[2]
+ *   # [-1, 1]
+ *
  * @raise [ArgumentError] If the sample array is not 2-dimensional, the label array is not 1-dimensional,
  *   the sample array and label array do not have the same number of samples, or
  *   the hyperparameter has an invalid value, this error is raised.
@@ -30,6 +54,8 @@ VALUE train(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash)
   narray_t* x_nary;
   narray_t* y_nary;
   char* err_msg;
+  VALUE random_seed;
+  VALUE verbose;
   VALUE model_hash;
 
   if (CLASS_OF(x_val) != numo_cDFloat) {
@@ -60,6 +86,11 @@ VALUE train(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash)
     return Qnil;
   }
 
+  random_seed = rb_hash_aref(param_hash, ID2SYM(rb_intern("random_seed")));
+  if (!NIL_P(random_seed)) {
+    srand(NUM2UINT(random_seed));
+  }
+
   param = rb_hash_to_svm_parameter(param_hash);
   problem = dataset_to_svm_problem(x_val, y_val);
 
@@ -71,7 +102,11 @@ VALUE train(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash)
     return Qnil;
   }
 
-  svm_set_print_string_function(print_null);
+  verbose = rb_hash_aref(param_hash, ID2SYM(rb_intern("verbose")));
+  if (verbose != Qtrue) {
+    svm_set_print_string_function(print_null);
+  }
+
   model = svm_train(problem, param);
   model_hash = svm_model_to_rb_hash(model);
   svm_free_and_destroy_model(&model);
@@ -79,6 +114,9 @@ VALUE train(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash)
   xfree_svm_problem(problem);
   xfree_svm_parameter(param);
 
+  RB_GC_GUARD(x_val);
+  RB_GC_GUARD(y_val);
+
   return model_hash;
 }
 
@@ -92,6 +130,30 @@ VALUE train(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash)
  *   @param param [Hash] The parameters of an SVM model.
  *   @param n_folds [Integer] The number of folds.
  *
+ * @example
+ *   require 'numo/libsvm'
+ *
+ *   # x: samples
+ *   # y: labels
+ *
+ *   # Define parameters of C-SVC with RBF Kernel.
+ *   param = {
+ *     svm_type: Numo::Libsvm::SvmType::C_SVC,
+ *     kernel_type: Numo::Libsvm::KernelType::RBF,
+ *     gamma: 1.0,
+ *     C: 1,
+ *     random_seed: 1,
+ *     verbose: true
+ *   }
+ *
+ *   # Perform 5-cross validation.
+ *   n_folds = 5
+ *   res = Numo::Libsvm.cv(x, y, param, n_folds)
+ *
+ *   # Print mean accuracy.
+ *   mean_accuracy = y.eq(res).count.fdiv(y.size)
+ *   puts "Accuracy: %.1f %%" % (100 * mean_accuracy)
+ *
  * @raise [ArgumentError] If the sample array is not 2-dimensional, the label array is not 1-dimensional,
  *   the sample array and label array do not have the same number of samples, or
  *   the hyperparameter has an invalid value, this error is raised.
@@ -107,6 +169,8 @@ VALUE cross_validation(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash, V
   narray_t* x_nary;
   narray_t* y_nary;
   char* err_msg;
+  VALUE random_seed;
+  VALUE verbose;
   struct svm_problem* problem;
   struct svm_parameter* param;
 
@@ -138,6 +202,11 @@ VALUE cross_validation(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash, V
     return Qnil;
   }
 
+  random_seed = rb_hash_aref(param_hash, ID2SYM(rb_intern("random_seed")));
+  if (!NIL_P(random_seed)) {
+    srand(NUM2UINT(random_seed));
+  }
+
   param = rb_hash_to_svm_parameter(param_hash);
   problem = dataset_to_svm_problem(x_val, y_val);
 
@@ -153,12 +222,19 @@ VALUE cross_validation(VALUE self, VALUE x_val, VALUE y_val, VALUE param_hash, V
   t_val = rb_narray_new(numo_cDFloat, 1, t_shape);
   t_pt = (double*)na_get_pointer_for_write(t_val);
 
-  svm_set_print_string_function(print_null);
+  verbose = rb_hash_aref(param_hash, ID2SYM(rb_intern("verbose")));
+  if (verbose != Qtrue) {
+    svm_set_print_string_function(print_null);
+  }
+
   svm_cross_validation(problem, param, n_folds, t_pt);
 
   xfree_svm_problem(problem);
   xfree_svm_parameter(param);
 
+  RB_GC_GUARD(x_val);
+  RB_GC_GUARD(y_val);
+
   return t_val;
 }
 
@@ -184,9 +260,10 @@ VALUE predict(VALUE self, VALUE x_val, VALUE param_hash, VALUE model_hash)
   size_t y_shape[1];
   VALUE y_val;
   double* y_pt;
-  int i, j;
+  int i, j, k;
   int n_samples;
   int n_features;
+  int n_nonzero_features;
 
   /* Obtain C data structures. */
   if (CLASS_OF(x_val) != numo_cDFloat) {
@@ -215,21 +292,17 @@ VALUE predict(VALUE self, VALUE x_val, VALUE param_hash, VALUE model_hash)
   x_pt = (double*)na_get_pointer_for_read(x_val);
 
   /* Predict values. */
-  x_nodes = ALLOC_N(struct svm_node, n_features + 1);
-  x_nodes[n_features].index = -1;
-  x_nodes[n_features].value = 0.0;
   for (i = 0; i < n_samples; i++) {
-    for (j = 0; j < n_features; j++) {
-      x_nodes[j].index = j + 1;
-      x_nodes[j].value = (double)x_pt[i * n_features + j];
-    }
+    x_nodes = dbl_vec_to_svm_node(&x_pt[i * n_features], n_features);
     y_pt[i] = svm_predict(model, x_nodes);
+    xfree(x_nodes);
   }
 
-  xfree(x_nodes);
   xfree_svm_model(model);
   xfree_svm_parameter(param);
 
+  RB_GC_GUARD(x_val);
+
   return y_val;
 }
 
@@ -298,40 +371,30 @@ VALUE decision_function(VALUE self, VALUE x_val, VALUE param_hash, VALUE model_h
 
   /* Predict values. */
   if (model->param.svm_type == ONE_CLASS || model->param.svm_type == EPSILON_SVR || model->param.svm_type == NU_SVR) {
-    x_nodes = ALLOC_N(struct svm_node, n_features + 1);
-    x_nodes[n_features].index = -1;
-    x_nodes[n_features].value = 0.0;
     for (i = 0; i < n_samples; i++) {
-      for (j = 0; j < n_features; j++) {
-        x_nodes[j].index = j + 1;
-        x_nodes[j].value = (double)x_pt[i * n_features + j];
-      }
+      x_nodes = dbl_vec_to_svm_node(&x_pt[i * n_features], n_features);
       svm_predict_values(model, x_nodes, &y_pt[i]);
+      xfree(x_nodes);
     }
-    xfree(x_nodes);
   } else {
     y_cols = (int)y_shape[1];
     dec_values = ALLOC_N(double, y_cols);
-    x_nodes = ALLOC_N(struct svm_node, n_features + 1);
-    x_nodes[n_features].index = -1;
-    x_nodes[n_features].value = 0.0;
     for (i = 0; i < n_samples; i++) {
-      for (j = 0; j < n_features; j++) {
-        x_nodes[j].index = j + 1;
-        x_nodes[j].value = (double)x_pt[i * n_features + j];
-      }
+      x_nodes = dbl_vec_to_svm_node(&x_pt[i * n_features], n_features);
       svm_predict_values(model, x_nodes, dec_values);
+      xfree(x_nodes);
       for (j = 0; j < y_cols; j++) {
         y_pt[i * y_cols + j] = dec_values[j];
       }
     }
-    xfree(x_nodes);
     xfree(dec_values);
   }
 
   xfree_svm_model(model);
   xfree_svm_parameter(param);
 
+  RB_GC_GUARD(x_val);
+
   return y_val;
 }
 
@@ -393,26 +456,22 @@ VALUE predict_proba(VALUE self, VALUE x_val, VALUE param_hash, VALUE model_hash)
 
     /* Predict values. */
     probs = ALLOC_N(double, model->nr_class);
-    x_nodes = ALLOC_N(struct svm_node, n_features + 1);
-    x_nodes[n_features].index = -1;
-    x_nodes[n_features].value = 0.0;
     for (i = 0; i < n_samples; i++) {
-      for (j = 0; j < n_features; j++) {
-        x_nodes[j].index = j + 1;
-        x_nodes[j].value = (double)x_pt[i * n_features + j];
-      }
+      x_nodes = dbl_vec_to_svm_node(&x_pt[i * n_features], n_features);
       svm_predict_probability(model, x_nodes, probs);
+      xfree(x_nodes);
       for (j = 0; j < model->nr_class; j++) {
         y_pt[i * model->nr_class + j] = probs[j];
       }
     }
-    xfree(x_nodes);
     xfree(probs);
   }
 
   xfree_svm_model(model);
   xfree_svm_parameter(param);
 
+  RB_GC_GUARD(x_val);
+
   return y_val;
 }
 

data/ext/numo/libsvm/svm_problem.c

@@ -29,9 +29,12 @@ struct svm_problem* dataset_to_svm_problem(VALUE x_val, VALUE y_val)
   narray_t* x_nary;
   double* x_pt;
   double* y_pt;
-  int i, j;
+  int i, j, k;
   int n_samples;
   int n_features;
+  int n_nonzero_features;
+  int is_padded;
+  int last_feature_id;
 
   GetNArray(x_val, x_nary);
   n_samples = (int)NA_SHAPE(x_nary)[0];
@@ -43,16 +46,45 @@ struct svm_problem* dataset_to_svm_problem(VALUE x_val, VALUE y_val)
   problem->l = n_samples;
   problem->x = ALLOC_N(struct svm_node*, n_samples);
   problem->y = ALLOC_N(double, n_samples);
+
+  is_padded = 0;
   for (i = 0; i < n_samples; i++) {
-    problem->x[i] = ALLOC_N(struct svm_node, n_features + 1);
+    n_nonzero_features = 0;
     for (j = 0; j < n_features; j++) {
-      problem->x[i][j].index = j + 1;
-      problem->x[i][j].value = x_pt[i * n_features + j];
+      if (x_pt[i * n_features + j] != 0.0) {
+        n_nonzero_features += 1;
+        last_feature_id = j + 1;
+      }
+    }
+    if (is_padded == 0 && last_feature_id == n_features) {
+      is_padded = 1;
+    }
+    if (is_padded == 1) {
+      problem->x[i] = ALLOC_N(struct svm_node, n_nonzero_features + 1);
+    } else {
+      problem->x[i] = ALLOC_N(struct svm_node, n_nonzero_features + 2);
+    }
+    for (j = 0, k = 0; j < n_features; j++) {
+      if (x_pt[i * n_features + j] != 0.0) {
+        problem->x[i][k].index = j + 1;
+        problem->x[i][k].value = (double)x_pt[i * n_features + j];
+        k++;
+      }
+    }
+    if (is_padded == 1) {
+      problem->x[i][n_nonzero_features].index = -1;
+      problem->x[i][n_nonzero_features].value = 0.0;
+    } else {
+      problem->x[i][n_nonzero_features].index = n_features;
+      problem->x[i][n_nonzero_features].value = 0.0;
+      problem->x[i][n_nonzero_features + 1].index = -1;
+      problem->x[i][n_nonzero_features + 1].value = 0.0;
     }
-    problem->x[i][n_features].index = -1;
-    problem->x[i][n_features].value = 0.0;
     problem->y[i] = y_pt[i];
   }
 
+  RB_GC_GUARD(x_val);
+  RB_GC_GUARD(y_val);
+
   return problem;
 }

data/lib/numo/libsvm/version.rb

@@ -3,6 +3,6 @@
 module Numo
   module Libsvm
     # The version of Numo::Libsvm you are using.
-    VERSION = '0.2.0'
+    VERSION = '1.0.1'
   end
 end

data/numo-libsvm.gemspec

@@ -28,14 +28,28 @@ Gem::Specification.new do |spec|
   spec.files = Dir.chdir(File.expand_path(__dir__)) do
     `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
   end
+
+  gem_dir = File.expand_path(__dir__) + '/'
+  submodule_path = `git submodule --quiet foreach pwd`.split($OUTPUT_RECORD_SEPARATOR).first
+  submodule_relative_path = submodule_path.sub gem_dir, ''
+  spec.files << "#{submodule_relative_path}/svm.cpp"
+  spec.files << "#{submodule_relative_path}/svm.h"
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/numo/libsvm/extconf.rb']
 
+  spec.metadata      = {
+    'homepage_uri' => 'https://github.com/yoshoku/numo-libsvm',
+    'source_code_uri' => 'https://github.com/yoshoku/numo-libsvm',
+    'documentation_uri' => 'https://yoshoku.github.io/numo-libsvm/doc/'
+  }
+
   spec.add_runtime_dependency 'numo-narray', '~> 0.9.1'
+
   spec.add_development_dependency 'bundler', '~> 2.0'
-  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rake', '~> 12.0'
   spec.add_development_dependency 'rake-compiler', '~> 1.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
 end