svmkit 0.1.3 → 0.2.0

data/lib/svmkit/linear_model/{pegasos_svc.rb → svc.rb}

@@ -4,17 +4,17 @@ require 'svmkit/base/classifier'
 module SVMKit
   # This module consists of the classes that implement generalized linear models.
   module LinearModel
-    # PegasosSVC is a class that implements Support Vector Classifier with the Pegasos algorithm.
+    # SVC 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)
+    #     SVMKit::LinearModel::SVC.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*
     # 1. S. Shalev-Shwartz and Y. Singer, "Pegasos: Primal Estimated sub-GrAdient SOlver for SVM," Proc. ICML'07, pp. 807--814, 2007.
-    class PegasosSVC
+    class SVC
       include Base::BaseEstimator
       include Base::Classifier
 
@@ -29,7 +29,7 @@ module SVMKit
       }.freeze
 
       # Return the weight vector for SVC.
-      # @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 SVC.
@@ -42,17 +42,20 @@ module SVMKit
 
       # Create a new classifier with Support Vector Machine by the Pegasos algorithm.
       #
-      # @overload new(reg_param: 1.0, max_iter: 100, batch_size: 50, random_seed: 1) -> PegasosSVC
-      #
-      # @param params [Hash] The parameters for SVC.
-      # @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.
-      # @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 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.
+      # @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
@@ -61,38 +64,41 @@ 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 labels to be used for fitting the model.
-      # @return [PegasosSVC] The learned classifier itself.
+      # @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 [SVC] 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 }
         # 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
           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(samples.row(n).transpose) * bin_y[n] < 1
-          end
+          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))
-          mean_vec = NMatrix.zeros([1, n_features])
-          target_ids.each { |n| mean_vec += samples.row(n) * bin_y[n] }
+          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
           # 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.
@@ -108,42 +114,42 @@ 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)
         @weight_vec.dot(x.transpose) + @bias_term
       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 ? 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_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 PegasosSVC.
+      # @return [Hash] The marshal data about SVC.
       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

data/lib/svmkit/multiclass/one_vs_rest_classifier.rb

@@ -16,40 +16,34 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Classifier
 
-      # @!visibility private
-      DEFAULT_PARAMS = {
-        estimator: nil
-      }.freeze
-
       # Return the set of estimators.
       # @return [Array<Classifier>]
       attr_reader :estimators
 
       # Return the class labels.
-      # @return [NMatrix] (shape: [1, n_classes])
+      # @return [Numo::Int32] (shape: [n_classes])
       attr_reader :classes
 
       # Create a new multi-label classifier with the one-vs-rest startegy.
       #
-      # @overload new(estimator: base_estimator) -> OneVsRestClassifier
-      #
-      # @param params [Hash] The parameters for OneVsRestClassifier.
-      # @option params [Classifier] :estimator (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] }])
+      # @param estimator [Classifier] The (binary) classifier for construction a multi-label classifier.
+      def initialize(estimator: nil)
+        self.params = {}
+        self.params[:estimator] = estimator
         @estimators = nil
         @classes = nil
       end
 
       # 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 labels to be used for fitting the model.
+      # @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 [OneVsRestClassifier] The learned classifier itself.
       def fit(x, y)
-        @classes = y.uniq.sort
-        @estimators = @classes.map do |label|
-          bin_y = y.map { |l| l == label ? 1 : -1 }
+        y_arr = y.to_a
+        @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)
         end
         self
@@ -57,36 +51,31 @@ module SVMKit
 
       # Calculate confidence scores for samples.
       #
-      # @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.
+      # @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_samples, = x.shape
         n_classes = @classes.size
-        NMatrix.new(
-          [n_classes, n_samples],
-          Array.new(n_classes) { |m| @estimators[m].decision_function(x).to_a }.flatten
-        ).transpose
+        Numo::DFloat.asarray(Array.new(n_classes) { |m| @estimators[m].decision_function(x).to_a }).transpose
       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)
         n_samples, = x.shape
         decision_values = decision_function(x)
-        NMatrix.new([1, n_samples],
-                    decision_values.each_row.map { |vals| @classes[vals.to_a.index(vals.to_a.max)] })
+        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 [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
 

data/lib/svmkit/pairwise_metric.rb

@@ -4,38 +4,38 @@ module SVMKit
     class << self
       # Calculate the pairwise euclidean distances between x and y.
       #
-      # @param x [NMatrix] (shape: [n_samples_x, n_features])
-      # @param y [NMatrix] (shape: [n_samples_y, n_features])
-      # @return [NMatrix] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
+      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
+      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
+      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def euclidean_distance(x, y = nil)
         y = x if y.nil?
         sum_x_vec = (x**2).sum(1)
         sum_y_vec = (y**2).sum(1)
         dot_xy_mat = x.dot(y.transpose)
         distance_matrix = dot_xy_mat * -2.0 +
-                          sum_x_vec.repeat(y.shape[0], 1) +
-                          sum_y_vec.transpose.repeat(x.shape[0], 0)
-        distance_matrix.abs.sqrt
+                          sum_x_vec.tile(y.shape[0], 1).transpose +
+                          sum_y_vec.tile(x.shape[0], 1)
+        Numo::NMath.sqrt(distance_matrix.abs)
       end
 
       # Calculate the rbf kernel between x and y.
       #
-      # @param x [NMatrix] (shape: [n_samples_x, n_features])
-      # @param y [NMatrix] (shape: [n_samples_y, n_features])
+      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
+      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
       # @param gamma [Float] The parameter of rbf kernel, if nil it is 1 / n_features.
-      # @return [NMatrix] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
+      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def rbf_kernel(x, y = nil, gamma = nil)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
         distance_matrix = euclidean_distance(x, y)
-        ((distance_matrix**2) * -gamma).exp
+        Numo::NMath.exp((distance_matrix**2) * -gamma)
       end
 
       # Calculate the linear kernel between x and y.
       #
-      # @param x [NMatrix] (shape: [n_samples_x, n_features])
-      # @param y [NMatrix] (shape: [n_samples_y, n_features])
-      # @return [NMatrix] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
+      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
+      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
+      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def linear_kernel(x, y = nil)
         y = x if y.nil?
         x.dot(y.transpose)
@@ -43,12 +43,12 @@ module SVMKit
 
       # Calculate the polynomial kernel between x and y.
       #
-      # @param x [NMatrix] (shape: [n_samples_x, n_features])
-      # @param y [NMatrix] (shape: [n_samples_y, n_features])
+      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
+      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
       # @param degree [Integer] The parameter of polynomial kernel.
       # @param gamma [Float] The parameter of polynomial kernel, if nil it is 1 / n_features.
       # @param coef [Integer] The parameter of polynomial kernel.
-      # @return [NMatrix] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
+      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def polynomial_kernel(x, y = nil, degree = 3, gamma = nil, coef = 1)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
@@ -57,15 +57,15 @@ module SVMKit
 
       # Calculate the sigmoid kernel between x and y.
       #
-      # @param x [NMatrix] (shape: [n_samples_x, n_features])
-      # @param y [NMatrix] (shape: [n_samples_y, n_features])
+      # @param x [Numo::DFloat] (shape: [n_samples_x, n_features])
+      # @param y [Numo::DFloat] (shape: [n_samples_y, n_features])
       # @param gamma [Float] The parameter of polynomial kernel, if nil it is 1 / n_features.
       # @param coef [Integer] The parameter of polynomial kernel.
-      # @return [NMatrix] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
+      # @return [Numo::DFloat] (shape: [n_samples_x, n_samples_x] or [n_samples_x, n_samples_y] if y is given)
       def sigmoid_kernel(x, y = nil, gamma = nil, coef = 1)
         y = x if y.nil?
         gamma ||= 1.0 / x.shape[1]
-        (x.dot(y.transpose) * gamma + coef).tanh
+        Numo::NMath.tanh(x.dot(y.transpose) * gamma + coef)
       end
     end
   end

data/lib/svmkit/preprocessing/l2_normalizer.rb

@@ -14,13 +14,12 @@ module SVMKit
       include Base::Transformer
 
       # Return the vector consists of L2-norm for each sample.
-      # @return [NMatrix] (shape: [1, n_samples])
+      # @return [Numo::DFloat] (shape: [n_samples])
       attr_reader :norm_vec # :nodoc:
 
       # Create a new normalizer for normaliing to unit L2-norm.
-      #
-      # @overload new() -> L2Normalizer
-      def initialize(_params = {})
+      def initialize()
+        self.params = {}
         @norm_vec = nil
       end
 
@@ -28,24 +27,22 @@ module SVMKit
       #
       # @overload fit(x) -> L2Normalizer
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @param x [Numo::DFloat] (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],
-                                Array.new(n_samples) { |n| x.row(n).norm2 })
+        @norm_vec = Numo::NMath.sqrt((x**2).sum(1))
         self
       end
 
       # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.
       #
-      # @overload fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> Numo::DFloat
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
-      # @return [NMatrix] The normalized samples.
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L2-norms.
+      # @return [Numo::DFloat] The normalized samples.
       def fit_transform(x, _y = nil)
         fit(x)
-        x / @norm_vec.transpose.repeat(x.shape[1], 1)
+        x / @norm_vec.tile(x.shape[1], 1).transpose
       end
     end
   end

data/lib/svmkit/preprocessing/min_max_scaler.rb

@@ -14,27 +14,20 @@ module SVMKit
       include Base::BaseEstimator
       include Base::Transformer
 
-      # @!visibility private
-      DEFAULT_PARAMS = {
-        feature_range: [0.0, 1.0]
-      }.freeze
-
       # Return the vector consists of the minimum value for each feature.
-      # @return [NMatrix] (shape: [1, n_features])
+      # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :min_vec
 
       # Return the vector consists of the maximum value for each feature.
-      # @return [NMatrix] (shape: [1, n_features])
+      # @return [Numo::DFloat] (shape: [n_features])
       attr_reader :max_vec
 
       # Creates a new normalizer for scaling each feature to a given range.
       #
-      # @overload new(feature_range: [0.0, 1.0]) -> MinMaxScaler
-      #
-      # @param params [Hash] The parameters for MinMaxScaler.
-      # @option params [Array<Float>] :feature_range ([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] }])
+      # @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
         @min_vec = nil
         @max_vec = nil
       end
@@ -43,7 +36,7 @@ module SVMKit
       #
       # @overload fit(x) -> MinMaxScaler
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @param x [Numo::DFloat] (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)
@@ -53,22 +46,22 @@ module SVMKit
 
       # Calculate the minimum and maximum values, and then normalize samples to feature_range.
       #
-      # @overload fit_transform(x) -> NMatrix
+      # @overload fit_transform(x) -> Numo::DFloat
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
-      # @return [NMatrix] The scaled samples.
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the minimum and maximum values.
+      # @return [Numo::DFloat] The scaled samples.
       def fit_transform(x, _y = nil)
         fit(x).transform(x)
       end
 
       # Perform scaling the given samples according to feature_range.
       #
-      # @param x [NMatrix] (shape: [n_samples, n_features]) The samples to be scaled.
-      # @return [NMatrix] The scaled samples.
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be scaled.
+      # @return [Numo::DFloat] The scaled samples.
       def transform(x)
         n_samples, = x.shape
         dif_vec = @max_vec - @min_vec
-        nx = (x - @min_vec.repeat(n_samples, 0)) / dif_vec.repeat(n_samples, 0)
+        nx = (x - @min_vec.tile(n_samples, 1)) / dif_vec.tile(n_samples, 1)
         nx * (@params[:feature_range][1] - @params[:feature_range][0]) + @params[:feature_range][0]
       end
 
@@ -76,16 +69,16 @@ module SVMKit
       # @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) }
+          min_vec: @min_vec,
+          max_vec: @max_vec }
       end
 
       # 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])
+        @min_vec = obj[:min_vec]
+        @max_vec = obj[:max_vec]
         nil
       end
     end