svmkit 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 1d3f4f2c398faa6b9e936ec813dac3023d9d1728
-  data.tar.gz: 6fe4f9b6ac5a656fb1a3f49662997d0ebbdd8d4b
+  metadata.gz: c2538f07704c57e4dc90caa85411d0795ac23763
+  data.tar.gz: 3815cf50ee5978cca24d944c6e7f577216dae0e3
 SHA512:
-  metadata.gz: fb1ac8798124f25cdd4dd0738dd856c8bae7e87aacac260a8ea8b1fb7388e3a966045f2382e48f241292111312eb7cb6cd69035010ee1487645f725f364ee16b
-  data.tar.gz: 99bdb17d5a2d2825e904ce2e788e31d100e1850b1d9bfc32f7e7cc48ba1b13da59b667d1ed117a6768d852d5c15d3a4c3132994bc13350315c8b07016bcbcd41
+  metadata.gz: e448dd5f8fddb4a2a805b1dcddb7ab9c53d7c3db3460760b3165940d0ab93ae82ba1b0fec089e7a1d6651154b5f0437f3d4400531cc11017fd16f9e2029e2611
+  data.tar.gz: 1416d8c3ea1f55abd1fb269bdaf86f80faaa31be298d0ed1349f6b708d05e64545bf0ad4c3865c7ced26057441ff0999dd82ca77eae54209190527b87ba4ec27

data/HISTORY.md

@@ -1,3 +1,11 @@
+# 0.1.2
+- Added the function learning a model with bias term to the PegasosSVC and LogisticRegression classes.
+- Rewrited the document with yard notation.
+
+# 0.1.1
+- Added class for Logistic Regression with SGD optimization.
+- Fixed some mistakes on the document.
+
 # 0.1.0
 - Added basic classes.
 - Added an utility module.
@@ -5,4 +13,3 @@
 - Added class for Support Vector Machine with Pegasos alogrithm.
 - Added class that performs mutlclass classification with one-vs.-rest strategy.
 - Added classes for preprocessing such as min-max scaling, standardization, and L2 normalization.
-

data/README.md

@@ -1,5 +1,9 @@
 # SVMKit
 
+[![Build Status](https://travis-ci.org/yoshoku/SVMKit.svg?branch=master)](https://travis-ci.org/yoshoku/SVMKit)
+[![Gem Version](https://badge.fury.io/rb/svmkit.svg)](https://badge.fury.io/rb/svmkit)
+[![BSD 2-Clause License](https://img.shields.io/badge/License-BSD%202--Clause-orange.svg)](https://github.com/yoshoku/SVMKit/blob/master/LICENSE.txt)
+
 SVMKit is a library for machine learninig in Ruby.
 SVMKit implements machine learning algorithms with an interface similar to Scikit-Learn in Python.
 However, since SVMKit is an experimental library, there are few machine learning algorithms implemented.
@@ -23,6 +27,7 @@ Or install it yourself as:
 ## Usage
 
 Training phase:
+
 ```ruby
 require 'svmkit'
 require 'libsvmloader'
@@ -46,6 +51,7 @@ File.open('trained_classifier.dat', 'wb') { |f| f.write(Marshal.dump(classifier)
 ```
 
 Testing phase:
+
 ```ruby
 require 'svmkit'
 require 'libsvmloader'

data/lib/svmkit/base/base_estimator.rb

@@ -4,7 +4,8 @@ module SVMKit
   module Base
     # Base module for all estimators in SVMKit.
     module BaseEstimator
-      # Parameters for this estimator.
+      # Return parameters about an estimator.
+      # @return [Hash]
       attr_accessor :params
     end
   end

data/lib/svmkit/kernel_approximation/rbf.rb

@@ -6,40 +6,43 @@ module SVMKit
   module KernelApproximation
     # Class for RBF kernel feature mapping.
     #
+    # @example
     #   transformer = SVMKit::KernelApproximation::RBF.new(gamma: 1.0, n_coponents: 128, random_seed: 1)
     #   new_training_samples = transformer.fit_transform(training_samples)
     #   new_testing_samples = transformer.transform(testing_samples)
     #
-    # * *Refernce*:
-    #   - A. Rahimi and B. Recht, "Random Features for Large-Scale Kernel Machines," Proc. NIPS'07, pp.1177--1184, 2007.
+    # *Refernce*:
+    # 1. A. Rahimi and B. Recht, "Random Features for Large-Scale Kernel Machines," Proc. NIPS'07, pp.1177--1184, 2007.
     class RBF
       include Base::BaseEstimator
       include Base::Transformer
 
-      DEFAULT_PARAMS = { # :nodoc:
+      # @!visibility private
+      DEFAULT_PARAMS = {
         gamma: 1.0,
         n_components: 128,
         random_seed: nil
       }.freeze
 
-      # The random matrix for transformation.
-      attr_reader :random_mat # :nodoc:
+      # Return the random matrix for transformation.
+      # @return [NMatrix] (shape: [n_features, n_components])
+      attr_reader :random_mat
 
-      # The random vector for transformation.
-      attr_reader :random_vec # :nodoc:
+      # Return the random vector for transformation.
+      # @return [NMatrix] (shape: [1, n_components])
+      attr_reader :random_vec
 
-      # The random generator for transformation.
-      attr_reader :rng # :nodoc:
+      # Return the random generator for transformation.
+      # @return [Random]
+      attr_reader :rng
 
-      # Creates a new transformer for mapping to RBF kernel feature space.
+      # Create a new transformer for mapping to RBF kernel feature space.
       #
-      # call-seq:
-      #   new(gamma: 1.0, n_components: 128, random_seed: 1) -> RBF
+      # @overload new(gamma: 1.0, n_components: 128, random_seed: 1) -> RBF
       #
-      # * *Arguments* :
-      #   - +:gamma+ (Float) (defaults to: 1.0) -- The parameter of RBF kernel: exp(-gamma * x^2)
-      #   - +:n_components+ (Integer) (defaults to: 128) -- The number of dimensions of the RBF kernel feature space.
-      #   - +:random_seed+ (Integer) (defaults to: nil) -- The seed value using to initialize the random generator.
+      # @param gamma        [Float] (defaults to: 1.0) The parameter of RBF kernel: exp(-gamma * x^2).
+      # @param n_components [Integer] (defaults to: 128) The number of dimensions of the RBF kernel feature space.
+      # @param random_seed  [Integer] (defaults to: nil) The seed value using to initialize the random generator.
       def initialize(params = {})
         self.params = DEFAULT_PARAMS.merge(Hash[params.map { |k, v| [k.to_sym, v] }])
         self.params[:random_seed] ||= srand
@@ -50,13 +53,11 @@ module SVMKit
 
       # Fit the model with given training data.
       #
-      # call-seq:
-      #   fit(x) -> RBF
+      # @overload fit(x) -> RBF
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The training data to be used for fitting the model. This method uses only the number of features of the data.
-      # * *Returns* :
-      #   - The learned transformer itself.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      #   This method uses only the number of features of the data.
+      # @return [RBF] The learned transformer itself.
       def fit(x, _y = nil)
         n_features = x.shape[1]
         params[:n_components] = 2 * n_features if params[:n_components] <= 0
@@ -65,48 +66,43 @@ module SVMKit
         @random_vec = NMatrix.zeros([1, params[:n_components] - n_half_components]).hconcat(
           NMatrix.ones([1, n_half_components]) * (0.5 * Math::PI)
         )
-        #@random_vec = rand_uniform([1, self.params[:n_components]]) * (2.0 * Math::PI)
         self
       end
 
       # Fit the model with training data, and then transform them with the learned model.
       #
-      # call-seq:
-      #   fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> NMatrix
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The training data to be used for fitting the model.
-      # * *Returns* :
-      #   - The transformed data (NMatrix, shape: [n_samples, n_components]).
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @return [NMatrix] (shape: [n_samples, n_components]) The transformed data
       def fit_transform(x, _y = nil)
         fit(x).transform(x)
       end
 
       # Transform the given data with the learned model.
       #
-      # call-seq:
-      #   transform(x) -> NMatrix
+      # @overload transform(x) -> NMatrix
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The data to be transformed with the learned model.
-      # * *Returns* :
-      #   - The transformed data (NMatrix, shape: [n_samples, n_components]).
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
+      # @return [NMatrix] (shape: [n_samples, n_components]) The transformed data.
       def transform(x)
         n_samples, = x.shape
         projection = x.dot(@random_mat) + @random_vec.repeat(n_samples, 0)
         projection.sin * ((2.0 / params[:n_components])**0.5)
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
+      # Dump marshal data.
+      # @return [Hash] The marshal data about RBF.
+      def marshal_dump
         { params: params,
           random_mat: Utils.dump_nmatrix(@random_mat),
           random_vec: Utils.dump_nmatrix(@random_vec),
           rng: @rng }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         self.params = obj[:params]
         @random_mat = Utils.restore_nmatrix(obj[:random_mat])
         @random_vec = Utils.restore_nmatrix(obj[:random_vec])
@@ -117,13 +113,13 @@ module SVMKit
       protected
 
       # Generate the uniform random matrix with the given shape.
-      def rand_uniform(shape) # :nodoc:
+      def rand_uniform(shape)
         rnd_vals = Array.new(NMatrix.size(shape)) { @rng.rand }
         NMatrix.new(shape, rnd_vals, dtype: :float64, stype: :dense)
       end
 
       # Generate the normal random matrix with the given shape, mean, and standard deviation.
-      def rand_normal(shape, mu = 0.0, sigma = 1.0) # :nodoc:
+      def rand_normal(shape, mu = 0.0, sigma = 1.0)
         a = rand_uniform(shape)
         b = rand_uniform(shape)
         ((a.log * -2.0).sqrt * (b * 2.0 * Math::PI).sin) * sigma + mu

data/lib/svmkit/linear_model/logistic_regression.rb

@@ -4,69 +4,80 @@ require 'svmkit/base/classifier'
 module SVMKit
   # This module consists of the classes that implement generalized linear models.
   module LinearModel
-    # LogisticRegression is a class that implements Logistic Regression with stochastic gradient descent (SGD) optimization.
-    # Note that the Logistic Regression of SVMKit performs as a binary classifier.
+    # LogisticRegression is a class that implements Logistic Regression
+    # with stochastic gradient descent (SGD) optimization.
+    # Note that the class performs as a binary classifier.
     #
+    # @example
     #   estimator =
     #     SVMKit::LinearModel::LogisticRegression.new(reg_param: 1.0, max_iter: 100, batch_size: 20, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
     #
-    # * *Reference*:
-    #   - S. Shalev-Shwartz, Y. Singer, N. Srebro, and A. Cotter, "Pegasos: Primal Estimated sub-GrAdient SOlver for SVM," Mathematical Programming, vol. 127 (1), pp. 3--30, 2011.
-    #
+    # *Reference*
+    # 1. S. Shalev-Shwartz, Y. Singer, N. Srebro, and A. Cotter, "Pegasos: Primal Estimated sub-GrAdient SOlver for SVM," Mathematical Programming, vol. 127 (1), pp. 3--30, 2011.
     class LogisticRegression
       include Base::BaseEstimator
       include Base::Classifier
 
-      DEFAULT_PARAMS = { # :nodoc:
+      # @!visibility private
+      DEFAULT_PARAMS = {
         reg_param: 1.0,
+        fit_bias: false,
+        bias_scale: 1.0,
         max_iter: 100,
         batch_size: 50,
         random_seed: nil
       }.freeze
 
-      # The weight vector for Logistic Regression.
+      # Return the weight vector for Logistic Regression.
+      # @return [NMatrix] (shape: [1, n_features])
       attr_reader :weight_vec
 
-      # The random generator for performing random sampling in the SGD optimization.
+      # Return the bias term (a.k.a. intercept) for Logistic Regression.
+      # @return [Float]
+      attr_reader :bias_term
+
+      # Return the random generator for transformation.
+      # @return [Random]
       attr_reader :rng
 
       # Create a new classifier with Logisitc Regression by the SGD optimization.
       #
-      # :call-seq:
-      #   new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> LogisiticRegression
+      # @overload new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> LogisiticRegression
       #
-      # * *Arguments* :
-      #   - +:reg_param+ (Float) (defaults to: 1.0) -- The regularization parameter.
-      #   - +:max_iter+ (Integer) (defaults to: 100) -- The maximum number of iterations.
-      #   - +:batch_size+ (Integer) (defaults to: 50) -- The size of the mini batches.
-      #   - +:random_seed+ (Integer) (defaults to: nil) -- The seed value using to initialize the random generator.
+      # @param reg_param   [Float] (defaults to: 1.0) The regularization parameter.
+      # @param fit_bias    [Boolean] (defaults to: false) The flag indicating whether to fit the bias term.
+      # @param bias_scale  [Float] (defaults to: 1.0) The scale of the bias term.
+      #   If fit_bias is true, the feature vector v becoms [v; bias_scale].
+      # @param max_iter    [Integer] (defaults to: 100) The maximum number of iterations.
+      # @param batch_size  [Integer] (defaults to: 50) The size of the mini batches.
+      # @param random_seed [Integer] (defaults to: nil) The seed value using to initialize the random generator.
       def initialize(params = {})
         self.params = DEFAULT_PARAMS.merge(Hash[params.map { |k, v| [k.to_sym, v] }])
         self.params[:random_seed] ||= srand
         @weight_vec = nil
+        @bias_term = 0.0
         @rng = Random.new(self.params[:random_seed])
       end
 
       # Fit the model with given training data.
       #
-      # :call-seq:
-      #   fit(x, y) -> LogisticRegression
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The training data to be used for fitting the model.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- The categorical variables (e.g. labels) to be used for fitting the model.
-      # * *Returns* :
-      #   - The learned classifier itself.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [NMatrix] (shape: [1, n_samples]) The categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [LogisticRegression] The learned classifier itself.
       def fit(x, y)
-        # Generate binary labels
+        # Generate binary labels.
         negative_label = y.uniq.sort.shift
         bin_y = y.to_flat_a.map { |l| l != negative_label ? 1 : 0 }
+        # Expand feature vectors for bias term.
+        samples = x
+        samples = samples.hconcat(NMatrix.ones([x.shape[0], 1]) * params[:bias_scale]) if params[:fit_bias]
         # Initialize some variables.
-        n_samples, n_features = x.shape
+        n_samples, n_features = samples.shape
         rand_ids = [*0..n_samples - 1].shuffle(random: @rng)
-        @weight_vec = NMatrix.zeros([1, n_features])
+        weight_vec = NMatrix.zeros([1, n_features])
         # Start optimization.
         params[:max_iter].times do |t|
           # random sampling
@@ -76,84 +87,75 @@ module SVMKit
           eta = 1.0 / (params[:reg_param] * (t + 1))
           mean_vec = NMatrix.zeros([1, n_features])
           subset_ids.each do |n|
-            z = @weight_vec.dot(x.row(n).transpose)[0]
+            z = weight_vec.dot(samples.row(n).transpose)[0]
             coef = bin_y[n] / (1.0 + Math.exp(bin_y[n] * z))
-            mean_vec += x.row(n) * coef
+            mean_vec += samples.row(n) * coef
           end
           mean_vec *= eta / params[:batch_size]
-          @weight_vec = @weight_vec * (1.0 - eta * params[:reg_param]) + mean_vec
+          weight_vec = weight_vec * (1.0 - eta * params[:reg_param]) + mean_vec
           # scale the weight vector.
-          scaler = (1.0 / params[:reg_param]**0.5) / @weight_vec.norm2
-          @weight_vec *= [1.0, scaler].min
+          scaler = (1.0 / params[:reg_param]**0.5) / weight_vec.norm2
+          weight_vec *= [1.0, scaler].min
+        end
+        # Store the learned model.
+        if params[:fit_bias]
+          @weight_vec = weight_vec[0...n_features - 1]
+          @bias_term = weight_vec[n_features - 1]
+        else
+          @weight_vec = weight_vec[0...n_features]
+          @bias_term = 0.0
         end
         self
       end
 
       # Calculate confidence scores for samples.
       #
-      # :call-seq:
-      #   decision_function(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to compute the scores.
-      # * *Returns* :
-      #   - Confidence score per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [NMatrix] (shape: [1, n_samples]) Confidence score per sample.
       def decision_function(x)
-        w = (@weight_vec.dot(x.transpose) * -1.0).exp + 1.0
+        w = ((@weight_vec.dot(x.transpose) + @bias_term) * -1.0).exp + 1.0
         w.map { |v| 1.0 / v }
       end
 
       # Predict class labels for samples.
       #
-      # :call-seq:
-      #   predict(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to predict the labels.
-      # * *Returns* :
-      #   - Predicted class label per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [NMatrix] (shape: [1, n_samples]) Predicted class label per sample.
       def predict(x)
         decision_function(x).map { |v| v >= 0.5 ? 1 : -1 }
       end
 
       # Predict probability for samples.
       #
-      # :call-seq:
-      #   predict_proba(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to predict the probailities.
-      # * *Returns* :
-      #   - Predicted probability per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to predict the probailities.
+      # @return [NMatrix] (shape: [1, n_samples]) Predicted probability per sample.
       def predict_proba(x)
         decision_function(x)
       end
 
       # Claculate the mean accuracy of the given testing data.
       #
-      # :call-seq:
-      #   score(x, y) -> Float
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- Testing data.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- True labels for testing data.
-      # * *Returns* :
-      #   - Mean accuracy
+      # @param x [NMatrix] (shape: [n_samples, n_features]) Testing data.
+      # @param y [NMatrix] (shape: [1, n_samples]) True labels for testing data.
+      # @return [Float] Mean accuracy
       def score(x, y)
         p = predict(x)
         n_hits = (y.to_flat_a.map.with_index { |l, n| l == p[n] ? 1 : 0 }).inject(:+)
         n_hits / y.size.to_f
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
-        { params: params, weight_vec: Utils.dump_nmatrix(@weight_vec), rng: @rng }
+      # Dump marshal data.
+      # @return [Hash] The marshal data about LogisticRegression.
+      def marshal_dump
+        { params: params, weight_vec: Utils.dump_nmatrix(@weight_vec), bias_term: @bias_term, rng: @rng }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         self.params = obj[:params]
         @weight_vec = Utils.restore_nmatrix(obj[:weight_vec])
+        @bias_term = obj[:bias_term]
         @rng = obj[:rng]
         nil
       end

data/lib/svmkit/linear_model/pegasos_svc.rb

@@ -6,140 +6,144 @@ module SVMKit
   module LinearModel
     # PegasosSVC is a class that implements Support Vector Classifier with the Pegasos algorithm.
     #
+    # @example
     #   estimator =
     #     SVMKit::LinearModel::PegasosSVC.new(reg_param: 1.0, max_iter: 100, batch_size: 20, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
     #
-    # * *Reference*:
-    #   - S. Shalev-Shwartz and Y. Singer, "Pegasos: Primal Estimated sub-GrAdient SOlver for SVM," Proc. ICML'07, pp. 807--814, 2007.
-    #
+    # *Reference*
+    # 1. S. Shalev-Shwartz and Y. Singer, "Pegasos: Primal Estimated sub-GrAdient SOlver for SVM," Proc. ICML'07, pp. 807--814, 2007.
     class PegasosSVC
       include Base::BaseEstimator
       include Base::Classifier
 
-      DEFAULT_PARAMS = { # :nodoc:
+      # @!visibility private
+      DEFAULT_PARAMS = {
         reg_param: 1.0,
+        fit_bias: false,
+        bias_scale: 1.0,
         max_iter: 100,
         batch_size: 50,
         random_seed: nil
       }.freeze
 
-      # The weight vector for SVC.
+      # Return the weight vector for SVC.
+      # @return [NMatrix] (shape: [1, n_features])
       attr_reader :weight_vec
 
-      # The random generator for performing random sampling in the Pegasos algorithm.
+      # Return the bias term (a.k.a. intercept) for SVC.
+      # @return [Float]
+      attr_reader :bias_term
+
+      # Return the random generator for performing random sampling in the Pegasos algorithm.
+      # @return [Random]
       attr_reader :rng
 
       # Create a new classifier with Support Vector Machine by the Pegasos algorithm.
       #
-      # :call-seq:
-      #   new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> PegasosSVC
+      # @overload new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> PegasosSVC
       #
-      # * *Arguments* :
-      #   - +:reg_param+ (Float) (defaults to: 1.0) -- The regularization parameter.
-      #   - +:max_iter+ (Integer) (defaults to: 100) -- The maximum number of iterations.
-      #   - +:batch_size+ (Integer) (defaults to: 50) -- The size of the mini batches.
-      #   - +:random_seed+ (Integer) (defaults to: nil) -- The seed value using to initialize the random generator.
+      # @param reg_param   [Float] (defaults to: 1.0) The regularization parameter.
+      # @param fit_bias    [Boolean] (defaults to: false) The flag indicating whether to fit the bias term.
+      # @param bias_scale  [Float] (defaults to: 1.0) The scale of the bias term.
+      # @param max_iter    [Integer] (defaults to: 100) The maximum number of iterations.
+      # @param batch_size  [Integer] (defaults to: 50) The size of the mini batches.
+      # @param random_seed [Integer] (defaults to: nil) The seed value using to initialize the random generator.
       def initialize(params = {})
         self.params = DEFAULT_PARAMS.merge(Hash[params.map { |k, v| [k.to_sym, v] }])
         self.params[:random_seed] ||= srand
         @weight_vec = nil
+        @bias_term = 0.0
         @rng = Random.new(self.params[:random_seed])
       end
 
       # Fit the model with given training data.
       #
-      # :call-seq:
-      #   fit(x, y) -> PegasosSVC
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The training data to be used for fitting the model.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- The labels to be used for fitting the model.
-      # * *Returns* :
-      #   - The learned classifier itself.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [NMatrix] (shape: [1, n_samples]) The labels to be used for fitting the model.
+      # @return [PegasosSVC] The learned classifier itself.
       def fit(x, y)
         # Generate binary labels
         negative_label = y.uniq.sort.shift
         bin_y = y.to_flat_a.map { |l| l != negative_label ? 1 : -1 }
+        # Expand feature vectors for bias term.
+        samples = x
+        samples = samples.hconcat(NMatrix.ones([x.shape[0], 1]) * params[:bias_scale]) if params[:fit_bias]
         # Initialize some variables.
-        n_samples, n_features = x.shape
+        n_samples, n_features = samples.shape
         rand_ids = [*0..n_samples - 1].shuffle(random: @rng)
-        @weight_vec = NMatrix.zeros([1, n_features])
+        weight_vec = NMatrix.zeros([1, n_features])
         # Start optimization.
         params[:max_iter].times do |t|
           # random sampling
           subset_ids = rand_ids.shift(params[:batch_size])
           rand_ids.concat(subset_ids)
           target_ids = subset_ids.map do |n|
-            n if @weight_vec.dot(x.row(n).transpose) * bin_y[n] < 1
+            n if weight_vec.dot(samples.row(n).transpose) * bin_y[n] < 1
           end
           n_subsamples = target_ids.size
           next if n_subsamples.zero?
           # update the weight vector.
           eta = 1.0 / (params[:reg_param] * (t + 1))
           mean_vec = NMatrix.zeros([1, n_features])
-          target_ids.each { |n| mean_vec += x.row(n) * bin_y[n] }
+          target_ids.each { |n| mean_vec += samples.row(n) * bin_y[n] }
           mean_vec *= eta / n_subsamples
-          @weight_vec = @weight_vec * (1.0 - eta * params[:reg_param]) + mean_vec
+          weight_vec = weight_vec * (1.0 - eta * params[:reg_param]) + mean_vec
           # scale the weight vector.
-          scaler = (1.0 / params[:reg_param]**0.5) / @weight_vec.norm2
-          @weight_vec *= [1.0, scaler].min
+          scaler = (1.0 / params[:reg_param]**0.5) / weight_vec.norm2
+          weight_vec *= [1.0, scaler].min
+        end
+        # Store the learned model.
+        if params[:fit_bias]
+          @weight_vec = weight_vec[0...n_features - 1]
+          @bias_term = weight_vec[n_features - 1]
+        else
+          @weight_vec = weight_vec[0...n_features]
+          @bias_term = 0.0
         end
         self
       end
 
       # Calculate confidence scores for samples.
       #
-      # :call-seq:
-      #   decision_function(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to compute the scores.
-      # * *Returns* :
-      #   - Confidence score per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [NMatrix] (shape: [1, n_samples]) Confidence score per sample.
       def decision_function(x)
-        @weight_vec.dot(x.transpose)
+        @weight_vec.dot(x.transpose) + @bias_term
       end
 
       # Predict class labels for samples.
       #
-      # :call-seq:
-      #   predict(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to predict the labels.
-      # * *Returns* :
-      #   - Predicted class label per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [NMatrix] (shape: [1, n_samples]) Predicted class label per sample.
       def predict(x)
         decision_function(x).map { |v| v >= 0 ? 1 : -1 }
       end
 
       # Claculate the mean accuracy of the given testing data.
       #
-      # :call-seq:
-      #   score(x, y) -> Float
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- Testing data.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- True labels for testing data.
-      # * *Returns* :
-      #   - Mean accuracy
+      # @param x [NMatrix] (shape: [n_samples, n_features]) Testing data.
+      # @param y [NMatrix] (shape: [1, n_samples]) True labels for testing data.
+      # @return [Float] Mean accuracy
       def score(x, y)
         p = predict(x)
         n_hits = (y.to_flat_a.map.with_index { |l, n| l == p[n] ? 1 : 0 }).inject(:+)
         n_hits / y.size.to_f
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
-        { params: params, weight_vec: Utils.dump_nmatrix(@weight_vec), rng: @rng }
+      # Dump marshal data.
+      # @return [Hash] The marshal data about PegasosSVC.
+      def marshal_dump
+        { params: params, weight_vec: Utils.dump_nmatrix(@weight_vec), bias_term: @bias_term, rng: @rng }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         self.params = obj[:params]
         @weight_vec = Utils.restore_nmatrix(obj[:weight_vec])
+        @bias_term = obj[:bias_term]
         @rng = obj[:rng]
         nil
       end

data/lib/svmkit/multiclass/one_vs_rest_classifier.rb

@@ -6,33 +6,34 @@ module SVMKit
   module Multiclass
     # OneVsRestClassifier is a class that implements One-vs-Rest (OvR) strategy for multi-label classification.
     #
+    # @example
     #   base_estimator =
     #    SVMKit::LinearModel::PegasosSVC.new(penalty: 1.0, max_iter: 100, batch_size: 20, random_seed: 1)
     #   estimator = SVMKit::Multiclass::OneVsRestClassifier.new(estimator: base_estimator)
     #   estimator.fit(training_samples, training_labels)
     #   results = estimator.predict(testing_samples)
-    #
     class OneVsRestClassifier
       include Base::BaseEstimator
       include Base::Classifier
 
-      DEFAULT_PARAMS = { # :nodoc:
+      # @!visibility private
+      DEFAULT_PARAMS = {
         estimator: nil
       }.freeze
 
-      # The set of estimators.
+      # Return the set of estimators.
+      # @return [Array<Classifier>]
       attr_reader :estimators
 
-      # The class labels.
+      # Return the class labels.
+      # @return [NMatrix] (shape: [1, n_classes])
       attr_reader :classes
 
       # Create a new multi-label classifier with the one-vs-rest startegy.
       #
-      # :call-seq:
-      #   new(estimator: base_estimator) -> OneVsRestClassifier
-      #
-      # * *Arguments* :
-      #   - +:estimator+ (Classifier) (defaults to: nil) -- The (binary) classifier for construction a multi-label classifier.
+      # @overload new(estimator: base_estimator) -> OneVsRestClassifier
+      # @param estimator [Classifier] (defaults to: nil)
+      #   The (binary) classifier for construction a multi-label classifier.
       def initialize(params = {})
         self.params = DEFAULT_PARAMS.merge(Hash[params.map { |k, v| [k.to_sym, v] }])
         @estimators = nil
@@ -41,14 +42,9 @@ module SVMKit
 
       # Fit the model with given training data.
       #
-      # :call-seq:
-      #   fit(x, y) -> OneVsRestClassifier
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The training data to be used for fitting the model.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- The labels to be used for fitting the model.
-      # * *Returns* :
-      #   - The learned classifier itself.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [NMatrix] (shape: [1, n_samples]) The labels to be used for fitting the model.
+      # @return [OneVsRestClassifier] The learned classifier itself.
       def fit(x, y)
         @classes = y.uniq.sort
         @estimators = @classes.map do |label|
@@ -60,13 +56,8 @@ module SVMKit
 
       # Calculate confidence scores for samples.
       #
-      # :call-seq:
-      #   decision_function(x) -> NMatrix, shape: [n_samples, n_classes]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to compute the scores.
-      # * *Returns* :
-      #   - Confidence scores per sample for each class.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [NMatrix] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
       def decision_function(x)
         n_samples, = x.shape
         n_classes = @classes.size
@@ -78,13 +69,8 @@ module SVMKit
 
       # Predict class labels for samples.
       #
-      # :call-seq:
-      #   predict(x) -> NMatrix, shape: [1, n_samples]
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to predict the labels.
-      # * *Returns* :
-      #   - Predicted class label per sample.
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [NMatrix] (shape: [1, n_samples]) Predicted class label per sample.
       def predict(x)
         n_samples, = x.shape
         decision_values = decision_function(x)
@@ -94,29 +80,26 @@ module SVMKit
 
       # Claculate the mean accuracy of the given testing data.
       #
-      # :call-seq:
-      #   predict(x, y) -> Float
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- Testing data.
-      #   - +y+ (NMatrix, shape: [1, n_samples]) -- True labels for testing data.
-      # * *Returns* :
-      #   - Mean accuracy
+      # @param x [NMatrix] (shape: [n_samples, n_features]) Testing data.
+      # @param y [NMatrix] (shape: [1, n_samples]) True labels for testing data.
+      # @return [Float] Mean accuracy
       def score(x, y)
         p = predict(x)
         n_hits = (y.to_flat_a.map.with_index { |l, n| l == p[n] ? 1 : 0 }).inject(:+)
         n_hits / y.size.to_f
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
+      # Dump marshal data.
+      # @return [Hash] The marshal data about OneVsRestClassifier.
+      def marshal_dump
         { params: params,
           classes: @classes,
           estimators: @estimators.map { |e| Marshal.dump(e) } }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         self.params = obj[:params]
         @classes = obj[:classes]
         @estimators = obj[:estimators].map { |e| Marshal.load(e) }

data/lib/svmkit/preprocessing/l2_normalizer.rb

@@ -6,32 +6,30 @@ module SVMKit
   module Preprocessing
     # Normalize samples to unit L2-norm.
     #
+    # @example
     #   normalizer = SVMKit::Preprocessing::StandardScaler.new
     #   new_samples = normalizer.fit_transform(samples)
     class L2Normalizer
       include Base::BaseEstimator
       include Base::Transformer
 
-      # The vector consists of norms of each sample.
+      # Return the vector consists of L2-norm for each sample.
+      # @return [NMatrix] (shape: [1, n_samples])
       attr_reader :norm_vec # :nodoc:
 
       # Create a new normalizer for normaliing to unit L2-norm.
       #
-      # :call-seq:
-      #   new() -> L2Normalizer
+      # @overload new() -> L2Normalizer
       def initialize(_params = {})
         @norm_vec = nil
       end
 
-      # Calculate L2 norms of each sample.
+      # Calculate L2-norms of each sample.
       #
-      # :call-seq:
-      #   fit(x) -> L2Normalizer
+      # @overload fit(x) -> L2Normalizer
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate L2-norms.
-      # * *Returns* :
-      #   - L2Normalizer
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [L2Normalizer]
       def fit(x, _y = nil)
         n_samples, = x.shape
         @norm_vec = NMatrix.new([1, n_samples],
@@ -39,15 +37,12 @@ module SVMKit
         self
       end
 
-      # Calculate L2 norms of each sample, and then normalize samples to unit L2-norm.
+      # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
       #
-      # :call-seq:
-      #   fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> NMatrix
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate L2-norms.
-      # * *Returns* :
-      #   - The normalized samples (NMatrix)
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [NMatrix] The normalized samples.
       def fit_transform(x, _y = nil)
         fit(x)
         x / @norm_vec.transpose.repeat(x.shape[1], 1)

data/lib/svmkit/preprocessing/min_max_scaler.rb

@@ -6,6 +6,7 @@ module SVMKit
   module Preprocessing
     # Normalize samples by scaling each feature to a given range.
     #
+    # @example
     #   normalizer = SVMKit::Preprocessing::MinMaxScaler.new(feature_range: [0.0, 1.0])
     #   new_training_samples = normalizer.fit_transform(training_samples)
     #   new_testing_samples = normalizer.transform(testing_samples)
@@ -13,23 +14,24 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Transformer
 
-      DEFAULT_PARAMS = { # :nodoc:
+      # @!visibility private
+      DEFAULT_PARAMS = {
         feature_range: [0.0, 1.0]
       }.freeze
 
-      # The vector consists of the minimum value for each feature.
-      attr_reader :min_vec # :nodoc:
+      # Return the vector consists of the minimum value for each feature.
+      # @return [NMatrix] (shape: [1, n_features])
+      attr_reader :min_vec
 
-      # The vector consists of the maximum value for each feature.
-      attr_reader :max_vec # :nodoc:
+      # Return the vector consists of the maximum value for each feature.
+      # @return [NMatrix] (shape: [1, n_features])
+      attr_reader :max_vec
 
       # Creates a new normalizer for scaling each feature to a given range.
       #
-      # call-seq:
-      #   new(feature_range: [0.0, 1.0]) -> MinMaxScaler
+      # @overload new(feature_range: [0.0, 1.0]) -> MinMaxScaler
       #
-      # * *Arguments* :
-      #   - +:feature_range+ (Array) (defaults to: [0.0, 1.0]) -- The desired range of samples.
+      # @param feature_range [Array] (defaults to: [0.0, 1.0]) The desired range of samples.
       def initialize(params = {})
         @params = DEFAULT_PARAMS.merge(Hash[params.map { |k, v| [k.to_sym, v] }])
         @min_vec = nil
@@ -38,13 +40,10 @@ module SVMKit
 
       # Calculate the minimum and maximum value of each feature for scaling.
       #
-      # :call-seq:
-      #   fit(x) -> MinMaxScaler
+      # @overload fit(x) -> MinMaxScaler
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate the minimum and maximum values.
-      # * *Returns* :
-      #   - MinMaxScaler
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @return [MinMaxScaler]
       def fit(x, _y = nil)
         @min_vec = x.min(0)
         @max_vec = x.max(0)
@@ -53,26 +52,18 @@ module SVMKit
 
       # Calculate the minimum and maximum values, and then normalize samples to feature_range.
       #
-      # :call-seq:
-      #   fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> NMatrix
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate the minimum and maximum values.
-      # * *Returns* :
-      #   - The scaled samples (NMatrix)
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @return [NMatrix] The scaled samples.
       def fit_transform(x, _y = nil)
         fit(x).transform(x)
       end
 
       # Perform scaling the given samples according to feature_range.
       #
-      # call-seq:
-      #   transform(x) -> NMatrix
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to be scaled.
-      # * *Returns* :
-      #   - The scaled samples (NMatrix)
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [NMatrix] The scaled samples.
       def transform(x)
         n_samples, = x.shape
         dif_vec = @max_vec - @min_vec
@@ -80,15 +71,17 @@ module SVMKit
         nx * (@params[:feature_range][1] - @params[:feature_range][0]) + @params[:feature_range][0]
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
+      # Dump marshal data.
+      # @return [Hash] The marshal data about MinMaxScaler.
+      def marshal_dump
         { params: @params,
           min_vec: Utils.dump_nmatrix(@min_vec),
           max_vec: Utils.dump_nmatrix(@max_vec) }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         @params = obj[:params]
         @min_vec = Utils.restore_nmatrix(obj[:min_vec])
         @max_vec = Utils.restore_nmatrix(obj[:max_vec])

data/lib/svmkit/preprocessing/standard_scaler.rb

@@ -6,6 +6,7 @@ module SVMKit
   module Preprocessing
     # Normalize samples by centering and scaling to unit variance.
     #
+    # @example
     #   normalizer = SVMKit::Preprocessing::StandardScaler.new
     #   new_training_samples = normalizer.fit_transform(training_samples)
     #   new_testing_samples = normalizer.transform(testing_samples)
@@ -13,16 +14,17 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Transformer
 
-      # The vector consists of the mean value for each feature.
-      attr_reader :mean_vec # :nodoc:
+      # Return the vector consists of the mean value for each feature.
+      # @return [NMatrix] (shape: [1, n_features])
+      attr_reader :mean_vec
 
-      # The vector consists of the standard deviation for each feature.
-      attr_reader :std_vec # :nodoc:
+      # Return the vector consists of the standard deviation for each feature.
+      # @return [NMatrix] (shape: [1, n_features])
+      attr_reader :std_vec
 
       # Create a new normalizer for centering and scaling to unit variance.
       #
-      # :call-seq:
-      #   new() -> StandardScaler
+      # @overload new() -> StandardScaler
       def initialize(_params = {})
         @mean_vec = nil
         @std_vec = nil
@@ -30,13 +32,11 @@ module SVMKit
 
       # Calculate the mean value and standard deviation of each feature for scaling.
       #
-      # :call-seq:
-      #   fit(x) -> StandardScaler
+      # @overload fit(x) -> StandardScaler
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate the mean values and standard deviations.
-      # * *Returns* :
-      #   - StandardScaler
+      # @param x [NMatrix] (shape: [n_samples, n_features])
+      #   The samples to calculate the mean values and standard deviations.
+      # @return [StandardScaler]
       def fit(x, _y = nil)
         @mean_vec = x.mean(0)
         @std_vec = x.std(0)
@@ -45,39 +45,34 @@ module SVMKit
 
       # Calculate the mean values and standard deviations, and then normalize samples using them.
       #
-      # :call-seq:
-      #   fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> NMatrix
       #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to calculate the mean values and standard deviations.
-      # * *Returns* :
-      #   - The scaled samples (NMatrix)
+      # @param x [NMatrix] (shape: [n_samples, n_features])
+      #   The samples to calculate the mean values and standard deviations.
+      # @return [NMatrix] The scaled samples.
       def fit_transform(x, _y = nil)
         fit(x).transform(x)
       end
 
       # Perform standardization the given samples.
       #
-      # call-seq:
-      #   transform(x) -> NMatrix
-      #
-      # * *Arguments* :
-      #   - +x+ (NMatrix, shape: [n_samples, n_features]) -- The samples to be scaled.
-      # * *Returns* :
-      #   - The scaled samples (NMatrix)
+      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [NMatrix] The scaled samples.
       def transform(x)
         n_samples, = x.shape
         (x - @mean_vec.repeat(n_samples, 0)) / @std_vec.repeat(n_samples, 0)
       end
 
-      # Serializes object through Marshal#dump.
-      def marshal_dump # :nodoc:
+      # Dump marshal data.
+      # @return [Hash] The marshal data about StandardScaler.
+      def marshal_dump
         { mean_vec: Utils.dump_nmatrix(@mean_vec),
           std_vec: Utils.dump_nmatrix(@std_vec) }
       end
 
-      # Deserialize object through Marshal#load.
-      def marshal_load(obj) # :nodoc:
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
         @mean_vec = Utils.restore_nmatrix(obj[:mean_vec])
         @std_vec = Utils.restore_nmatrix(obj[:std_vec])
         nil

data/lib/svmkit/utils.rb

@@ -3,13 +3,9 @@ module SVMKit
   module Utils
     class << self
       # Dump an NMatrix object converted to a Ruby Hash.
-      # # call-seq:
-      #   dump_nmatrix(mat) -> Hash
       #
-      # * *Arguments* :
-      #   - +mat+ -- An NMatrix object converted to a Ruby Hash.
-      # * *Returns* :
-      #   - A Ruby Hash containing matrix information.
+      # @param mat [NMatrix] An NMatrix object converted to a Ruby Hash.
+      # @return [Hash] A Ruby Hash containing matrix information.
       def dump_nmatrix(mat)
         return nil if mat.class != NMatrix
         { shape: mat.shape, array: mat.to_flat_a, dtype: mat.dtype, stype: mat.stype }
@@ -17,13 +13,8 @@ module SVMKit
 
       # Return the results of converting the dumped data into an NMatrix object.
       #
-      # call-seq:
-      #   restore_nmatrix(dumped_mat) -> NMatrix
-      #
-      # * *Arguments* :
-      #   - +dumpted_mat+ -- A Ruby Hash about NMatrix object created with SVMKit::Utils.dump_nmatrix method.
-      # * *Returns* :
-      #   - An NMatrix object restored from the given Hash.
+      # @param dmp [Hash] A Ruby Hash about NMatrix object created with SVMKit::Utils.dump_nmatrix method.
+      # @return [NMatrix] An NMatrix object restored from the given Hash.
       def restore_nmatrix(dmp = {})
         return nil unless dmp.class == Hash && %i[shape array dtype stype].all?(&dmp.method(:has_key?))
         NMatrix.new(dmp[:shape], dmp[:array], dtype: dmp[:dtype], stype: dmp[:stype])

data/lib/svmkit/version.rb

@@ -1,3 +1,5 @@
+# SVMKit is an experimental library of machine learning in Ruby.
 module SVMKit
-  VERSION = '0.1.1'.freeze
+  # @!visibility private
+  VERSION = '0.1.2'.freeze
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svmkit
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-10-03 00:00:00.000000000 Z
+date: 2017-10-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler