numo-libsvm 0.1.0

data/ext/numo/libsvm/libsvmext.h

@@ -0,0 +1,17 @@
+#ifndef NUMO_LIBSVMEXT_H
+#define NUMO_LIBSVMEXT_H 1
+
+#include <math.h>
+#include <string.h>
+#include <svm.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+#include "svm_parameter.h"
+#include "svm_model.h"
+#include "svm_type.h"
+#include "kernel_type.h"
+
+#endif /* NUMO_LIBSVMEXT_H */

data/ext/numo/libsvm/svm_model.c

@@ -0,0 +1,89 @@
+
+#include "svm_model.h"
+
+struct svm_model* rb_hash_to_svm_model(VALUE model_hash)
+{
+  VALUE el;
+  struct svm_model* model = ALLOC(struct svm_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("l")));
+  model->l = el != Qnil ? NUM2INT(el) : 0;
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("SV")));
+  model->SV = nary_to_svm_nodes(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("sv_coef")));
+  model->sv_coef = nary_to_dbl_mat(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("rho")));
+  model->rho = nary_to_dbl_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("probA")));
+  model->probA = nary_to_dbl_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("probB")));
+  model->probB = nary_to_dbl_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("sv_indices")));
+  model->sv_indices = nary_to_int_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("nSV")));
+  model->nSV = nary_to_int_vec(el);
+  el = rb_hash_aref(model_hash, ID2SYM(rb_intern("free_sv")));
+  model->free_sv = el != Qnil ? NUM2INT(el) : 0;
+  return model;
+}
+
+VALUE svm_model_to_rb_hash(struct svm_model* const model)
+{
+  int const n_classes = model->nr_class;
+  int const n_support_vecs = model->l;
+  VALUE support_vecs = model->SV ? svm_nodes_to_nary(model->SV, n_support_vecs) : Qnil;
+  VALUE coefficients = model->sv_coef ? dbl_mat_to_nary(model->sv_coef, n_classes - 1, n_support_vecs) : Qnil;
+  VALUE intercepts = model->rho ? dbl_vec_to_nary(model->rho, n_classes * (n_classes - 1) / 2) : Qnil;
+  VALUE prob_alpha = model->probA ? dbl_vec_to_nary(model->probA, n_classes * (n_classes - 1) / 2) : Qnil;
+  VALUE prob_beta = model->probB ? dbl_vec_to_nary(model->probB, n_classes * (n_classes - 1) / 2) : Qnil;
+  VALUE sv_indices = model->sv_indices ? int_vec_to_nary(model->sv_indices, n_support_vecs) : Qnil;
+  VALUE labels = model->label ? int_vec_to_nary(model->label, n_classes) : Qnil;
+  VALUE n_support_vecs_each_class = model->nSV ? int_vec_to_nary(model->nSV, n_classes) : Qnil;
+  VALUE model_hash = rb_hash_new();
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("nr_class")), INT2NUM(n_classes));
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("l")), INT2NUM(n_support_vecs));
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("SV")), support_vecs);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("sv_coef")), coefficients);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("rho")), intercepts);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("probA")), prob_alpha);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("probB")), prob_beta);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("sv_indices")), sv_indices);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("label")), labels);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("nSV")), n_support_vecs_each_class);
+  rb_hash_aset(model_hash, ID2SYM(rb_intern("free_sv")), INT2NUM(model->free_sv));
+  return model_hash;
+}
+
+void xfree_svm_model(struct svm_model* model)
+{
+  int i;
+  if (model) {
+    if (model->SV) {
+      for (i = 0; i < model->l; xfree(model->SV[i++]));
+      xfree(model->SV);
+      model->SV = NULL;
+    }
+    if (model->sv_coef) {
+      for (i = 0; i < model->nr_class - 1; xfree(model->sv_coef[i++]));
+      xfree(model->sv_coef);
+      model->sv_coef = NULL;
+    }
+    xfree(model->rho);
+    model->rho = NULL;
+    xfree(model->probA);
+    model->probA = NULL;
+    xfree(model->probB);
+    model->probB = NULL;
+    xfree(model->sv_indices);
+    model->sv_indices = NULL;
+    xfree(model->label);
+    model->label = NULL;
+    xfree(model->nSV);
+    model->nSV = NULL;
+    xfree(model);
+    model = NULL;
+  }
+}

data/ext/numo/libsvm/svm_model.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LIBSVM_SVM_MODEL_H
+#define NUMO_LIBSVM_SVM_MODEL_H 1
+
+#include <svm.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+
+struct svm_model* rb_hash_to_svm_model(VALUE model_hash);
+VALUE svm_model_to_rb_hash(struct svm_model* const model);
+void xfree_svm_model(struct svm_model* model);
+
+#endif /* NUMO_LIBSVM_SVM_MODEL_H */

data/ext/numo/libsvm/svm_parameter.c

@@ -0,0 +1,88 @@
+
+#include "svm_parameter.h"
+
+struct svm_parameter* rb_hash_to_svm_parameter(VALUE param_hash)
+{
+  VALUE el;
+  struct svm_parameter* param = ALLOC(struct svm_parameter);
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("svm_type")));
+  param->svm_type = !NIL_P(el) ? NUM2INT(el) : C_SVC;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("kernel_type")));
+  param->kernel_type = !NIL_P(el) ? NUM2INT(el) : RBF;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("degree")));
+  param->degree = !NIL_P(el) ? NUM2INT(el) : 3;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("gamma")));
+  param->gamma = !NIL_P(el) ? NUM2DBL(el) : 1;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("coef0")));
+  param->coef0 = !NIL_P(el) ? NUM2DBL(el) : 0;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("cache_size")));
+  param->cache_size = !NIL_P(el) ? NUM2DBL(el) : 100;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("eps")));
+  param->eps = !NIL_P(el) ? NUM2DBL(el) : 1e-3;
+  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("nu")));
+  param->nu = !NIL_P(el) ? NUM2DBL(el) : 0.5;
+  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("shrinking")));
+  param->shrinking = RB_TYPE_P(el, T_FALSE) ? 0 : 1;
+  el = rb_hash_aref(param_hash, ID2SYM(rb_intern("probability")));
+  param->probability = RB_TYPE_P(el, T_TRUE) ? 1 : 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);
+  }
+  return param;
+}
+
+VALUE svm_parameter_to_rb_hash(struct svm_parameter* const param)
+{
+  VALUE param_hash = rb_hash_new();
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("svm_type")), INT2NUM(param->svm_type));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("kernel_type")), INT2NUM(param->kernel_type));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("degree")), INT2NUM(param->degree));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("gamma")), DBL2NUM(param->gamma));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("coef0")), DBL2NUM(param->coef0));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("cache_size")), DBL2NUM(param->cache_size));
+  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("nu")), DBL2NUM(param->nu));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("p")), DBL2NUM(param->p));
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("shrinking")),
+    param->shrinking == 1 ? Qtrue : Qfalse);
+  rb_hash_aset(param_hash, ID2SYM(rb_intern("probability")),
+    param->probability == 1 ? Qtrue : Qfalse);
+  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);
+  return param_hash;
+}
+
+void xfree_svm_parameter(struct svm_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;
+    }
+    xfree(param);
+    param = NULL;
+  }
+}

data/ext/numo/libsvm/svm_parameter.h

@@ -0,0 +1,15 @@
+#ifndef NUMO_LIBSVM_SVM_PARAMETER_H
+#define NUMO_LIBSVM_SVM_PARAMETER_H 1
+
+#include <svm.h>
+#include <ruby.h>
+#include <numo/narray.h>
+#include <numo/template.h>
+
+#include "converter.h"
+
+struct svm_parameter* rb_hash_to_svm_parameter(VALUE param_hash);
+VALUE svm_parameter_to_rb_hash(struct svm_parameter* const param);
+void xfree_svm_parameter(struct svm_parameter* param);
+
+#endif /* NUMO_LIBSVM_SVM_PARAMETER_H */

data/ext/numo/libsvm/svm_type.c

@@ -0,0 +1,22 @@
+#include "svm_type.h"
+
+RUBY_EXTERN VALUE mLibsvm;
+
+void rb_init_svm_type_module()
+{
+  /**
+   * Document-module: Numo::Libsvm::SvmType
+   * The module consisting of constants for SVM algorithm type that used for parameter of LIBSVM.
+   */
+  VALUE mSvmType = rb_define_module_under(mLibsvm, "SvmType");
+  /* C-SVM classification */
+  rb_define_const(mSvmType, "C_SVC", INT2NUM(C_SVC));
+  /* nu-SVM classification */
+  rb_define_const(mSvmType, "NU_SVC", INT2NUM(NU_SVC));
+  /* one-class-SVM */
+  rb_define_const(mSvmType, "ONE_CLASS", INT2NUM(ONE_CLASS));
+  /* epsilon-SVM regression */
+  rb_define_const(mSvmType, "EPSILON_SVR", INT2NUM(EPSILON_SVR));
+  /* nu-SVM regression */
+  rb_define_const(mSvmType, "NU_SVR", INT2NUM(NU_SVR));
+}

data/ext/numo/libsvm/svm_type.h

@@ -0,0 +1,9 @@
+#ifndef NUMO_LIBSVM_SVM_TYPE_H
+#define NUMO_LIBSVM_SVM_TYPE_H 1
+
+#include <svm.h>
+#include <ruby.h>
+
+void rb_init_svm_type_module();
+
+#endif /* NUMO_LIBSVM_SVM_TYPE_H */

data/lib/numo/libsvm.rb

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

data/lib/numo/libsvm/version.rb

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

data/numo-libsvm.gemspec

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+lib = File.expand_path('lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'numo/libsvm/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'numo-libsvm'
+  spec.version       = Numo::Libsvm::VERSION
+  spec.authors       = ['yoshoku']
+  spec.email         = ['yoshoku@outlook.com']
+
+  spec.summary       = <<~MSG
+    Numo::Libsvm is a Ruby gem binding to the LIBSVM library.
+    Numo::Libsvm makes to use the LIBSVM functions with dataset represented by Numo::NArray.
+  MSG
+  spec.description   = <<~MSG
+    Numo::Libsvm is a Ruby gem binding to the LIBSVM library.
+    LIBSVM is one of the famous libraries that implemented Support Vector Machines,
+    and provides functions for support vector classifier, regression, and distribution estimation.
+    Numo::Libsvm makes to use the LIBSVM functions with dataset represented by Numo::NArray.
+  MSG
+  spec.homepage      = 'https://github.com/yoshoku/numo-libsvm'
+  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/libsvm/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,145 @@
+--- !ruby/object:Gem::Specification
+name: numo-libsvm
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- yoshoku
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2019-07-22 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::Libsvm is a Ruby gem binding to the LIBSVM library.
+  LIBSVM is one of the famous libraries that implemented Support Vector Machines,
+  and provides functions for support vector classifier, regression, and distribution estimation.
+  Numo::Libsvm makes to use the LIBSVM functions with dataset represented by Numo::NArray.
+email:
+- yoshoku@outlook.com
+executables: []
+extensions:
+- ext/numo/libsvm/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".travis.yml"
+- CHANGELOG.md
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- ext/numo/libsvm/converter.c
+- ext/numo/libsvm/converter.h
+- ext/numo/libsvm/extconf.rb
+- ext/numo/libsvm/kernel_type.c
+- ext/numo/libsvm/kernel_type.h
+- ext/numo/libsvm/libsvmext.c
+- ext/numo/libsvm/libsvmext.h
+- ext/numo/libsvm/svm_model.c
+- ext/numo/libsvm/svm_model.h
+- ext/numo/libsvm/svm_parameter.c
+- ext/numo/libsvm/svm_parameter.h
+- ext/numo/libsvm/svm_type.c
+- ext/numo/libsvm/svm_type.h
+- lib/numo/libsvm.rb
+- lib/numo/libsvm/version.rb
+- numo-libsvm.gemspec
+homepage: https://github.com/yoshoku/numo-libsvm
+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::Libsvm is a Ruby gem binding to the LIBSVM library. Numo::Libsvm makes
+  to use the LIBSVM functions with dataset represented by Numo::NArray.
+test_files: []