rumale-linear_model 0.25.0 → 0.27.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 57ddfab4ee9acb363b19691bde8ddeb8d6ca9537bb0f8dc686d51c577272d335
-  data.tar.gz: 3df78c9596e6e6b93c413db560ef96b74a129f2ac6cb312e3bf374d01db72e62
+  metadata.gz: da770eaccf1809e9507caddea80332adf08759ae8af86179e418f7f787447153
+  data.tar.gz: '08b4a248944649b0b1216207fdeca4dd578d75a4280fc22a98ecca717b37f3b9'
 SHA512:
-  metadata.gz: f7d7df4703f64c3339d41b8c5b4f1a4ef72fedc501fa57119318659982a99d6faca3f8a49618be61f394a5ac0771dd85c90c529bb922eca6eeb584a94fa73e1d
-  data.tar.gz: a8228cf58797743818a11c41ac7d3f82775b82e745c1132caf568a532e3e114e6f237c59860b10d4f8888c9b7a1dbded4a4c1f390c54686ea857fa98bc03216d
+  metadata.gz: 8f160cac5b9cd6abad11ad4f6d095629f22075fa1e27642892c955cb7682fb114eeee330a54e835e48b5f2b40a32e7841f2b909011bda1d67033a34308ad43cf
+  data.tar.gz: 2b6d68a3f573d3d1394278f2a4ba5bf1a820be2eb1866967ec0e27e2b35be660f1b3367c765ecbd42e8aa41b53a1851b87163ffc81695a4b28eed6b483a9492f

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.25.0'
+    VERSION = '0.27.0'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale-linear_model
 version: !ruby/object:Gem::Version
-  version: 0.25.0
+  version: 0.27.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-01-18 00:00:00.000000000 Z
+date: 2023-08-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: lbfgsb
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.27.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 0.25.0
+        version: 0.27.0
 description: |
   Rumale::LinearModel provides linear model algorithms,
   such as Logistic Regression, Support Vector Machine, Lasso, and Ridge Regression