numo-liblinear 1.2.1 → 2.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fbe98bbdc79c6e0f8cb5392d0b990b7d0fc18033f2ef3f6ffe5634550b7a8065
-  data.tar.gz: 2a1adfe9e9b653885edc7256b517d8ed9ca8ba359cb5dda492592fa3169a664f
+  metadata.gz: 8ea54dc3ead49a3edb3d55b2bf46c673fca3a11b8b29001658fc453d8bfd8831
+  data.tar.gz: 3c4751dce386d1127ab4c1570807671a7b8ab73f632899e63655096cead86ffe
 SHA512:
-  metadata.gz: 8950474d1509b6bdf8398b0fc8961b81298110e7bcf609d60cd36ad7b1b1c5e287c349a07d3ae75799e2c5ca76c8b638a864914eaf32dfdb879c6bfe6015533b
-  data.tar.gz: 3984b878d18885c3cafe2f0afccef0974e0c9e8722da91f475ba41edfc20b54616b7947350f9a218c40dfed4d5749e5ec52f30ee4600101827ee8df3701d9d23
+  metadata.gz: 1f016fa4a2a372fb7948eea6418973ecf9228f3e8a8b58b23b7da9360f0dc3f0facd85a45d029b259bfd5d52ffb4a9b42565ebd1d163c9ac881f37c978a3f22b
+  data.tar.gz: 7119f78866b27df545177c6b6d24b2df261caade7a8437721df5b99c616af16ef2a039919ffc9ed35b5ee98760cc77520e9d708edeb9a851d822232b68c43806

data/CHANGELOG.md

@@ -1,3 +1,14 @@
+# 2.1.0
+- Update bundled LIBLINEAR to 2.44
+
+# 2.0.0
+- Redesign native extension codes.
+- Change not ot use git submodule for LIBLINEAR codes bundle.
+- Introduce conventional commits.
+
+# 1.2.2
+- Remove dependent gem's type declaration file from installation files.
+
 # 1.2.1
 - Fix version specifier of runtime dependencies.
 

data/LICENSE.txt

@@ -1,4 +1,4 @@
-Copyright (c) 2019-2021 Atsushi Tatsuma
+Copyright (c) 2019-2022 Atsushi Tatsuma
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without

data/README.md

@@ -173,7 +173,6 @@ param = {
 Bug reports and pull requests are welcome on GitHub at https://github.com/yoshoku/numo-liblinear.
 This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
 
-## Code of Conduct
+## License
 
-Everyone interacting in the Numo::Liblinear project’s codebases, issue trackers, chat rooms and mailing lists is expected to follow
-the [code of conduct](https://github.com/yoshoku/numo-liblinear/blob/main/CODE_OF_CONDUCT.md).
+The gem is available as open source under the terms of the [BSD-3-Clause License](https://opensource.org/licenses/BSD-3-Clause).

data/ext/numo/liblinear/extconf.rb

@@ -8,10 +8,7 @@ $LOAD_PATH.each do |lp|
   end
 end
 
-unless have_header('numo/narray.h')
-  puts 'numo/narray.h not found.'
-  exit(1)
-end
+abort 'numo/narray.h not found.' unless have_header('numo/narray.h')
 
 if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
   $LOAD_PATH.each do |lp|
@@ -20,19 +17,16 @@ if RUBY_PLATFORM =~ /mswin|cygwin|mingw/
       break
     end
   end
-  unless have_library('narray', 'nary_new')
-    puts 'libnarray.a not found.'
-    exit(1)
-  end
+  abort 'libnarray.a not found.' unless have_library('narray', 'nary_new')
 end
 
-$LDFLAGS << ' -lstdc++ '
+abort 'libstdc++ is not found.' unless have_library('stdc++')
 
-$srcs = Dir.glob("#{$srcdir}/*.c").map { |path| File.basename(path) }
-$srcs.concat(%w[linear.cpp newton.cpp daxpy.c ddot.c dnrm2.c dscal.c])
+$srcs = Dir.glob("#{$srcdir}/**/*.cpp").map { |path| File.basename(path) }
+$srcs.concat(%w[daxpy.c ddot.c dnrm2.c dscal.c])
 
-$INCFLAGS << " -I$(srcdir)/liblinear"
-$VPATH << "$(srcdir)/liblinear"
-$VPATH << "$(srcdir)/liblinear/blas"
+$INCFLAGS << " -I$(srcdir)/src"
+$VPATH << "$(srcdir)/src"
+$VPATH << "$(srcdir)/src/blas"
 
 create_makefile('numo/liblinear/liblinearext')

data/ext/numo/liblinear/liblinearext.cpp

@@ -0,0 +1,215 @@
+/**
+ * Copyright (c) 2019-2022 Atsushi Tatsuma
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * * Redistributions of source code must retain the above copyright notice, this
+ *   list of conditions and the following disclaimer.
+ *
+ * * Redistributions in binary form must reproduce the above copyright notice,
+ *   this list of conditions and the following disclaimer in the documentation
+ *   and/or other materials provided with the distribution.
+ *
+ * * Neither the name of the copyright holder nor the names of its
+ *   contributors may be used to endorse or promote products derived from
+ *   this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "liblinearext.hpp"
+
+extern "C" void Init_liblinearext(void) {
+  rb_require("numo/narray");
+
+  /**
+   * Document-module: Numo
+   * Numo is the top level namespace of NUmerical MOdules for Ruby.
+   */
+
+  /**
+   * Document-module: Numo::Liblinear
+   * Numo::Liblinear is a binding library for LIBLINEAR that handles dataset with Numo::NArray.
+   */
+  VALUE mLiblinear = rb_define_module_under(mNumo, "Liblinear");
+
+  /* The version of LIBLINEAR used in backgroud library. */
+  rb_define_const(mLiblinear, "LIBLINEAR_VERSION", INT2NUM(LIBLINEAR_VERSION));
+
+  /**
+   * 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));
+
+  /**
+   * Train the model according to the given training data.
+   *
+   * @overload train(x, y, param) -> Hash
+   *   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be used for training the model.
+   *   @param y [Numo::DFloat] (shape: [n_samples]) The labels or target values for samples.
+   *   @param param [Hash] The parameters of a model.
+   *
+   * @example
+   *   require 'numo/liblinear'
+   *
+   *   # Prepare training dataset.
+   *   x = Numo::DFloat[[-0.8, 1.0], [-0.5, 0.8], [0.9, -0.8], [0.8, -0.7]]
+   *   y = Numo::Int32[-1, -1, 1, 1]
+   *
+   *   # Train L2-regularized L2-loss support vector classifier.
+   *   param = {
+   *     solver_type: Numo::Liblinear::SolverType::L2R_L2LOSS_SVC_DUAL,
+   *     C: 0.1,
+   *     random_seed: 1
+   *   }
+   *   model = Numo::Liblinear.train(x, y, param)
+   *
+   *   # Predict labels of test data.
+   *   x_test = Numo::DFloat[[-0.7, 0.9], [0.5, -0.4]]
+   *   result = Numo::Liblinear.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.
+   * @return [Hash] The model obtained from the training procedure.
+   */
+  rb_define_module_function(mLiblinear, "train", RUBY_METHOD_FUNC(numo_liblinear_train), 3);
+  /**
+   * Perform cross validation under given parameters. The given samples are separated to n_fols folds.
+   * The predicted labels or values in the validation process are returned.
+   *
+   * @overload cv(x, y, param, n_folds) -> Numo::DFloat
+   *   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be used for training the model.
+   *   @param y [Numo::DFloat] (shape: [n_samples]) The labels or target values for samples.
+   *   @param param [Hash] The parameters of a model.
+   *   @param n_folds [Integer] The number of folds.
+   *
+   * @example
+   *   require 'numo/liblinear'
+   *
+   *   # x: samples
+   *   # y: labels
+   *
+   *   # Define parameters of L2-regularized L2-loss support vector classification.
+   *   param = {
+   *     solver_type: Numo::Liblinear::SolverType::L2R_L2LOSS_SVC_DUAL,
+   *     C: 1,
+   *     random_seed: 1,
+   *     verbose: true
+   *   }
+   *
+   *   # Perform 5-cross validation.
+   *   n_folds = 5
+   *   res = Numo::Liblinear::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.
+   * @return [Numo::DFloat] (shape: [n_samples]) The predicted class label or value of each sample.
+   */
+  rb_define_module_function(mLiblinear, "cv", RUBY_METHOD_FUNC(numo_liblinear_cross_validation), 4);
+  /**
+   * Predict class labels or values for given samples.
+   *
+   * @overload predict(x, param, model) -> Numo::DFloat
+   *   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the scores.
+   *   @param param [Hash] The parameters of the trained model.
+   *   @param model [Hash] The model obtained from the training procedure.
+   *
+   * @raise [ArgumentError] If the sample array is not 2-dimensional, this error is raised.
+   * @return [Numo::DFloat] (shape: [n_samples]) The predicted class label or value of each sample.
+   */
+  rb_define_module_function(mLiblinear, "predict", RUBY_METHOD_FUNC(numo_liblinear_predict), 3);
+  /**
+   * Calculate decision values for given samples.
+   *
+   * @overload decision_function(x, param, model) -> Numo::DFloat
+   *   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the scores.
+   *   @param param [Hash] The parameters of the trained model.
+   *   @param model [Hash] The model obtained from the training procedure.
+   *
+   * @raise [ArgumentError] If the sample array is not 2-dimensional, this error is raised.
+   * @return [Numo::DFloat] (shape: [n_samples, n_classes]) The decision value of each sample.
+   */
+  rb_define_module_function(mLiblinear, "decision_function", RUBY_METHOD_FUNC(numo_liblinear_decision_function), 3);
+  /**
+   * Predict class probability for given samples.
+   * The model must have probability information calcualted in training procedure.
+   * The method supports only the logistic regression.
+   *
+   * @overload predict_proba(x, param, model) -> Numo::DFloat
+   *   @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the class probabilities.
+   *   @param param [Hash] The parameters of the trained Logistic Regression model.
+   *   @param model [Hash] The model obtained from the training procedure.
+   *
+   * @raise [ArgumentError] If the sample array is not 2-dimensional, this error is raised.
+   * @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probablity of each class per sample.
+   */
+  rb_define_module_function(mLiblinear, "predict_proba", RUBY_METHOD_FUNC(numo_liblinear_predict_proba), 3);
+  /**
+   * Load the parameters and model from a text file with LIBLINEAR format.
+   *
+   * @overload load_model(filename) -> Array
+   *   @param filename [String] The path to a file to load.
+   *
+   * @raise [IOError] This error raises when failed to load the model file.
+   * @return [Array] Array contains the parameters and model.
+   */
+  rb_define_module_function(mLiblinear, "load_model", RUBY_METHOD_FUNC(numo_liblinear_load_model), 1);
+  /**
+   * Save the parameters and model as a text file with LIBLINEAR format. The saved file can be used with the liblinear tools.
+   * Note that the save_model saves only the parameters necessary for estimation with the trained model.
+   *
+   * @overload save_model(filename, param, model) -> Boolean
+   *   @param filename [String] The path to a file to save.
+   *   @param param [Hash] The parameters of the trained model.
+   *   @param model [Hash] The model obtained from the training procedure.
+   *
+   * @raise [IOError] This error raises when failed to save the model file.
+   * @return [Boolean] true on success, or false if an error occurs.
+   */
+  rb_define_module_function(mLiblinear, "save_model", RUBY_METHOD_FUNC(numo_liblinear_save_model), 3);
+}