numo-liblinear 1.2.2 → 2.1.1

data/ext/numo/liblinear/parameter.c

@@ -1,105 +0,0 @@
-#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;
-      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")));
-  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 * sizeof(int32_t));
-  }
-  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 * sizeof(double));
-  }
-  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;
-}
-
-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("nu")), DBL2NUM(param->nu));
-  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

@@ -1,15 +0,0 @@
-#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

@@ -1,92 +0,0 @@
-#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, 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];
-  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);
-
-  is_padded = 0;
-  for (i = 0; i < n_samples; i++) {
-    n_nonzero_features = 0;
-    for (j = 0; j < 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->y[i] = y_pt[i];
-  }
-
-  RB_GC_GUARD(x_val);
-  RB_GC_GUARD(y_val);
-
-  return problem;
-}

data/ext/numo/liblinear/problem.h

@@ -1,12 +0,0 @@
-#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

@@ -1,36 +0,0 @@
-#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));
-  /* one-class support vector machine (dual) */
-  rb_define_const(mSolverType, "ONECLASS_SVM", INT2NUM(ONECLASS_SVM));
-}

data/ext/numo/liblinear/solver_type.h

@@ -1,9 +0,0 @@
-#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/numo-liblinear.gemspec

@@ -1,47 +0,0 @@
-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|sig-deps)/}) }
-  end
-
-  submodule_path = `git submodule --quiet foreach pwd`.split($INPUT_RECORD_SEPARATOR).first
-  submodule_relative_path = submodule_path.sub("#{File.expand_path(__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'
-end