rumale-linear_model 0.26.0 → 0.28.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 68480352c1ab25d2242da8364a3377ee6ef0a1241c3299b5ffda0d3b699e81be
-  data.tar.gz: c02626de09115b2ce65dd6d4174d89fe1854a8385c33fa0c942822ba6d0a4c54
+  metadata.gz: 928168740565c9efd716841ef5a6901296182de1282706b093f287871cf80da5
+  data.tar.gz: 5e42d83b8a8a34dc68a0e2bbca71bd5e94f5a24ada21b03d24f548ff9d0c0c21
 SHA512:
-  metadata.gz: 23ed6fe1871d0fc6e8f10e32076257624683954f6f13fbd164289297ca845eaceb9829ae64e5a2af66b119bfa9a13cc3d609a767d9e97fc39ec88a59fcceaa7f
-  data.tar.gz: ab43f09a3fcecbe7b8c82a29f33380d363a4bfa056392f83cca931a4d839805250ad05640b0f1219cd78b72e824c6303427b62c02a362a26d08a1c0f9b220bfe
+  metadata.gz: b60d55f537d29da22f76355347f11b3def138e177befd0e37fae1d513285aebe951f582cbf428ca6d562deb5ba77c932d780cb3c9b3250eb3c5dbb1591a44168
+  data.tar.gz: 4e0661211522fe86613919331723761eaf35cc8f51d14d1b5351cd3d3975fe4a1bdc9430f36c57f92b635daa079896ea05942400cacdbfaf4af3523740c8827f

data/lib/rumale/linear_model/sgd_classifier.rb

@@ -114,6 +114,32 @@ module Rumale
         self
       end
 
+      # Perform 1-epoch of stochastic gradient descent optimization 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 binary labels to be used for fitting the model.
+      # @return [SGDClassifier] The learned classifier itself.
+      def partial_fit(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_label_array(y)
+        Rumale::Validation.check_sample_size(x, y)
+
+        n_features = x.shape[1]
+        n_features += 1 if fit_bias?
+        need_init = @weight.nil? || @weight.shape[0] != n_features
+
+        @classes = Numo::Int32[*y.to_a.uniq.sort] if need_init
+        negative_label = @classes[0]
+        bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
+
+        @weight_vec, @bias_term = partial_fit_(x, bin_y, max_iter: 1, init: need_init)
+        if @loss_func.name == Rumale::LinearModel::Loss::HingeLoss::NAME
+          @prob_param = Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose) + @bias_term, bin_y)
+        end
+
+        self
+      end
+
       # Calculate confidence scores for samples.
       #
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to compute the scores.
@@ -156,14 +182,14 @@ module Rumale
           models = if enable_parallel?
                      parallel_map(n_classes) do |n|
                        bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-                       w, b = partial_fit(x, bin_y)
+                       w, b = partial_fit_(x, bin_y)
                        prb = Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(w.transpose) + b, bin_y)
                        [w, b, prb]
                      end
                    else
                      Array.new(n_classes) do |n|
                        bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-                       w, b = partial_fit(x, bin_y)
+                       w, b = partial_fit_(x, bin_y)
                        prb = Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(w.transpose) + b, bin_y)
                        [w, b, prb]
                      end
@@ -173,7 +199,7 @@ module Rumale
         else
           negative_label = @classes[0]
           bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
-          @weight_vec, @bias_term = partial_fit(x, bin_y)
+          @weight_vec, @bias_term = partial_fit_(x, bin_y)
           @prob_param = Rumale::ProbabilisticOutput.fit_sigmoid(x.dot(@weight_vec.transpose) + @bias_term, bin_y)
         end
       end
@@ -187,19 +213,19 @@ module Rumale
           if enable_parallel?
             models = parallel_map(n_classes) do |n|
               bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-              partial_fit(x, bin_y)
+              partial_fit_(x, bin_y)
             end
             n_classes.times { |n| @weight_vec[n, true], @bias_term[n] = models[n] }
           else
             n_classes.times do |n|
               bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-              @weight_vec[n, true], @bias_term[n] = partial_fit(x, bin_y)
+              @weight_vec[n, true], @bias_term[n] = partial_fit_(x, bin_y)
             end
           end
         else
           negative_label = @classes[0]
           bin_y = Numo::Int32.cast(y.ne(negative_label)) * 2 - 1
-          @weight_vec, @bias_term = partial_fit(x, bin_y)
+          @weight_vec, @bias_term = partial_fit_(x, bin_y)
         end
       end
 

data/lib/rumale/linear_model/sgd_estimator.rb

@@ -215,45 +215,49 @@ module Rumale
 
       private_constant :L2_PENALTY, :L1_PENALTY, :ELASTICNET_PENALTY
 
-      def partial_fit(x, y)
+      def init_vars(n_features)
+        @sub_rng = @rng.dup
+        @weight = Numo::DFloat.zeros(n_features)
+        @optimizer = ::Rumale::LinearModel::Optimizer::SGD.new(
+          learning_rate: @params[:learning_rate], momentum: @params[:momentum], decay: @params[:decay]
+        )
+        @l2_penalty = ::Rumale::LinearModel::Penalty::L2Penalty.new(reg_param: l2_reg_param)
+        @l1_penalty = ::Rumale::LinearModel::Penalty::L1Penalty.new(reg_param: l1_reg_param)
+      end
+
+      def partial_fit_(x, y, max_iter: @params[:max_iter], init: true)
         class_name = self.class.to_s.split('::').last if @params[:verbose]
         narr = x.class
         # Expand feature vectors for bias term.
         x = expand_feature(x) if fit_bias?
         # Initialize some variables.
-        sub_rng = @rng.dup
         n_samples, n_features = x.shape
-        weight = Numo::DFloat.zeros(n_features)
-        optimizer = ::Rumale::LinearModel::Optimizer::SGD.new(
-          learning_rate: @params[:learning_rate], momentum: @params[:momentum], decay: @params[:decay]
-        )
-        l2_penalty = ::Rumale::LinearModel::Penalty::L2Penalty.new(reg_param: l2_reg_param) if apply_l2_penalty?
-        l1_penalty = ::Rumale::LinearModel::Penalty::L1Penalty.new(reg_param: l1_reg_param) if apply_l1_penalty?
+        init_vars(n_features) if init
         # Optimization.
-        @params[:max_iter].times do |t|
+        max_iter.times do |t|
           sample_ids = Array(0...n_samples)
-          sample_ids.shuffle!(random: sub_rng)
+          sample_ids.shuffle!(random: @sub_rng)
           until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
             # sampling
             sub_x = x[subset_ids, true]
             sub_y = y[subset_ids]
             # calculate gradient
-            dloss = @loss_func.dloss(sub_x.dot(weight), sub_y)
+            dloss = @loss_func.dloss(sub_x.dot(@weight), sub_y)
             dloss = narr.minimum(1e12, narr.maximum(-1e12, dloss))
             gradient = dloss.dot(sub_x)
             # update weight
-            lr = optimizer.current_learning_rate
-            weight = optimizer.call(weight, gradient)
+            lr = @optimizer.current_learning_rate
+            @weight = @optimizer.call(@weight, gradient)
             # l2 regularization
-            weight = l2_penalty.call(weight, lr) if apply_l2_penalty?
+            @weight = @l2_penalty.call(@weight, lr) if apply_l2_penalty?
             # l1 regularization
-            weight = l1_penalty.call(weight, lr) if apply_l1_penalty?
+            @weight = @l1_penalty.call(@weight, lr) if apply_l1_penalty?
           end
-          loss = @loss_func.loss(x.dot(weight), y)
+          loss = @loss_func.loss(x.dot(@weight), y)
           puts "[#{class_name}] Loss after #{t + 1} epochs: #{loss}" if @params[:verbose]
           break if loss < @params[:tol]
         end
-        split_weight(weight)
+        split_weight(@weight)
       end
 
       def apply_l2_penalty?

data/lib/rumale/linear_model/sgd_regressor.rb

@@ -112,18 +112,37 @@ module Rumale
           @weight_vec = Numo::DFloat.zeros(n_outputs, n_features)
           @bias_term = Numo::DFloat.zeros(n_outputs)
           if enable_parallel?
-            models = parallel_map(n_outputs) { |n| partial_fit(x, y[true, n]) }
+            models = parallel_map(n_outputs) { |n| partial_fit_(x, y[true, n]) }
             n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = models[n] }
           else
-            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
+            n_outputs.times { |n| @weight_vec[n, true], @bias_term[n] = partial_fit_(x, y[true, n]) }
           end
         else
-          @weight_vec, @bias_term = partial_fit(x, y)
+          @weight_vec, @bias_term = partial_fit_(x, y)
         end
 
         self
       end
 
+      # Perform 1-epoch of stochastic gradient descent optimization 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::DFloat] (shape: [n_samples]) The single target variables to be used for fitting the model.
+      # @return [SGDRegressor] The learned regressor itself.
+      def partial_fit(x, y)
+        x = Rumale::Validation.check_convert_sample_array(x)
+        y = Rumale::Validation.check_convert_target_value_array(y)
+        Rumale::Validation.check_sample_size(x, y)
+
+        n_features = x.shape[1]
+        n_features += 1 if fit_bias?
+        need_init = @weight.nil? || @weight.shape[0] != n_features
+
+        @weight_vec, @bias_term = partial_fit_(x, y, max_iter: 1, init: need_init)
+
+        self
+      end
+
       # Predict values for samples.
       #
       # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.

data/lib/rumale/linear_model/version.rb

@@ -5,6 +5,6 @@ module Rumale
   # This module consists of the classes that implement generalized linear models.
   module LinearModel
     # @!visibility private
-    VERSION = '0.26.0'
+    VERSION = '0.28.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-linear_model
 version: !ruby/object:Gem::Version
-  version: 0.26.0
+  version: 0.28.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-02-19 00:00:00.000000000 Z
+date: 2023-11-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lbfgsb
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.28.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.26.0
+        version: 0.28.0
 description: |
   Rumale::LinearModel provides linear model algorithms,
   such as Logistic Regression, Support Vector Machine, Lasso, and Ridge Regression
@@ -102,7 +102,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.3.26
+rubygems_version: 3.4.20
 signing_key:
 specification_version: 4
 summary: Rumale::LinearModel provides linear model algorithms with Rumale interface.