numo-liblinear 0.1.0

data/ext/numo/liblinear/liblinearext.h

@@ -0,0 +1,17 @@
+#ifndef NUMO_LIBLINEAREXT_H
+#define NUMO_LIBLINEAREXT_H 1
+
+#include <math.h>
+#include <string.h>
+#include <linear.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+#include "parameter.h"
+#include "model.h"
+#include "problem.h"
+#include "solver_type.h"
+
+#endif /* NUMO_LIBLINEAREXT_H */

data/ext/numo/liblinear/model.c

@@ -0,0 +1,45 @@
+#include "model.h"
+
+struct model* rb_hash_to_model(VALUE model_hash)
+{
+  VALUE el;
+  struct model* model = ALLOC(struct model);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("nr_class")));
+  model->nr_class = el != Qnil ? NUM2INT(el) : 0;
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("nr_feature")));
+  model->nr_feature = el != Qnil ? NUM2INT(el) : 0;
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("w")));
+  model->w = nary_to_dbl_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("label")));
+  model->label = nary_to_int_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("bias")));
+  model->bias = NUM2DBL(el);
+  return model;
+}
+
+VALUE model_to_rb_hash(struct model* const model)
+{
+  int const n_cols = model->nr_class > 2 ? model->nr_class : 1;
+  int const n_rows = model->nr_feature;
+  VALUE model_hash = rb_hash_new();
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("nr_class")), INT2NUM(model->nr_class));
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("nr_feature")), INT2NUM(model->nr_feature));
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("w")),
+      model->w ? dbl_vec_to_nary(model->w, n_rows * n_cols) : Qnil);
+  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));
+  return model_hash;
+}
+
+void xfree_model(struct model* model)
+{
+  if (model) {
+    xfree(model->w);
+    model->w = NULL;
+    xfree(model->label);
+    model->label = NULL;
+    xfree(model);
+    model = NULL;
+  }
+}

data/ext/numo/liblinear/model.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LIBLINEAR_MODEL_H
+#define NUMO_LIBLINEAR_MODEL_H 1
+
+#include <linear.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+
+struct model* rb_hash_to_model(VALUE model_hash);
+VALUE model_to_rb_hash(struct model* const model);
+void xfree_model(struct model* model);
+
+#endif /* NUMO_LIBLINEAR_MODEL_H */

data/ext/numo/liblinear/parameter.c

@@ -0,0 +1,98 @@
+#include "parameter.h"
+
+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;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("eps")));
+	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;
+    }
+	}
+  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")));
+  param->nr_weight = !NIL_P(el) ? NUM2INT(el) : 0;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("weight_label")));
+  param->weight_label = NULL;
+  if (!NIL_P(el)) {
+    param->weight_label = ALLOC_N(int, param->nr_weight);
+    memcpy(param->weight_label, (int32_t*)na_get_pointer_for_read(el), param->nr_weight);
+  }
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("weight")));
+  param->weight = NULL;
+  if (!NIL_P(el)) {
+    param->weight = ALLOC_N(double, param->nr_weight);
+    memcpy(param->weight, (double*)na_get_pointer_for_read(el), param->nr_weight);
+  }
+  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("init_sol")));
+  param->init_sol = NULL;
+  if (!NIL_P(el)) {
+    param->init_sol = nary_to_dbl_vec(el);
+  }
+  return param;
+}
+
+VALUE parameter_to_rb_hash(struct parameter* const param)
+{
+  VALUE param_hash = rb_hash_new();
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("solver_type")), INT2NUM(param->solver_type));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("eps")), DBL2NUM(param->eps));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("C")), DBL2NUM(param->C));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("nr_weight")), INT2NUM(param->nr_weight));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("weight_label")),
+    param->weight_label ? int_vec_to_nary(param->weight_label, param->nr_weight) : Qnil);
+  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("init_sol")), Qnil);
+  return param_hash;
+}
+
+void xfree_parameter(struct parameter* param)
+{
+  if (param) {
+    if (param->weight_label) {
+      xfree(param->weight_label);
+      param->weight_label = NULL;
+    }
+    if (param->weight) {
+      xfree(param->weight);
+      param->weight = NULL;
+    }
+    if (param->init_sol) {
+      xfree(param->init_sol);
+      param->init_sol = NULL;
+    }
+    xfree(param);
+    param = NULL;
+  }
+}

data/ext/numo/liblinear/parameter.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LIBLINEAR_PARAMETER_H
+#define NUMO_LIBLINEAR_PARAMETER_H 1
+
+#include <linear.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+
+struct parameter* rb_hash_to_parameter(VALUE parm_hash);
+VALUE parameter_to_rb_hash(struct parameter* const param);
+void xfree_parameter(struct parameter* param);
+
+#endif /* NUMO_LIBLINEAR_PARAMETER_H */

data/ext/numo/liblinear/problem.c

@@ -0,0 +1,61 @@
+#include "problem.h"
+
+void xfree_problem(struct problem* problem)
+{
+  int i;
+  if (problem) {
+    if (problem->x) {
+      for (i = 0; i < problem->l; i++) {
+        if (problem->x[i]) {
+          xfree(problem->x[i]);
+          problem->x[i] = NULL;
+        }
+      }
+      xfree(problem->x);
+      problem->x = NULL;
+    }
+    if (problem->y) {
+      xfree(problem->y);
+      problem->y = NULL;
+    }
+    xfree(problem);
+    problem = NULL;
+  }
+}
+
+struct problem* dataset_to_problem(VALUE x_val, VALUE y_val)
+{
+  struct problem* problem;
+  narray_t* x_nary;
+  double* x_pt;
+  double* y_pt;
+  int i, j;
+  int n_samples;
+  int n_features;
+
+  GetNArray(x_val, x_nary);
+  n_samples = (int)NA_SHAPE(x_nary)[0];
+  n_features = (int)NA_SHAPE(x_nary)[1];
+  x_pt = (double*)na_get_pointer_for_read(x_val);
+  y_pt = (double*)na_get_pointer_for_read(y_val);
+
+  problem = ALLOC(struct problem);
+  problem->bias = -1;
+  problem->n = n_features;
+  problem->l = n_samples;
+  problem->x = ALLOC_N(struct feature_node*, n_samples);
+  problem->y = ALLOC_N(double, n_samples);
+
+  for (i = 0; i < n_samples; i++) {
+    problem->x[i] = ALLOC_N(struct feature_node, n_features + 1);
+    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];
+    }
+    problem->x[i][n_features].index = -1;
+    problem->x[i][n_features].value = 0.0;
+    problem->y[i] = y_pt[i];
+  }
+
+  return problem;
+}

data/ext/numo/liblinear/problem.h

@@ -0,0 +1,12 @@
+#ifndef NUMO_LIBLINEAR_PROBLEM_H
+#define NUMO_LIBLINEAR_PROBLEM_H 1
+
+#include <linear.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+void xfree_problem(struct problem* problem);
+struct problem* dataset_to_problem(VALUE x_val, VALUE y_val);
+
+#endif /* NUMO_LIBLINEAR_PROBLEM_H */

data/ext/numo/liblinear/solver_type.c

@@ -0,0 +1,34 @@
+#include "solver_type.h"
+
+RUBY_EXTERN VALUE mLiblinear;
+
+void rb_init_solver_type_module()
+{
+  /**
+   * Document-module: Numo::Liblinear::SolverType
+   * The module consisting of constants for solver type that used for parameter of LIBLINER.
+   */
+  VALUE mSolverType = rb_define_module_under(mLiblinear, "SolverType");
+  /* L2-regularized logistic regression (primal) */
+  rb_define_const(mSolverType, "L2R_LR", INT2NUM(L2R_LR));
+  /* L2-regularized L2-loss support vector classification (dual) */
+  rb_define_const(mSolverType, "L2R_L2LOSS_SVC_DUAL", INT2NUM(L2R_L2LOSS_SVC_DUAL));
+  /* L2-regularized L2-loss support vector classification (primal) */
+  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 */
+  rb_define_const(mSolverType, "MCSVM_CS", INT2NUM(MCSVM_CS));
+	/* L1-regularized L2-loss support vector classification */
+  rb_define_const(mSolverType, "L1R_L2LOSS_SVC", INT2NUM(L1R_L2LOSS_SVC));
+	/* 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) */
+  rb_define_const(mSolverType, "L2R_L2LOSS_SVR", INT2NUM(L2R_L2LOSS_SVR));
+	/* 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) */
+  rb_define_const(mSolverType, "L2R_L1LOSS_SVR_DUAL", INT2NUM(L2R_L1LOSS_SVR_DUAL));
+}

data/ext/numo/liblinear/solver_type.h

@@ -0,0 +1,9 @@
+#ifndef NUMO_LIBLINEAR_SOLVER_TYPE_H
+#define NUMO_LIBLINEAR_SOLVER_TYPE_H 1
+
+#include <linear.h>
+#include <ruby.h>
+
+void rb_init_solver_type_module();
+
+#endif /* NUMO_LIBLINEAR_SOLVER_TYPE_H */

data/lib/numo/liblinear.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+require 'numo/narray'
+require 'numo/liblinear/version'
+require 'numo/liblinear/liblinearext'

data/lib/numo/liblinear/version.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Numo
+  module Liblinear
+    # The version of Numo::Liblienar you are using.
+    VERSION = '0.1.0'
+  end
+end

data/numo-liblinear.gemspec

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numo/liblinear/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'numo-liblinear'
+  spec.version       = Numo::Liblinear::VERSION
+  spec.authors       = ['yoshoku']
+  spec.email         = ['yoshoku@outlook.com']
+
+  spec.summary       = <<~MSG
+    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.
+  MSG
+  spec.description   = <<~MSG
+    Numo::Liblinear is a Ruby gem binding to the LIBLINEAR library.
+    LIBLINEAR is one of the famous libraries for large-scale regularized linear classification and regression.
+    Numo::Liblinear makes to use the LIBLINEAR functions with dataset represented by Numo::NArray.
+  MSG
+  spec.homepage      = 'https://github.com/yoshoku/numo-liblinear'
+  spec.license       = 'BSD-3-Clause'
+
+  # Specify which files should be added to the gem when it is released.
+  # The `git ls-files -z` loads the files in the RubyGem that have been added into git.
+  spec.files         = Dir.chdir(File.expand_path(__dir__)) do
+    `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  end
+  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.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-compiler', '~> 1.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+end

metadata

@@ -0,0 +1,144 @@
+--- !ruby/object:Gem::Specification
+name: numo-liblinear
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yoshoku
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-07-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: numo-narray
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.1
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+description: |
+  Numo::Liblinear is a Ruby gem binding to the LIBLINEAR library.
+  LIBLINEAR is one of the famous libraries for large-scale regularized linear classification and regression.
+  Numo::Liblinear makes to use the LIBLINEAR functions with dataset represented by Numo::NArray.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions:
+- ext/numo/liblinear/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/numo/liblinear/converter.c
+- ext/numo/liblinear/converter.h
+- ext/numo/liblinear/extconf.rb
+- ext/numo/liblinear/liblinearext.c
+- ext/numo/liblinear/liblinearext.h
+- ext/numo/liblinear/model.c
+- ext/numo/liblinear/model.h
+- ext/numo/liblinear/parameter.c
+- ext/numo/liblinear/parameter.h
+- ext/numo/liblinear/problem.c
+- ext/numo/liblinear/problem.h
+- ext/numo/liblinear/solver_type.c
+- ext/numo/liblinear/solver_type.h
+- lib/numo/liblinear.rb
+- lib/numo/liblinear/version.rb
+- numo-liblinear.gemspec
+homepage: https://github.com/yoshoku/numo-liblinear
+licenses:
+- BSD-3-Clause
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.14.4
+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.
+test_files: []