svmkit 0.2.4 → 0.2.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 22a165e3fa579d5a5d0dbd9095d208dd09d5fbd0
-  data.tar.gz: c3f7fa2f4fe115dc821ec5050cf7c1f0fdd75a36
+  metadata.gz: 42b8bbee820defc7646b422fa160ade5dd0ffddd
+  data.tar.gz: 5ba44c2c18a02231646456ab1ff73fee409c50c0
 SHA512:
-  metadata.gz: 4002a03944871f2fd9cf305fd64b02d4a1899b291167289d2f78112f977c54b33fc60041b2d2c506d755fb938e4d226002b1d6dc41ea74ad28d0e215adc0ee2b
-  data.tar.gz: 59dc53541aee6832ea66b826cc5f92e1329adba108aa2683ddba9105d8ac28fba7fae483ce1d2c092c60d83e9d3b3adfb574bf11401ad74f24435f237d262871
+  metadata.gz: 23bdab14e55581e61b9050c88167dd74ebd5c086dfa2c37f57aaebe2110e8d7bac70df659ae34615c788d36cd03fac36663267ed07cf950564da7b1e496e9b59
+  data.tar.gz: c36b3565bd731e1613ee63f83ad83f2021e8c2c255267df00a0872ec8f1d9f2e9ab73edd10d5f2a5bef6ca1af8712aef4220434bc680f1f5228bf9727c94b6e4

data/.rubocop.yml

@@ -1,12 +1,13 @@
-#AllCops:
-#  TargetRubyVersion: 2.3
+inherit_from: .rubocop_todo.yml
+
+AllCops:
+  TargetRubyVersion: 2.2
+  DisplayCopNames: true
+  DisplayStyleGuide: true
 
 Documentation:
   Enabled: false
 
-Metrics/AbcSize:
-  Max: 30
-
 Metrics/LineLength:
   Max: 120
   IgnoredPatterns: ['(\A|\s)#']

data/.rubocop_todo.yml

@@ -0,0 +1,18 @@
+# This configuration was generated by
+# `rubocop --auto-gen-config`
+# on 2018-02-04 11:34:28 +0900 using RuboCop version 0.52.1.
+# The point is for the user to remove these configuration records
+# one by one as the offenses are removed from the code base.
+# Note that changes in the inspected code, or installation of new
+# versions of RuboCop, may require this file to be generated again.
+
+# Offense count: 5
+Metrics/AbcSize:
+  Max: 70
+
+# Offense count: 4
+# Configuration parameters: .
+# SupportedStyles: annotated, template, unannotated
+Style/FormatStringToken:
+  EnforcedStyle: unannotated
+  Enabled: false

data/HISTORY.md

@@ -1,3 +1,8 @@
+# 0.2.5
+- Added classes for Naive Bayes classifier.
+- Fixed decision function method on Logistic Regression class.
+- Fixed method visibility on RBF kernel approximation class.
+
 # 0.2.4
 - Added class for Factorization Machine classifier.
 - Added classes for evaluation measures.

data/README.md

@@ -5,10 +5,10 @@
 [![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 machine learninig library in Ruby.
-SVMKit implements machine learning algorithms with interfaces similar to Scikit-Learn in Python.
-Since the development of SVMKit has just getting started,
-the methods implemented in SVMKit are only Linear / Kernel SVC,
-Logistic Regression, Factorization Machine, K-nearest neighbor classifier, and cross-validation.
+SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+SVMKit currently supports Linear / Kernel Support Vector Machine,
+Logistic Regression, Factorization Machine, Naive Bayes,
+K-nearest neighbor classifier, and cross-validation.
 
 ## Installation
 

data/lib/svmkit.rb

@@ -16,6 +16,7 @@ require 'svmkit/kernel_machine/kernel_svc'
 require 'svmkit/polynomial_model/factorization_machine_classifier'
 require 'svmkit/multiclass/one_vs_rest_classifier'
 require 'svmkit/nearest_neighbors/k_neighbors_classifier'
+require 'svmkit/naive_bayes/naive_bayes'
 require 'svmkit/preprocessing/l2_normalizer'
 require 'svmkit/preprocessing/min_max_scaler'
 require 'svmkit/preprocessing/standard_scaler'

data/lib/svmkit/kernel_approximation/rbf.rb

@@ -104,7 +104,7 @@ module SVMKit
         nil
       end
 
-      protected
+      private
 
       # Generate the uniform random matrix with the given shape.
       def rand_uniform(shape)

data/lib/svmkit/linear_model/logistic_regression.rb

@@ -112,8 +112,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
       # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
       def decision_function(x)
-        w = Numo::NMath.exp(((@weight_vec.dot(x.transpose) + @bias_term) * -1.0)) + 1.0
-        w.map { |v| 1.0 / v }
+        @weight_vec.dot(x.transpose) + @bias_term
       end
 
       # Predict class labels for samples.
@@ -121,7 +120,7 @@ module SVMKit
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
       # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
       def predict(x)
-        Numo::Int32.cast(decision_function(x).map { |v| v >= 0.5 ? 1 : -1 })
+        Numo::Int32.cast(sigmoid(decision_function(x)).map { |v| v >= 0.5 ? 1 : -1 })
       end
 
       # Predict probability for samples.
@@ -131,7 +130,7 @@ module SVMKit
       def predict_proba(x)
         n_samples, = x.shape
         proba = Numo::DFloat.zeros(n_samples, 2)
-        proba[true, 1] = decision_function(x)
+        proba[true, 1] = sigmoid(decision_function(x))
         proba[true, 0] = 1.0 - proba[true, 1]
         proba
       end
@@ -162,6 +161,12 @@ module SVMKit
         @rng = obj[:rng]
         nil
       end
+
+      private
+
+      def sigmoid(x)
+        1.0 / (Numo::NMath.exp(-x) + 1.0)
+      end
     end
   end
 end

data/lib/svmkit/naive_bayes/naive_bayes.rb

@@ -0,0 +1,304 @@
+require 'svmkit/base/base_estimator'
+require 'svmkit/base/classifier'
+
+module SVMKit
+  # This module consists of the classes that implement naive bayes models.
+  module NaiveBayes
+    # BaseNaiveBayes is a class that has methods for common processes of naive bayes classifier.
+    class BaseNaiveBayes
+      include Base::BaseEstimator
+      include Base::Classifier
+
+      # Predict class labels for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the labels.
+      # @return [Numo::Int32] (shape: [n_samples]) Predicted class label per sample.
+      def predict(x)
+        n_samples = x.shape.first
+        decision_values = decision_function(x)
+        Numo::Int32.asarray(Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] })
+      end
+
+      # Predict log-probability for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the log-probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted log-probability of each class per sample.
+      def predict_log_proba(x)
+        n_samples, = x.shape
+        log_likelihoods = decision_function(x)
+        log_likelihoods - Numo::NMath.log(Numo::NMath.exp(log_likelihoods).sum(1)).reshape(n_samples, 1)
+      end
+
+      # Predict probability for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
+      def predict_proba(x)
+        Numo::NMath.exp(predict_log_proba(x)).abs
+      end
+
+      # Claculate the mean accuracy of the given testing data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
+      # @param y [Numo::Int32] (shape: [n_samples]) True labels for testing data.
+      # @return [Float] Mean accuracy
+      def score(x, y)
+        evaluator = SVMKit::EvaluationMeasure::Accuracy.new
+        evaluator.score(y, predict(x))
+      end
+    end
+
+    # GaussianNB is a class that implements Gaussian Naive Bayes classifier.
+    #
+    # @example
+    #   estimator = SVMKit::NaiveBayes::GaussianNB.new
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    class GaussianNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the mean vectors of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :means
+
+      # Return the variance vectors of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :variances
+
+      # Create a new classifier with Gaussian Naive Bayes.
+      def initialize
+        @params = {}
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [GaussianNB] The learned classifier itself.
+      def fit(x, y)
+        n_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
+        @means = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].mean(0) }]
+        @variances = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].var(0) }]
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
+      def decision_function(x)
+        n_classes = @classes.size
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) - 0.5 * (
+            Numo::NMath.log(2.0 * Math::PI * @variances[l, true]) +
+            ((x - @means[l, true])**2 / @variances[l, true])).sum(1)
+        end
+        Numo::DFloat[*log_likelihoods].transpose
+      end
+
+      # Dump marshal data.
+      #
+      # @return [Hash] The marshal data about GaussianNB.
+      def marshal_dump
+        { params: params,
+          classes: @classes,
+          class_priors: @class_priors,
+          means: @means,
+          variances: @variances }
+      end
+
+      # Load marshal data.
+      #
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @classes = obj[:classes]
+        @class_priors = obj[:class_priors]
+        @means = obj[:means]
+        @variances = obj[:variances]
+        nil
+      end
+    end
+
+    # MultinomialNB is a class that implements Multinomial Naive Bayes classifier.
+    #
+    # @example
+    #   estimator = SVMKit::NaiveBayes::MultinomialNB.new(smoothing_param: 1.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - C D. Manning, P. Raghavan, and H. Schutze, "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class MultinomialNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Multinomial Naive Bayes.
+      #
+      # @param smoothing_param [Float] The Laplace smoothing parameter.
+      def initialize(smoothing_param: 1.0)
+        @params = {}
+        @params[:smoothing_param] = smoothing_param
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [MultinomialNB] The learned classifier itself.
+      def fit(x, y)
+        n_samples, = x.shape
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        @class_priors = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count / n_samples.to_f }]
+        count_features = Numo::DFloat[*@classes.to_a.map { |l| x[y.eq(l).where, true].sum(0) }]
+        count_features += @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = count_features / count_features.sum(1).reshape(n_classes, 1)
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
+      def decision_function(x)
+        n_classes = @classes.size
+        bin_x = x.gt(0)
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) + (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
+        end
+        Numo::DFloat[*log_likelihoods].transpose
+      end
+
+      # Dump marshal data.
+      #
+      # @return [Hash] The marshal data about MultinomialNB.
+      def marshal_dump
+        { params: params,
+          classes: @classes,
+          class_priors: @class_priors,
+          feature_probs: @feature_probs }
+      end
+
+      # Load marshal data.
+      #
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @classes = obj[:classes]
+        @class_priors = obj[:class_priors]
+        @feature_probs = obj[:feature_probs]
+        nil
+      end
+    end
+
+    # BernoulliNB is a class that implements Bernoulli Naive Bayes classifier.
+    #
+    # @example
+    #   estimator = SVMKit::NaiveBayes::BernoulliNB.new(smoothing_param: 1.0, bin_threshold: 0.0)
+    #   estimator.fit(training_samples, training_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    # *Reference*
+    # - C D. Manning, P. Raghavan, and H. Schutze, "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class BernoulliNB < BaseNaiveBayes
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Return the prior probabilities of the classes.
+      # @return [Numo::DFloat] (shape: [n_classes])
+      attr_reader :class_priors
+
+      # Return the conditional probabilities for features of each class.
+      # @return [Numo::DFloat] (shape: [n_classes, n_features])
+      attr_reader :feature_probs
+
+      # Create a new classifier with Bernoulli Naive Bayes.
+      #
+      # @param smoothing_param [Float] The Laplace smoothing parameter.
+      # @param bin_threshold [Float] The threshold for binarizing of features.
+      def initialize(smoothing_param: 1.0, bin_threshold: 0.0)
+        @params = {}
+        @params[:smoothing_param] = smoothing_param
+        @params[:bin_threshold] = bin_threshold
+      end
+
+      # Fit the model with given training data.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_samples]) The categorical variables (e.g. labels)
+      #   to be used for fitting the model.
+      # @return [BernoulliNB] The learned classifier itself.
+      def fit(x, y)
+        n_samples, = x.shape
+        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
+        @classes = Numo::Int32[*y.to_a.uniq.sort]
+        n_samples_each_class = Numo::DFloat[*@classes.to_a.map { |l| y.eq(l).count.to_f }]
+        @class_priors = n_samples_each_class / n_samples
+        count_features = Numo::DFloat[*@classes.to_a.map { |l| bin_x[y.eq(l).where, true].sum(0) }]
+        count_features += @params[:smoothing_param]
+        n_samples_each_class += 2.0 * @params[:smoothing_param]
+        n_classes = @classes.size
+        @feature_probs = count_features / n_samples_each_class.reshape(n_classes, 1)
+        self
+      end
+
+      # Calculate confidence scores for samples.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Confidence scores per sample for each class.
+      def decision_function(x)
+        n_classes = @classes.size
+        bin_x = Numo::DFloat[*x.gt(@params[:bin_threshold])]
+        not_bin_x = Numo::DFloat[*x.le(@params[:bin_threshold])]
+        log_likelihoods = Array.new(n_classes) do |l|
+          Math.log(@class_priors[l]) + (
+            (Numo::DFloat[*bin_x] * Numo::NMath.log(@feature_probs[l, true])).sum(1)
+            (Numo::DFloat[*not_bin_x] * Numo::NMath.log(1.0 - @feature_probs[l, true])).sum(1))
+        end
+        Numo::DFloat[*log_likelihoods].transpose
+      end
+
+      # Dump marshal data.
+      #
+      # @return [Hash] The marshal data about BernoulliNB.
+      def marshal_dump
+        { params: params,
+          classes: @classes,
+          class_priors: @class_priors,
+          feature_probs: @feature_probs }
+      end
+
+      # Load marshal data.
+      #
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @classes = obj[:classes]
+        @class_priors = obj[:class_priors]
+        @feature_probs = obj[:feature_probs]
+        nil
+      end
+    end
+  end
+end

data/lib/svmkit/polynomial_model/factorization_machine_classifier.rb

@@ -7,12 +7,11 @@ module SVMKit
     # FactorizationMachineClassifier is a class that
     # implements Fatorization Machine for binary classification
     # with (mini-batch) stochastic gradient descent optimization.
-    # Note that this implementation uses hinge loss for the loss function.
     #
     # @example
     #   estimator =
     #     SVMKit::PolynomialModel::FactorizationMachineClassifier.new(
-    #      n_factors: 10, reg_param_bias: 0.001, reg_param_weight: 0.001, reg_param_factor: 0.001,
+    #      n_factors: 10, loss: 'hinge', reg_param_bias: 0.001, reg_param_weight: 0.001, reg_param_factor: 0.001,
     #      max_iter: 5000, batch_size: 50, random_seed: 1)
     #   estimator.fit(training_samples, traininig_labels)
     #   results = estimator.predict(testing_samples)
@@ -43,6 +42,7 @@ module SVMKit
       # Create a new classifier with Support Vector Machine by the Pegasos algorithm.
       #
       # @param n_factors [Integer] The maximum number of iterations.
+      # @param loss [String] The loss function ('hinge' or 'logistic').
       # @param reg_param_bias [Float] The regularization parameter for bias term.
       # @param reg_param_weight [Float] The regularization parameter for weight vector.
       # @param reg_param_factor [Float] The regularization parameter for factor matrix.
@@ -50,10 +50,11 @@ module SVMKit
       # @param max_iter [Integer] The maximum number of iterations.
       # @param batch_size [Integer] The size of the mini batches.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_factors: 2, reg_param_bias: 1.0, reg_param_weight: 1.0, reg_param_factor: 1.0,
+      def initialize(n_factors: 2, loss: 'hinge', reg_param_bias: 1.0, reg_param_weight: 1.0, reg_param_factor: 1.0,
                      init_std: 0.1, max_iter: 1000, batch_size: 10, random_seed: nil)
         @params = {}
         @params[:n_factors] = n_factors
+        @params[:loss] = loss
         @params[:reg_param_bias] = reg_param_bias
         @params[:reg_param_weight] = reg_param_weight
         @params[:reg_param_factor] = reg_param_factor
@@ -122,6 +123,19 @@ module SVMKit
         Numo::Int32.cast(decision_function(x).map { |v| v >= 0.0 ? 1 : -1 })
       end
 
+      # Predict probability for samples.
+      # Note that this method works normally only if the 'loss' parameter is set to 'logistic'.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
+      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
+      def predict_proba(x)
+        n_samples, = x.shape
+        proba = Numo::DFloat.zeros(n_samples, 2)
+        proba[true, 1] = 1.0 / (Numo::NMath.exp(-decision_function(x)) + 1.0)
+        proba[true, 0] = 1.0 - proba[true, 1]
+        proba
+      end
+
       # Claculate the mean accuracy of the given testing data.
       #
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) Testing data.
@@ -152,13 +166,23 @@ module SVMKit
 
       private
 
-      def loss_gradient(x, y)
+      def hinge_loss_gradient(x, y)
         evaluated = y * decision_function(x)
         gradient = Numo::DFloat.zeros(evaluated.size)
         gradient[evaluated < 1.0] = -y[evaluated < 1.0]
         gradient
       end
 
+      def logistic_loss_gradient(x, y)
+        evaluated = y * decision_function(x)
+        sigmoid_func = 1.0 / (Numo::NMath.exp(-evaluated) + 1.0)
+        (sigmoid_func - 1.0) * y
+      end
+
+      def loss_gradient(x, y)
+        @params[:loss] == 'hinge' ? hinge_loss_gradient(x, y) : logistic_loss_gradient(x, y)
+      end
+
       def learning_rate(reg_param, iter)
         1.0 / (reg_param * (iter + 1))
       end

data/lib/svmkit/version.rb

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

data/svmkit.gemspec

@@ -12,14 +12,14 @@ Gem::Specification.new do |spec|
 
   spec.summary       = <<MSG
 SVMKit is a machine learninig library in Ruby.
-SVMKit implements machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
 MSG
   spec.description   = <<MSG
 SVMKit is a machine learninig library in Ruby.
-SVMKit implements machine learning algorithms with interfaces similar to Scikit-Learn in Python.
-Since the development of SVMKit has just getting started,
-the methods implemented in SVMKit are only Linear / Kernel SVC,
-Logistic Regression, Factorization Machine, K-nearest neighbor method, and cross-validation.
+SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+SVMKit currently supports Linear / Kernel Support Vector Machine,
+Logistic Regression, Factorization Machine, Naive Bayes,
+K-nearest neighbor classifier, and cross-validation.
 MSG
   spec.homepage      = 'https://github.com/yoshoku/svmkit'
   spec.license       = 'BSD-2-Clause'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: svmkit
 version: !ruby/object:Gem::Version
-  version: 0.2.4
+  version: 0.2.5
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-02-04 00:00:00.000000000 Z
+date: 2018-02-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -82,10 +82,10 @@ dependencies:
         version: '0.15'
 description: |
   SVMKit is a machine learninig library in Ruby.
-  SVMKit implements machine learning algorithms with interfaces similar to Scikit-Learn in Python.
-  Since the development of SVMKit has just getting started,
-  the methods implemented in SVMKit are only Linear / Kernel SVC,
-  Logistic Regression, Factorization Machine, K-nearest neighbor method, and cross-validation.
+  SVMKit provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
+  SVMKit currently supports Linear / Kernel Support Vector Machine,
+  Logistic Regression, Factorization Machine, Naive Bayes,
+  K-nearest neighbor classifier, and cross-validation.
 email:
 - yoshoku@outlook.com
 executables: []
@@ -95,6 +95,7 @@ files:
 - ".gitignore"
 - ".rspec"
 - ".rubocop.yml"
+- ".rubocop_todo.yml"
 - ".travis.yml"
 - CODE_OF_CONDUCT.md
 - Gemfile
@@ -124,6 +125,7 @@ files:
 - lib/svmkit/model_selection/k_fold.rb
 - lib/svmkit/model_selection/stratified_k_fold.rb
 - lib/svmkit/multiclass/one_vs_rest_classifier.rb
+- lib/svmkit/naive_bayes/naive_bayes.rb
 - lib/svmkit/nearest_neighbors/k_neighbors_classifier.rb
 - lib/svmkit/pairwise_metric.rb
 - lib/svmkit/polynomial_model/factorization_machine_classifier.rb
@@ -161,6 +163,6 @@ rubyforge_project:
 rubygems_version: 2.4.5.4
 signing_key: 
 specification_version: 4
-summary: SVMKit is a machine learninig library in Ruby. SVMKit implements machine
-  learning algorithms with interfaces similar to Scikit-Learn in Python.
+summary: SVMKit is a machine learninig library in Ruby. SVMKit provides machine learning
+  algorithms with interfaces similar to Scikit-Learn in Python.
 test_files: []