numo-liblinear 0.2.0 → 1.1.0

data/ext/numo/liblinear/model.c

@@ -14,6 +14,8 @@ struct model* rb_hash_to_model(VALUE model_hash)
   model->label = nary_to_int_vec(el);
   el = rb_hash_aref(model_hash, ID2SYM(rb_intern("bias")));
   model->bias = NUM2DBL(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("rho")));
+  model->rho = NUM2DBL(el);
   return model;
 }
 
@@ -29,6 +31,7 @@ VALUE model_to_rb_hash(struct model* const model)
   rb_hash_aset(model_hash, ID2SYM(rb_intern("label")),
       model->label ? int_vec_to_nary(model->label, model->nr_class) : Qnil);
   rb_hash_aset(model_hash, ID2SYM(rb_intern("bias")), DBL2NUM(model->bias));
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("rho")), DBL2NUM(model->rho));
   return model_hash;
 }
 

data/ext/numo/liblinear/parameter.c

@@ -5,36 +5,39 @@ struct parameter* rb_hash_to_parameter(VALUE param_hash)
   VALUE el;
   struct parameter* param = ALLOC(struct parameter);
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("solver_type")));
-	param->solver_type = !NIL_P(el) ? NUM2INT(el) : L2R_L2LOSS_SVC_DUAL;
+  param->solver_type = !NIL_P(el) ? NUM2INT(el) : L2R_L2LOSS_SVC_DUAL;
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("eps")));
-	if (!NIL_P(el)) {
+  if (!NIL_P(el)) {
     param->eps = NUM2DBL(el);
-	} else {
-		switch(param->solver_type)
-		{
-			case L2R_LR:
-			case L2R_L2LOSS_SVC:
-				param->eps = 0.01;
-				break;
-			case L2R_L2LOSS_SVR:
-				param->eps = 0.0001;
-				break;
-			case L2R_L2LOSS_SVC_DUAL:
-			case L2R_L1LOSS_SVC_DUAL:
-			case MCSVM_CS:
-			case L2R_LR_DUAL:
-				param->eps = 0.1;
-				break;
-			case L1R_L2LOSS_SVC:
-			case L1R_LR:
-				param->eps = 0.01;
-				break;
-			case L2R_L1LOSS_SVR_DUAL:
-			case L2R_L2LOSS_SVR_DUAL:
-				param->eps = 0.1;
-				break;
+  } else {
+    switch(param->solver_type)
+    {
+      case L2R_LR:
+      case L2R_L2LOSS_SVC:
+        param->eps = 0.01;
+        break;
+      case L2R_L2LOSS_SVR:
+        param->eps = 0.0001;
+        break;
+      case L2R_L2LOSS_SVC_DUAL:
+      case L2R_L1LOSS_SVC_DUAL:
+      case MCSVM_CS:
+      case L2R_LR_DUAL:
+        param->eps = 0.1;
+        break;
+      case L1R_L2LOSS_SVC:
+      case L1R_LR:
+        param->eps = 0.01;
+        break;
+      case L2R_L1LOSS_SVR_DUAL:
+      case L2R_L2LOSS_SVR_DUAL:
+        param->eps = 0.1;
+        break;
+      case ONECLASS_SVM:
+        param->eps = 0.01;
+        break;
     }
-	}
+  }
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("C")));
   param->C = !NIL_P(el) ? NUM2DBL(el) : 1;
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("nr_weight")));
@@ -53,11 +56,14 @@ struct parameter* rb_hash_to_parameter(VALUE param_hash)
   }
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("p")));
   param->p = !NIL_P(el) ? NUM2DBL(el) : 0.1;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("nu")));
+  param->nu = !NIL_P(el) ? NUM2DBL(el) : 0.5;
   el = rb_hash_aref(param_hash, ID2SYM(rb_intern("init_sol")));
   param->init_sol = NULL;
   if (!NIL_P(el)) {
     param->init_sol = nary_to_dbl_vec(el);
   }
+  param->regularize_bias = 1;
   return param;
 }
 
@@ -73,6 +79,7 @@ VALUE parameter_to_rb_hash(struct parameter* const param)
   rb_hash_aset(param_hash, ID2SYM(rb_intern("weight")),
     param->weight ? dbl_vec_to_nary(param->weight, param->nr_weight) : Qnil);
   rb_hash_aset(param_hash, ID2SYM(rb_intern("p")), DBL2NUM(param->p));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("nu")), DBL2NUM(param->nu));
   rb_hash_aset(param_hash, ID2SYM(rb_intern("init_sol")), Qnil);
   return param_hash;
 }

data/ext/numo/liblinear/problem.c

@@ -29,9 +29,12 @@ struct problem* dataset_to_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];
@@ -46,14 +49,39 @@ struct problem* dataset_to_problem(VALUE x_val, VALUE y_val)
   problem->x = ALLOC_N(struct feature_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 feature_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++;
+        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 feature_node, n_nonzero_features + 1);
+    } else {
+      problem->x[i] = ALLOC_N(struct feature_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 = 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];
   }
 

data/ext/numo/liblinear/solver_type.c

@@ -17,18 +17,20 @@ void rb_init_solver_type_module()
   rb_define_const(mSolverType, "L2R_L2LOSS_SVC", INT2NUM(L2R_L2LOSS_SVC));
   /* L2-regularized L1-loss support vector classification (dual) */
   rb_define_const(mSolverType, "L2R_L1LOSS_SVC_DUAL", INT2NUM(L2R_L1LOSS_SVC_DUAL));
-	/* support vector classification by Crammer and Singer */
+  /* support vector classification by Crammer and Singer */
   rb_define_const(mSolverType, "MCSVM_CS", INT2NUM(MCSVM_CS));
-	/* L1-regularized L2-loss support vector classification */
+  /* L1-regularized L2-loss support vector classification */
   rb_define_const(mSolverType, "L1R_L2LOSS_SVC", INT2NUM(L1R_L2LOSS_SVC));
-	/* L1-regularized logistic regression */
+  /* L1-regularized logistic regression */
   rb_define_const(mSolverType, "L1R_LR", INT2NUM(L1R_LR));
   /* L2-regularized logistic regression (dual) */
   rb_define_const(mSolverType, "L2R_LR_DUAL", INT2NUM(L2R_LR_DUAL));
-	/* L2-regularized L2-loss support vector regression (primal) */
+  /* L2-regularized L2-loss support vector regression (primal) */
   rb_define_const(mSolverType, "L2R_L2LOSS_SVR", INT2NUM(L2R_L2LOSS_SVR));
-	/* L2-regularized L2-loss support vector regression (dual) */
+  /* L2-regularized L2-loss support vector regression (dual) */
   rb_define_const(mSolverType, "L2R_L2LOSS_SVR_DUAL", INT2NUM(L2R_L2LOSS_SVR_DUAL));
-	/* L2-regularized L1-loss support vector regression (dual) */
+  /* L2-regularized L1-loss support vector regression (dual) */
   rb_define_const(mSolverType, "L2R_L1LOSS_SVR_DUAL", INT2NUM(L2R_L1LOSS_SVR_DUAL));
+  /* one-class support vector machine (dual) */
+  rb_define_const(mSolverType, "ONECLASS_SVM", INT2NUM(ONECLASS_SVM));
 }

data/lib/numo/liblinear/version.rb

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

data/numo-liblinear.gemspec

@@ -27,14 +27,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, ''
+  liblinear_files = %w[linear.cpp linear.h newton.cpp newton.h blas/blas.h blas/blasp.h blas/daxpy.c blas/ddot.c blas/dnrm2.c blas/dscal.c]
+  liblinear_files.each { |liblinf| spec.files << "#{submodule_relative_path}/#{liblinf}" }
+
   spec.bindir        = 'exe'
   spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
   spec.require_paths = ['lib']
   spec.extensions    = ['ext/numo/liblinear/extconf.rb']
 
+  spec.metadata      = {
+    'homepage_uri' => 'https://github.com/yoshoku/numo-liblinear',
+    'source_code_uri' => 'https://github.com/yoshoku/numo-liblinear',
+    'documentation_uri' => 'https://yoshoku.github.io/numo-liblinear/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

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: numo-liblinear
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 1.1.0
 platform: ruby
 authors:
 - yoshoku
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2019-08-15 00:00:00.000000000 Z
+date: 2020-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '10.0'
+        version: '12.0'
 - !ruby/object:Gem::Dependency
   name: rake-compiler
   requirement: !ruby/object:Gem::Requirement
@@ -92,6 +92,7 @@ extensions:
 extra_rdoc_files: []
 files:
 - ".gitignore"
+- ".gitmodules"
 - ".rspec"
 - ".travis.yml"
 - CHANGELOG.md
@@ -103,6 +104,16 @@ files:
 - ext/numo/liblinear/converter.c
 - ext/numo/liblinear/converter.h
 - ext/numo/liblinear/extconf.rb
+- ext/numo/liblinear/liblinear/blas/blas.h
+- ext/numo/liblinear/liblinear/blas/blasp.h
+- ext/numo/liblinear/liblinear/blas/daxpy.c
+- ext/numo/liblinear/liblinear/blas/ddot.c
+- ext/numo/liblinear/liblinear/blas/dnrm2.c
+- ext/numo/liblinear/liblinear/blas/dscal.c
+- ext/numo/liblinear/liblinear/linear.cpp
+- ext/numo/liblinear/liblinear/linear.h
+- ext/numo/liblinear/liblinear/newton.cpp
+- ext/numo/liblinear/liblinear/newton.h
 - ext/numo/liblinear/liblinearext.c
 - ext/numo/liblinear/liblinearext.h
 - ext/numo/liblinear/model.c
@@ -119,8 +130,11 @@ files:
 homepage: https://github.com/yoshoku/numo-liblinear
 licenses:
 - BSD-3-Clause
-metadata: {}
-post_install_message: 
+metadata:
+  homepage_uri: https://github.com/yoshoku/numo-liblinear
+  source_code_uri: https://github.com/yoshoku/numo-liblinear
+  documentation_uri: https://yoshoku.github.io/numo-liblinear/doc/
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -135,9 +149,8 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.6.14.4
-signing_key: 
+rubygems_version: 3.1.2
+signing_key:
 specification_version: 4
 summary: Numo::Liblinear is a Ruby gem binding to the LIBLINEAR library. Numo::Liblinear
   makes to use the LIBLINEAR functions with dataset represented by Numo::NArray.