svmkit 0.2.0 → 0.2.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 4a53bee5e11b90721544b873d144b149b38aafe1
-  data.tar.gz: f1ded6552e6cbdd8af3c29c4d8d403d3c8a62128
+  metadata.gz: b3cb57cc46849d792fff7b6c6500b9498d56fc71
+  data.tar.gz: 65c909ee0efaafc42df12dd24aa6c62d5b816d6a
 SHA512:
-  metadata.gz: c3e3073f1afd4470cc21e1241d1f3666bbfefcd871700f711cfe377bb04c490f2f3ff10bc4d8ef764e05e0015faf09aef114e45ad0affde35a18641b064ed389
-  data.tar.gz: 90144eea5e5f848dffb1325cd4576f27dbf61e5032917493e4957f5acba96489cc2b556f88a2078f5f2d9b5d2842c32454e6e56c003bfd2e36f6d5263cefc4c6
+  metadata.gz: 25b52e63512393706f3f53ddf415a2e4ac07923f3d1bd909cca0ade9de66d5bbb63d32a932bce32f2fa2b6c4430bab73f483d94d620eb355540a91905320644a
+  data.tar.gz: a3b983cf6d75168cb6eda70ec5da113feb2bc52c7fc501af3a9328f569c6d793c19e4744a4a80f0c3c60b0ea4e5387db21451f2a004f8d4699605b8348c81bab

data/.rubocop.yml

@@ -4,6 +4,9 @@
 Documentation:
   Enabled: false
 
+Metrics/AbcSize:
+  Max: 30
+
 Metrics/LineLength:
   Max: 120
 
@@ -13,5 +16,15 @@ Metrics/ModuleLength:
 Metrics/ClassLength:
   Max: 200
 
+Metrics/MethodLength:
+  Max: 40
+
+Metrics/BlockLength:
+  Exclude:
+    - 'spec/**/*'
+
+ParameterLists:
+  Max: 10
+
 Security/MarshalLoad:
   Enabled: false

data/HISTORY.md

@@ -1,3 +1,6 @@
+# 0.2.1
+- Added class for K-nearest neighbors classifier.
+
 # 0.2.0
 - Migrated the linear algebra library to Numo::NArray.
 - Added module for loading and saving libsvm format file.

data/lib/svmkit.rb

@@ -12,6 +12,7 @@ require 'svmkit/linear_model/svc'
 require 'svmkit/linear_model/logistic_regression'
 require 'svmkit/kernel_machine/kernel_svc'
 require 'svmkit/multiclass/one_vs_rest_classifier'
+require 'svmkit/nearest_neighbors/k_neighbors_classifier'
 require 'svmkit/preprocessing/l2_normalizer'
 require 'svmkit/preprocessing/min_max_scaler'
 require 'svmkit/preprocessing/standard_scaler'

data/lib/svmkit/kernel_approximation/rbf.rb

@@ -35,12 +35,12 @@ module SVMKit
       # @param n_components [Integer] The number of dimensions of the RBF kernel feature space.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(gamma: 1.0, n_components: 128, random_seed: nil)
-        self.params = {}
-        self.params[:gamma] = gamma
-        self.params[:n_components] = n_components
-        self.params[:random_seed] = random_seed
-        self.params[:random_seed] ||= srand
-        @rng = Random.new(self.params[:random_seed])
+        @params = {}
+        @params[:gamma] = gamma
+        @params[:n_components] = n_components
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
+        @rng = Random.new(@params[:random_seed])
         @random_mat = nil
         @random_vec = nil
       end
@@ -54,10 +54,10 @@ module SVMKit
       # @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
-        @random_mat = rand_normal([n_features, params[:n_components]]) * (2.0 * params[:gamma])**0.5
-        n_half_components = params[:n_components] / 2
-        @random_vec = Numo::DFloat.zeros(params[:n_components] - n_half_components).concatenate(
+        @params[:n_components] = 2 * n_features if @params[:n_components] <= 0
+        @random_mat = rand_normal([n_features, @params[:n_components]]) * (2.0 * @params[:gamma])**0.5
+        n_half_components = @params[:n_components] / 2
+        @random_vec = Numo::DFloat.zeros(@params[:n_components] - n_half_components).concatenate(
           Numo::DFloat.ones(n_half_components) * (0.5 * Math::PI)
         )
         self
@@ -82,13 +82,13 @@ module SVMKit
       def transform(x)
         n_samples, = x.shape
         projection = x.dot(@random_mat) + @random_vec.tile(n_samples, 1)
-        Numo::NMath.sin(projection) * ((2.0 / params[:n_components])**0.5)
+        Numo::NMath.sin(projection) * ((2.0 / @params[:n_components])**0.5)
       end
 
       # Dump marshal data.
       # @return [Hash] The marshal data about RBF.
       def marshal_dump
-        { params: params,
+        { params: @params,
           random_mat: @random_mat,
           random_vec: @random_vec,
           rng: @rng }
@@ -97,7 +97,7 @@ module SVMKit
       # Load marshal data.
       # @return [nil]
       def marshal_load(obj)
-        self.params = obj[:params]
+        @params = obj[:params]
         @random_mat = obj[:random_mat]
         @random_vec = obj[:random_vec]
         @rng = obj[:rng]

data/lib/svmkit/kernel_machine/kernel_svc.rb

@@ -34,13 +34,13 @@ module SVMKit
       # @param max_iter [Integer] The maximum number of iterations.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
       def initialize(reg_param: 1.0, max_iter: 1000, random_seed: nil)
-        self.params = {}
-        self.params[:reg_param] = reg_param
-        self.params[:max_iter] = max_iter
-        self.params[:random_seed] = random_seed
-        self.params[:random_seed] ||= srand
+        @params = {}
+        @params[:reg_param] = reg_param
+        @params[:max_iter] = max_iter
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
         @weight_vec = nil
-        @rng = Random.new(self.params[:random_seed])
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -58,13 +58,13 @@ module SVMKit
         rand_ids = []
         weight_vec = Numo::DFloat.zeros(n_training_samples)
         # Start optimization.
-        params[:max_iter].times do |t|
+        @params[:max_iter].times do |t|
           # random sampling
           rand_ids = [*0...n_training_samples].shuffle(random: @rng) if rand_ids.empty?
           target_id = rand_ids.shift
           # update the weight vector
           func = (weight_vec * bin_y[target_id]).dot(x[target_id, true].transpose).to_f
-          func *= bin_y[target_id] / (params[:reg_param] * (t + 1))
+          func *= bin_y[target_id] / (@params[:reg_param] * (t + 1))
           weight_vec[target_id] += 1.0 if func < 1.0
         end
         # Store the learned model.
@@ -105,13 +105,13 @@ module SVMKit
       # Dump marshal data.
       # @return [Hash] The marshal data about KernelSVC.
       def marshal_dump
-        { params: params, weight_vec: @weight_vec, rng: @rng }
+        { params: @params, weight_vec: @weight_vec, rng: @rng }
       end
 
       # Load marshal data.
       # @return [nil]
       def marshal_load(obj)
-        self.params = obj[:params]
+        @params = obj[:params]
         @weight_vec = obj[:weight_vec]
         @rng = obj[:rng]
         nil

data/lib/svmkit/linear_model/logistic_regression.rb

@@ -20,16 +20,6 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Classifier
 
-      # @!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
-
       # Return the weight vector for Logistic Regression.
       # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :weight_vec
@@ -52,17 +42,17 @@ module SVMKit
       # @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(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, max_iter: 100, batch_size: 50, random_seed: nil)
-        self.params = {}
-        self.params[:reg_param] = reg_param
-        self.params[:fit_bias] = fit_bias
-        self.params[:bias_scale] = bias_scale
-        self.params[:max_iter] = max_iter
-        self.params[:batch_size] = batch_size
-        self.params[:random_seed] = random_seed
-        self.params[:random_seed] ||= srand
+        @params = {}
+        @params[:reg_param] = reg_param
+        @params[:fit_bias] = fit_bias
+        @params[:bias_scale] = bias_scale
+        @params[:max_iter] = max_iter
+        @params[:batch_size] = batch_size
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
         @weight_vec = nil
         @bias_term = 0.0
-        @rng = Random.new(self.params[:random_seed])
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -77,9 +67,9 @@ module SVMKit
         bin_y = y.to_a.map { |l| l != negative_label ? 1 : 0 }
         # Expand feature vectors for bias term.
         samples = x
-        if params[:fit_bias]
+        if @params[:fit_bias]
           samples = Numo::NArray.hstack(
-            [samples, Numo::DFloat.ones([x.shape[0], 1]) * params[:bias_scale]]
+            [samples, Numo::DFloat.ones([x.shape[0], 1]) * @params[:bias_scale]]
           )
         end
         # Initialize some variables.
@@ -87,27 +77,27 @@ module SVMKit
         rand_ids = [*0..n_samples - 1].shuffle(random: @rng)
         weight_vec = Numo::DFloat.zeros(n_features)
         # Start optimization.
-        params[:max_iter].times do |t|
+        @params[:max_iter].times do |t|
           # random sampling
-          subset_ids = rand_ids.shift(params[:batch_size])
+          subset_ids = rand_ids.shift(@params[:batch_size])
           rand_ids.concat(subset_ids)
           # update the weight vector.
-          eta = 1.0 / (params[:reg_param] * (t + 1))
+          eta = 1.0 / (@params[:reg_param] * (t + 1))
           mean_vec = Numo::DFloat.zeros(n_features)
           subset_ids.each do |n|
             z = weight_vec.dot(samples[n, true])
             coef = bin_y[n] / (1.0 + Math.exp(bin_y[n] * z))
             mean_vec += samples[n, true] * coef
           end
-          mean_vec *= eta / params[:batch_size]
-          weight_vec = weight_vec * (1.0 - eta * params[:reg_param]) + mean_vec
+          mean_vec *= eta / @params[:batch_size]
+          weight_vec = weight_vec * (1.0 - eta * @params[:reg_param]) + mean_vec
           # scale the weight vector.
           norm = Math.sqrt(weight_vec.dot(weight_vec))
-          scaler = (1.0 / params[:reg_param]**0.5) / (norm + 1.0e-12)
+          scaler = (1.0 / @params[:reg_param]**0.5) / (norm + 1.0e-12)
           weight_vec *= [1.0, scaler].min
         end
         # Store the learned model.
-        if params[:fit_bias]
+        if @params[:fit_bias]
           @weight_vec = weight_vec[0...n_features - 1]
           @bias_term = weight_vec[n_features - 1]
         else
@@ -156,13 +146,13 @@ module SVMKit
       # Dump marshal data.
       # @return [Hash] The marshal data about LogisticRegression.
       def marshal_dump
-        { params: params, weight_vec: @weight_vec, bias_term: @bias_term, rng: @rng }
+        { params: @params, weight_vec: @weight_vec, bias_term: @bias_term, rng: @rng }
       end
 
       # Load marshal data.
       # @return [nil]
       def marshal_load(obj)
-        self.params = obj[:params]
+        @params = obj[:params]
         @weight_vec = obj[:weight_vec]
         @bias_term = obj[:bias_term]
         @rng = obj[:rng]

data/lib/svmkit/linear_model/svc.rb

@@ -18,16 +18,6 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Classifier
 
-      # @!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
-
       # Return the weight vector for SVC.
       # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :weight_vec
@@ -49,17 +39,17 @@ module SVMKit
       # @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(reg_param: 1.0, fit_bias: false, bias_scale: 1.0, max_iter: 100, batch_size: 50, random_seed: nil)
-        self.params = {}
-        self.params[:reg_param] = reg_param
-        self.params[:fit_bias] = fit_bias
-        self.params[:bias_scale] = bias_scale
-        self.params[:max_iter] = max_iter
-        self.params[:batch_size] = batch_size
-        self.params[:random_seed] = random_seed
-        self.params[:random_seed] ||= srand
+        @params = {}
+        @params[:reg_param] = reg_param
+        @params[:fit_bias] = fit_bias
+        @params[:bias_scale] = bias_scale
+        @params[:max_iter] = max_iter
+        @params[:batch_size] = batch_size
+        @params[:random_seed] = random_seed
+        @params[:random_seed] ||= srand
         @weight_vec = nil
         @bias_term = 0.0
-        @rng = Random.new(self.params[:random_seed])
+        @rng = Random.new(@params[:random_seed])
       end
 
       # Fit the model with given training data.
@@ -73,9 +63,9 @@ module SVMKit
         bin_y = y.to_a.map { |l| l != negative_label ? 1 : -1 }
         # Expand feature vectors for bias term.
         samples = x
-        if params[:fit_bias]
+        if @params[:fit_bias]
           samples = Numo::NArray.hstack(
-            [samples, Numo::DFloat.ones([x.shape[0], 1]) * params[:bias_scale]]
+            [samples, Numo::DFloat.ones([x.shape[0], 1]) * @params[:bias_scale]]
           )
         end
         # Initialize some variables.
@@ -83,26 +73,26 @@ module SVMKit
         rand_ids = [*0..n_samples - 1].shuffle(random: @rng)
         weight_vec = Numo::DFloat.zeros(n_features)
         # Start optimization.
-        params[:max_iter].times do |t|
+        @params[:max_iter].times do |t|
           # random sampling
-          subset_ids = rand_ids.shift(params[:batch_size])
+          subset_ids = rand_ids.shift(@params[:batch_size])
           rand_ids.concat(subset_ids)
           target_ids = subset_ids.map { |n| n if weight_vec.dot(samples[n, true]) * bin_y[n] < 1 }.compact
           n_subsamples = target_ids.size
           next if n_subsamples.zero?
           # update the weight vector.
-          eta = 1.0 / (params[:reg_param] * (t + 1))
+          eta = 1.0 / (@params[:reg_param] * (t + 1))
           mean_vec = Numo::DFloat.zeros(n_features)
           target_ids.each { |n| mean_vec += samples[n, true] * 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.
           norm = Math.sqrt(weight_vec.dot(weight_vec))
-          scaler = (1.0 / params[:reg_param]**0.5) / (norm + 1.0e-12)
+          scaler = (1.0 / @params[:reg_param]**0.5) / (norm + 1.0e-12)
           weight_vec *= [1.0, scaler].min
         end
         # Store the learned model.
-        if params[:fit_bias]
+        if @params[:fit_bias]
           @weight_vec = weight_vec[0...n_features - 1]
           @bias_term = weight_vec[n_features - 1]
         else
@@ -142,13 +132,13 @@ module SVMKit
       # Dump marshal data.
       # @return [Hash] The marshal data about SVC.
       def marshal_dump
-        { params: params, weight_vec: @weight_vec, bias_term: @bias_term, rng: @rng }
+        { params: @params, weight_vec: @weight_vec, bias_term: @bias_term, rng: @rng }
       end
 
       # Load marshal data.
       # @return [nil]
       def marshal_load(obj)
-        self.params = obj[:params]
+        @params = obj[:params]
         @weight_vec = obj[:weight_vec]
         @bias_term = obj[:bias_term]
         @rng = obj[:rng]

data/lib/svmkit/multiclass/one_vs_rest_classifier.rb

@@ -28,8 +28,8 @@ module SVMKit
       #
       # @param estimator [Classifier] The (binary) classifier for construction a multi-label classifier.
       def initialize(estimator: nil)
-        self.params = {}
-        self.params[:estimator] = estimator
+        @params = {}
+        @params[:estimator] = estimator
         @estimators = nil
         @classes = nil
       end
@@ -44,7 +44,7 @@ module SVMKit
         @classes = Numo::Int32.asarray(y_arr.uniq.sort)
         @estimators = @classes.to_a.map do |label|
           bin_y = Numo::Int32.asarray(y_arr.map { |l| l == label ? 1 : -1 })
-          params[:estimator].dup.fit(x, bin_y)
+          @params[:estimator].dup.fit(x, bin_y)
         end
         self
       end
@@ -82,7 +82,7 @@ module SVMKit
       # Dump marshal data.
       # @return [Hash] The marshal data about OneVsRestClassifier.
       def marshal_dump
-        { params: params,
+        { params: @params,
           classes: @classes,
           estimators: @estimators.map { |e| Marshal.dump(e) } }
       end
@@ -90,7 +90,7 @@ module SVMKit
       # Load marshal data.
       # @return [nil]
       def marshal_load(obj)
-        self.params = obj[:params]
+        @params = obj[:params]
         @classes = obj[:classes]
         @estimators = obj[:estimators].map { |e| Marshal.load(e) }
         nil

data/lib/svmkit/nearest_neighbors/k_neighbors_classifier.rb

@@ -0,0 +1,113 @@
+require 'svmkit/base/base_estimator'
+require 'svmkit/base/classifier'
+
+module SVMKit
+  # This module consists of the classes that implement estimators based on nearest neighbors rule.
+  module NearestNeighbors
+    # KNeighborsClassifier is a class that implements the classifier with the k-nearest neighbors rule.
+    # The current implementation uses the Euclidean distance for finding the neighbors.
+    #
+    # @example
+    #   estimator =
+    #     SVMKit::NearestNeighbor::KNeighborsClassifier.new(n_neighbors = 5)
+    #   estimator.fit(training_samples, traininig_labels)
+    #   results = estimator.predict(testing_samples)
+    #
+    class KNeighborsClassifier
+      include Base::BaseEstimator
+      include Base::Classifier
+
+      # Return the prototypes for the nearest neighbor classifier.
+      # @return [Numo::DFloat] (shape: [n_samples, n_features])
+      attr_reader :prototypes
+
+      # Return the labels of the prototypes
+      # @return [Numo::Int32] (size: n_samples)
+      attr_reader :labels
+
+      # Return the class labels.
+      # @return [Numo::Int32] (size: n_classes)
+      attr_reader :classes
+
+      # Create a new classifier with the nearest neighbor rule.
+      #
+      # @param n_neighbors [Integer] The number of neighbors.
+      def initialize(n_neighbors: 5)
+        @params = {}
+        @params[:n_neighbors] = n_neighbors
+        @prototypes = nil
+        @labels = nil
+        @classes = nil
+      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 labels to be used for fitting the model.
+      # @return [KNeighborsClassifier] The learned classifier itself.
+      def fit(x, y)
+        @prototypes = Numo::DFloat.asarray(x.to_a)
+        @labels = Numo::Int32.asarray(y.to_a)
+        @classes = Numo::Int32.asarray(y.to_a.uniq.sort)
+        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)
+        distance_matrix = PairwiseMetric.euclidean_distance(x, @prototypes)
+        n_samples, n_prototypes = distance_matrix.shape
+        n_classes = @classes.size
+        n_neighbors = [@params[:n_neighbors], n_prototypes].min
+        scores = Numo::DFloat.zeros(n_samples, n_classes)
+        n_samples.times do |m|
+          neighbor_ids = distance_matrix[m, true].to_a.each_with_index.sort.map(&:last)[0...n_neighbors]
+          neighbor_ids.each { |n| scores[m, @classes.to_a.index(@labels[n])] += 1.0 }
+        end
+        scores
+      end
+
+      # 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
+
+      # 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)
+        p = predict(x)
+        n_hits = (y.to_a.map.with_index { |l, n| l == p[n] ? 1 : 0 }).inject(:+)
+        n_hits / y.size.to_f
+      end
+
+      # Dump marshal data.
+      # @return [Hash] The marshal data about KNeighborsClassifier.
+      def marshal_dump
+        { params: params,
+          prototypes: @prototypes,
+          labels: @labels,
+          classes: @classes }
+      end
+
+      # Load marshal data.
+      # @return [nil]
+      def marshal_load(obj)
+        @params = obj[:params]
+        @prototypes = obj[:prototypes]
+        @labels = obj[:labels]
+        @classes = obj[:classes]
+        nil
+      end
+    end
+  end
+end

data/lib/svmkit/preprocessing/l2_normalizer.rb

@@ -18,8 +18,8 @@ module SVMKit
       attr_reader :norm_vec # :nodoc:
 
       # Create a new normalizer for normaliing to unit L2-norm.
-      def initialize()
-        self.params = {}
+      def initialize
+        @params = {}
         @norm_vec = nil
       end
 

data/lib/svmkit/preprocessing/min_max_scaler.rb

@@ -26,8 +26,8 @@ module SVMKit
       #
       # @param feature_range [Array<Float>] The desired range of samples.
       def initialize(feature_range: [0.0, 1.0])
-        self.params = {}
-        self.params[:feature_range] = feature_range
+        @params = {}
+        @params[:feature_range] = feature_range
         @min_vec = nil
         @max_vec = nil
       end

data/lib/svmkit/preprocessing/standard_scaler.rb

@@ -23,8 +23,8 @@ module SVMKit
       attr_reader :std_vec
 
       # Create a new normalizer for centering and scaling to unit variance.
-      def initialize()
-        self.params = {}
+      def initialize
+        @params = {}
         @mean_vec = nil
         @std_vec = nil
       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.0'.freeze
+  VERSION = '0.2.1'.freeze
 end

data/svmkit.gemspec

@@ -29,21 +29,20 @@ Gem::Specification.new do |spec|
 
   spec.required_ruby_version = '>= 2.1'
 
-  spec.add_runtime_dependency 'numo-narray', '>= 0.9.0.5'
+  spec.add_runtime_dependency 'numo-narray', '~> 0.9.0.5'
 
   spec.add_development_dependency 'bundler', '~> 1.15'
   spec.add_development_dependency 'rake', '~> 10.0'
   spec.add_development_dependency 'rspec', '~> 3.0'
   spec.add_development_dependency 'simplecov', '~> 0.15.1'
-  spec.add_development_dependency 'numo-narray', '~> 0.9.0.9'
 
-  spec.post_install_message = <<-EOF
+  spec.post_install_message = <<MSG
 *************************************************************************
 Thank you for installing SVMKit!!
 
 Note that the SVMKit has been changed to use Numo::NArray for
 linear algebra library from version 0.2.0.
 *************************************************************************
-EOF
+MSG
 
 end

metadata

@@ -1,27 +1,27 @@
 --- !ruby/object:Gem::Specification
 name: svmkit
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.2.1
 platform: ruby
 authors:
 - yoshoku
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2017-11-05 00:00:00.000000000 Z
+date: 2017-12-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
   requirement: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0.5
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
-    - - ">="
+    - - "~>"
       - !ruby/object:Gem::Version
         version: 0.9.0.5
 - !ruby/object:Gem::Dependency
@@ -80,20 +80,6 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: 0.15.1
-- !ruby/object:Gem::Dependency
-  name: numo-narray
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.0.9
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 0.9.0.9
 description: |
   SVMKit is a library for machine learninig in Ruby.
   SVMKit implements machine learning algorithms with an interface similar to Scikit-Learn in Python.
@@ -126,6 +112,7 @@ files:
 - lib/svmkit/linear_model/logistic_regression.rb
 - lib/svmkit/linear_model/svc.rb
 - lib/svmkit/multiclass/one_vs_rest_classifier.rb
+- lib/svmkit/nearest_neighbors/k_neighbors_classifier.rb
 - lib/svmkit/pairwise_metric.rb
 - lib/svmkit/preprocessing/l2_normalizer.rb
 - lib/svmkit/preprocessing/min_max_scaler.rb
@@ -158,7 +145,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.6.13
+rubygems_version: 2.2.5
 signing_key: 
 specification_version: 4
 summary: SVMKit is an experimental library of machine learning in Ruby.