svmkit 0.1.3 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6a6941fcd2f0f465de1d6a3b6f658e7ee0fdc8fb
-  data.tar.gz: b9dc50c6fa8e3d7470adf89ffc950b2ae63db4e1
+  metadata.gz: 4a53bee5e11b90721544b873d144b149b38aafe1
+  data.tar.gz: f1ded6552e6cbdd8af3c29c4d8d403d3c8a62128
 SHA512:
-  metadata.gz: 4795995b936f2902dc50e19dc30c46fdb2a1b6a732869a311efa791da8ec09305f6ea6dbfd9aab7da8c934465c8eebe9c45dcaab57090b09f0cc20c1ccacff77
-  data.tar.gz: b8afdc306dba4a10922e63756bb6d18731e54a4a5f04293a478b7c897b6a58622c9f88eb6bdb47837fa7114ab80d879e6e1ea3e993a5937f291d69e5d72f1699
+  metadata.gz: c3e3073f1afd4470cc21e1241d1f3666bbfefcd871700f711cfe377bb04c490f2f3ff10bc4d8ef764e05e0015faf09aef114e45ad0affde35a18641b064ed389
+  data.tar.gz: 90144eea5e5f848dffb1325cd4576f27dbf61e5032917493e4957f5acba96489cc2b556f88a2078f5f2d9b5d2842c32454e6e56c003bfd2e36f6d5263cefc4c6

data/HISTORY.md

@@ -1,3 +1,7 @@
+# 0.2.0
+- Migrated the linear algebra library to Numo::NArray.
+- Added module for loading and saving libsvm format file.
+
 # 0.1.3
 - Added class for Kernel Support Vector Machine with Pegasos algorithm.
 - Added module for calculating pairwise kernel fuctions and euclidean distances.

data/README.md

@@ -30,9 +30,8 @@ Training phase:
 
 ```ruby
 require 'svmkit'
-require 'libsvmloader'
 
-samples, labels = LibSVMLoader.load_libsvm_file('pendigits', stype: :dense)
+samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits')
 
 normalizer = SVMKit::Preprocessing::MinMaxScaler.new
 normalized = normalizer.fit_transform(samples)
@@ -41,7 +40,7 @@ transformer = SVMKit::KernelApproximation::RBF.new(gamma: 2.0, n_components: 102
 transformed = transformer.fit_transform(normalized)
 
 base_classifier =
-  SVMKit::LinearModel::PegasosSVC.new(reg_param: 1.0, max_iter: 50, batch_size: 20, random_seed: 1)
+  SVMKit::LinearModel::SVC.new(reg_param: 1.0, max_iter: 1000, batch_size: 20, random_seed: 1)
 classifier = SVMKit::Multiclass::OneVsRestClassifier.new(estimator: base_classifier)
 classifier.fit(transformed, labels)
 
@@ -54,9 +53,8 @@ Testing phase:
 
 ```ruby
 require 'svmkit'
-require 'libsvmloader'
 
-samples, labels = LibSVMLoader.load_libsvm_file('pendigits.t', stype: :dense)
+samples, labels = SVMKit::Dataset.load_libsvm_file('pendigits.t')
 
 normalizer = Marshal.load(File.binread('trained_normalizer.dat'))
 transformer = Marshal.load(File.binread('trained_transformer.dat'))

data/lib/svmkit.rb

@@ -1,16 +1,14 @@
-begin
-  require 'nmatrix/nmatrix'
-rescue LoadError
-end
+
+require 'numo/narray'
 
 require 'svmkit/version'
-require 'svmkit/utils'
 require 'svmkit/pairwise_metric'
+require 'svmkit/dataset'
 require 'svmkit/base/base_estimator'
 require 'svmkit/base/classifier'
 require 'svmkit/base/transformer'
 require 'svmkit/kernel_approximation/rbf'
-require 'svmkit/linear_model/pegasos_svc'
+require 'svmkit/linear_model/svc'
 require 'svmkit/linear_model/logistic_regression'
 require 'svmkit/kernel_machine/kernel_svc'
 require 'svmkit/multiclass/one_vs_rest_classifier'

data/lib/svmkit/dataset.rb

@@ -0,0 +1,90 @@
+module SVMKit
+  # Module for loading and saving a dataset file.
+  module Dataset
+    class << self
+      # Load a dataset with the libsvm file format into Numo::NArray.
+      #
+      # @param filename [String] A path to a dataset file.
+      # @param zero_based [Boolean] Whether the column index starts from 0 (true) or 1 (false).
+      #
+      # @return [Array<Numo::NArray>]
+      #   Returns array containing the (n_samples x n_features) matrix for feature vectors
+      #   and (n_samples) vector for labels or target values.
+      def load_libsvm_file(filename, zero_based: false)
+        ftvecs = []
+        labels = []
+        n_features = 0
+        File.read(filename).split("\n").each do |line|
+          label, ftvec, max_idx = parse_libsvm_line(line, zero_based)
+          labels.push(label)
+          ftvecs.push(ftvec)
+          n_features = [n_features, max_idx].max
+        end
+        [convert_to_matrix(ftvecs, n_features), Numo::NArray.asarray(labels)]
+      end
+
+      # Dump the dataset with the libsvm file format.
+      #
+      # @param data [Numo::NArray] (shape: [n_samples, n_features]) matrix consisting of feature vectors.
+      # @param labels [Numo::NArray] (shape: [n_samples]) matrix consisting of labels or target values.
+      # @param filename [String] A path to the output libsvm file.
+      # @param zero_based [Boolean] Whether the column index starts from 0 (true) or 1 (false).
+      def dump_libsvm_file(data, labels, filename, zero_based: false)
+        n_samples = [data.shape[0], labels.shape[0]].min
+        label_type = detect_dtype(labels)
+        value_type = detect_dtype(data)
+        File.open(filename, 'w') do |file|
+          n_samples.times do |n|
+            file.puts(dump_libsvm_line(labels[n], data[n, true],
+                                       label_type, value_type, zero_based))
+          end
+        end
+      end
+
+      private
+
+      def parse_libsvm_line(line, zero_based)
+        tokens = line.split
+        label = tokens.shift
+        label = label.to_i.to_s == label ? label.to_i : label.to_f
+        ftvec = tokens.map do |el|
+          idx, val = el.split(':')
+          idx = idx.to_i - (zero_based == false ? 1 : 0)
+          val = val.to_i.to_s == val ? val.to_i : val.to_f
+          [idx, val]
+        end
+        max_idx = ftvec.map { |el| el[0] }.max
+        max_idx ||= 0
+        [label, ftvec, max_idx]
+      end
+
+      def convert_to_matrix(data, n_features)
+        mat = []
+        data.each do |ft|
+          vec = Array.new(n_features) { 0 }
+          ft.each { |el| vec[el[0]] = el[1] }
+          mat.push(vec)
+        end
+        Numo::NArray.asarray(mat)
+      end
+
+      def detect_dtype(data)
+        arr_type_str = Numo::NArray.array_type(data).to_s
+        type = '%s'
+        type = '%d' if ['Numo::Int8', 'Numo::Int16', 'Numo::Int32', 'Numo::Int64'].include?(arr_type_str)
+        type = '%d' if ['Numo::UInt8', 'Numo::UInt16', 'Numo::UInt32', 'Numo::UInt64'].include?(arr_type_str)
+        type = '%.10g' if ['Numo::SFloat', 'Numo::DFloat'].include?(arr_type_str)
+        type
+      end
+
+      def dump_libsvm_line(label, ftvec, label_type, value_type, zero_based)
+        line = format(label_type.to_s, label)
+        ftvec.to_a.each_with_index do |val, n|
+          idx = n + (zero_based == false ? 1 : 0)
+          line += format(" %d:#{value_type}", idx, val) if val != 0.0
+        end
+        line
+      end
+    end
+  end
+end

data/lib/svmkit/kernel_approximation/rbf.rb

@@ -17,19 +17,12 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Transformer
 
-      # @!visibility private
-      DEFAULT_PARAMS = {
-        gamma: 1.0,
-        n_components: 128,
-        random_seed: nil
-      }.freeze
-
       # Return the random matrix for transformation.
-      # @return [NMatrix] (shape: [n_features, n_components])
+      # @return [Numo::DFloat] (shape: [n_features, n_components])
       attr_reader :random_mat
 
       # Return the random vector for transformation.
-      # @return [NMatrix] (shape: [1, n_components])
+      # @return [Numo::DFloat] (shape: [n_components])
       attr_reader :random_vec
 
       # Return the random generator for transformation.
@@ -38,14 +31,14 @@ module SVMKit
 
       # Create a new transformer for mapping to RBF kernel feature space.
       #
-      # @overload new(gamma: 1.0, n_components: 128, random_seed: 1) -> RBF
-      #
-      # @param params [Hash] The parameters for RBF kernel approximation.
-      # @option params [Float]   :gamma (1.0) The parameter of RBF kernel: exp(-gamma * x^2).
-      # @option params [Integer] :n_components (128) The number of dimensions of the RBF kernel feature space.
-      # @option params [Integer] :random_seed (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] }])
+      # @param gamma [Float] The parameter of RBF kernel: exp(-gamma * x^2).
+      # @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])
         @random_mat = nil
@@ -56,7 +49,7 @@ module SVMKit
       #
       # @overload fit(x) -> RBF
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @param x [Numo::NArray] (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)
@@ -64,40 +57,40 @@ module SVMKit
         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 = NMatrix.zeros([1, params[:n_components] - n_half_components]).hconcat(
-          NMatrix.ones([1, n_half_components]) * (0.5 * Math::PI)
+        @random_vec = Numo::DFloat.zeros(params[:n_components] - n_half_components).concatenate(
+          Numo::DFloat.ones(n_half_components) * (0.5 * Math::PI)
         )
         self
       end
 
       # Fit the model with training data, and then transform them with the learned model.
       #
-      # @overload fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> Numo::DFloat
       #
-      # @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
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The training data to be used for fitting the model.
+      # @return [Numo::DFloat] (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.
       #
-      # @overload transform(x) -> NMatrix
+      # @overload transform(x) -> Numo::DFloat
       #
-      # @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.
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The data to be transformed with the learned model.
+      # @return [Numo::DFloat] (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)
+        projection = x.dot(@random_mat) + @random_vec.tile(n_samples, 1)
+        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,
-          random_mat: Utils.dump_nmatrix(@random_mat),
-          random_vec: Utils.dump_nmatrix(@random_vec),
+          random_mat: @random_mat,
+          random_vec: @random_vec,
           rng: @rng }
       end
 
@@ -105,8 +98,8 @@ module SVMKit
       # @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])
+        @random_mat = obj[:random_mat]
+        @random_vec = obj[:random_vec]
         @rng = obj[:rng]
         nil
       end
@@ -115,15 +108,15 @@ module SVMKit
 
       # Generate the uniform random matrix with the given shape.
       def rand_uniform(shape)
-        rnd_vals = Array.new(NMatrix.size(shape)) { @rng.rand }
-        NMatrix.new(shape, rnd_vals, dtype: :float64, stype: :dense)
+        rnd_vals = Array.new(shape.inject(:*)) { @rng.rand }
+        Numo::DFloat.asarray(rnd_vals).reshape(shape[0], shape[1])
       end
 
       # Generate the normal random matrix with the given shape, mean, and standard deviation.
       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
+        (Numo::NMath.sqrt(Numo::NMath.log(a) * -2.0) * Numo::NMath.sin(b * 2.0 * Math::PI)) * sigma + mu
       end
     end
   end

data/lib/svmkit/kernel_machine/kernel_svc.rb

@@ -2,7 +2,7 @@ require 'svmkit/base/base_estimator'
 require 'svmkit/base/classifier'
 
 module SVMKit
-  # This module consists of the classes that implement generalized linear models.
+  # This module consists of the classes that implement kernel method-based estimator.
   module KernelMachine
     # KernelSVC is a class that implements (Nonlinear) Kernel Support Vector Classifier with the Pegasos algorithm.
     #
@@ -20,15 +20,8 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Classifier
 
-      # @!visibility private
-      DEFAULT_PARAMS = {
-        reg_param: 1.0,
-        max_iter: 1000,
-        random_seed: nil
-      }.freeze
-
       # Return the weight vector for Kernel SVC.
-      # @return [NMatrix] (shape: [1, n_trainig_sample])
+      # @return [Numo::DFloat] (shape: [n_trainig_sample])
       attr_reader :weight_vec
 
       # Return the random generator for performing random sampling in the Pegasos algorithm.
@@ -37,14 +30,14 @@ module SVMKit
 
       # Create a new classifier with Kernel Support Vector Machine by the Pegasos algorithm.
       #
-      # @overload new(reg_param: 1.0, max_iter: 1000, random_seed: 1) -> KernelSVC
-      #
-      # @param params [Hash] The parameters for Kernel SVC.
-      # @option params [Float]   :reg_param (1.0) The regularization parameter.
-      # @option params [Integer] :max_iter (1000) The maximum number of iterations.
-      # @option params [Integer] :random_seed (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] }])
+      # @param reg_param [Float] The regularization parameter.
+      # @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
         @weight_vec = nil
         @rng = Random.new(self.params[:random_seed])
@@ -52,74 +45,74 @@ module SVMKit
 
       # Fit the model with given training data.
       #
-      # @param x [NMatrix] (shape: [n_training_samples, n_training_samples])
+      # @param x [Numo::DFloat] (shape: [n_training_samples, n_training_samples])
       #   The kernel matrix of the training data to be used for fitting the model.
-      # @param y [NMatrix] (shape: [1, n_training_samples]) The labels to be used for fitting the model.
+      # @param y [Numo::Int32] (shape: [n_training_samples]) The labels to be used for fitting the model.
       # @return [KernelSVC] 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 }
+        negative_label = y.to_a.uniq.sort.shift
+        bin_y = y.to_a.map { |l| l != negative_label ? 1 : -1 }
         # Initialize some variables.
         n_training_samples = x.shape[0]
         rand_ids = []
-        weight_vec = NMatrix.zeros([1, n_training_samples])
+        weight_vec = Numo::DFloat.zeros(n_training_samples)
         # Start optimization.
         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.row(target_id).transpose).to_f
+          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))
           weight_vec[target_id] += 1.0 if func < 1.0
         end
         # Store the learned model.
-        @weight_vec = weight_vec * NMatrix.new([1, n_training_samples], bin_y)
+        @weight_vec = weight_vec * Numo::DFloat.asarray(bin_y)
         self
       end
 
       # Calculate confidence scores for samples.
       #
-      # @param x [NMatrix] (shape: [n_testing_samples, n_training_samples])
+      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
       #     The kernel matrix between testing samples and training samples to compute the scores.
-      # @return [NMatrix] (shape: [1, n_testing_samples]) Confidence score per sample.
+      # @return [Numo::DFloat] (shape: [n_testing_samples]) Confidence score per sample.
       def decision_function(x)
         @weight_vec.dot(x.transpose)
       end
 
       # Predict class labels for samples.
       #
-      # @param x [NMatrix] (shape: [n_testing_samples, n_training_samples])
+      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
       #     The kernel matrix between testing samples and training samples to predict the labels.
-      # @return [NMatrix] (shape: [1, n_testing_samples]) Predicted class label per sample.
+      # @return [Numo::Int32] (shape: [n_testing_samples]) Predicted class label per sample.
       def predict(x)
-        decision_function(x).map { |v| v >= 0 ? 1 : -1 }
+        Numo::Int32.cast(decision_function(x).map { |v| v >= 0 ? 1 : -1 })
       end
 
       # Claculate the mean accuracy of the given testing data.
       #
-      # @param x [NMatrix] (shape: [n_testing_samples, n_training_samples])
+      # @param x [Numo::DFloat] (shape: [n_testing_samples, n_training_samples])
       #     The kernel matrix between testing samples and training samples.
-      # @param y [NMatrix] (shape: [1, n_testing_samples]) True labels for testing data.
+      # @param y [Numo::Int32] (shape: [n_testing_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.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 KernelSVC.
       def marshal_dump
-        { params: params, weight_vec: Utils.dump_nmatrix(@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]
-        @weight_vec = Utils.restore_nmatrix(obj[:weight_vec])
+        @weight_vec = obj[:weight_vec]
         @rng = obj[:rng]
         nil
       end

data/lib/svmkit/linear_model/logistic_regression.rb

@@ -31,7 +31,7 @@ module SVMKit
       }.freeze
 
       # Return the weight vector for Logistic Regression.
-      # @return [NMatrix] (shape: [1, n_features])
+      # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :weight_vec
 
       # Return the bias term (a.k.a. intercept) for Logistic Regression.
@@ -44,18 +44,21 @@ module SVMKit
 
       # Create a new classifier with Logisitc Regression by the SGD optimization.
       #
-      # @overload new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> LogisiticRegression
-      #
-      # @param params [Hash] The parameters for Logistic Regression.
-      # @option params [Float]   :reg_param (1.0) The regularization parameter.
-      # @option params [Boolean] :fit_bias (false) The flag indicating whether to fit the bias term.
-      # @option params [Float]   :bias_scale (1.0) The scale of the bias term.
+      # @param reg_param [Float] The regularization parameter.
+      # @param fit_bias [Boolean] The flag indicating whether to fit the bias term.
+      # @param bias_scale [Float] The scale of the bias term.
       #   If fit_bias is true, the feature vector v becoms [v; bias_scale].
-      # @option params [Integer] :max_iter (100) The maximum number of iterations.
-      # @option params [Integer] :batch_size (50) The size of the mini batches.
-      # @option params [Integer] :random_seed (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] }])
+      # @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(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
         @weight_vec = nil
         @bias_term = 0.0
@@ -64,21 +67,25 @@ module SVMKit
 
       # Fit the model with given training data.
       #
-      # @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)
+      # @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 [LogisticRegression] 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 : 0 }
+        negative_label = y.to_a.uniq.sort.shift
+        bin_y = y.to_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]
+        if params[:fit_bias]
+          samples = Numo::NArray.hstack(
+            [samples, Numo::DFloat.ones([x.shape[0], 1]) * params[:bias_scale]]
+          )
+        end
         # Initialize some variables.
         n_samples, n_features = samples.shape
         rand_ids = [*0..n_samples - 1].shuffle(random: @rng)
-        weight_vec = NMatrix.zeros([1, n_features])
+        weight_vec = Numo::DFloat.zeros(n_features)
         # Start optimization.
         params[:max_iter].times do |t|
           # random sampling
@@ -86,16 +93,17 @@ module SVMKit
           rand_ids.concat(subset_ids)
           # update the weight vector.
           eta = 1.0 / (params[:reg_param] * (t + 1))
-          mean_vec = NMatrix.zeros([1, n_features])
+          mean_vec = Numo::DFloat.zeros(n_features)
           subset_ids.each do |n|
-            z = weight_vec.dot(samples.row(n).transpose)[0]
+            z = weight_vec.dot(samples[n, true])
             coef = bin_y[n] / (1.0 + Math.exp(bin_y[n] * z))
-            mean_vec += samples.row(n) * coef
+            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
           # scale the weight vector.
-          scaler = (1.0 / params[:reg_param]**0.5) / weight_vec.norm2
+          norm = Math.sqrt(weight_vec.dot(weight_vec))
+          scaler = (1.0 / params[:reg_param]**0.5) / (norm + 1.0e-12)
           weight_vec *= [1.0, scaler].min
         end
         # Store the learned model.
@@ -111,51 +119,51 @@ module SVMKit
 
       # Calculate confidence scores for samples.
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to compute the scores.
-      # @return [NMatrix] (shape: [1, n_samples]) Confidence score per sample.
+      # @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 = ((@weight_vec.dot(x.transpose) + @bias_term) * -1.0).exp + 1.0
+        w = Numo::NMath.exp(((@weight_vec.dot(x.transpose) + @bias_term) * -1.0)) + 1.0
         w.map { |v| 1.0 / v }
       end
 
       # Predict class labels for samples.
       #
-      # @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.
+      # @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)
-        decision_function(x).map { |v| v >= 0.5 ? 1 : -1 }
+        Numo::Int32.cast(decision_function(x).map { |v| v >= 0.5 ? 1 : -1 })
       end
 
       # Predict probability for samples.
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to predict the probailities.
-      # @return [NMatrix] (shape: [1, n_samples]) Predicted probability per sample.
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
+      # @return [Numo::DFloat] (shape: [n_samples]) Predicted probability per sample.
       def predict_proba(x)
         decision_function(x)
       end
 
       # Claculate the mean accuracy of the given testing data.
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) Testing data.
-      # @param y [NMatrix] (shape: [1, n_samples]) True labels for 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_flat_a.map.with_index { |l, n| l == p[n] ? 1 : 0 }).inject(:+)
+        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 LogisticRegression.
       def marshal_dump
-        { params: params, weight_vec: Utils.dump_nmatrix(@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]
-        @weight_vec = Utils.restore_nmatrix(obj[:weight_vec])
+        @weight_vec = obj[:weight_vec]
         @bias_term = obj[:bias_term]
         @rng = obj[:rng]
         nil