rumale 0.19.3 → 0.20.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: dc3413c05ad7c365117adc4abbc304ff1851fa9a3ff69fef3c69e730d9a2b834
-  data.tar.gz: 8895cce8b350c4e245aabb5e3e4c4036655fa8d24a72f6481e0d2f8c9869fa54
+  metadata.gz: 358515f8785eb3de2e6571a957ca76cece6b774bb022c1a0951c92d44ab422b4
+  data.tar.gz: '0289b7eb382cd3300845412af0fd43626f4f827bb719083c879b574e3ab37eb0'
 SHA512:
-  metadata.gz: fe10c975f286a4c9ac155d29310d61d1f180cbcc909ec7bdba3925973b6b9857635befc9bf4938cf28a6ef50c8011894b7b15768735f6200c27ce912907e5fb1
-  data.tar.gz: 327cce25145c1ca3f5623f84b4163560bdbee8245009c3d8e1c3318f61dec94b58a7395ebc3538e7b04a9702af08b077e7f426c54f7c5d4fd3b0fcf11c4744cf
+  metadata.gz: f03fc0f27f99ed4acea3fb7d7bf34017c1dbf923b20dabc9a78d6d44f0b151bc9dc78ba24d122f81607a43fd1852e398a603b75b87656a2f79109f87c0db0d98
+  data.tar.gz: 69f6b8892f6bfb4c43706513245c3fba687dcb6a347c1c5185a70d5e45a024b2848a019bfae48726e1f49212878e8d6d67c811ec5f4a990fdbb3a2841efdfe9b

data/CHANGELOG.md

@@ -1,3 +1,7 @@
+# 0.20.0
+## Breaking changes
+- Delete deprecated estimators such as PolynomialModel, Optimizer, and BaseLinearModel.
+
 # 0.19.3
 - Add preprocessing class for [Binarizer](https://yoshoku.github.io/rumale/doc/Rumale/Preprocessing/Binarizer.html)
 - Add preprocessing class for [MaxNormalizer](https://yoshoku.github.io/rumale/doc/Rumale/Preprocessing/MaxNormalizer.html)
@@ -13,6 +17,7 @@
 - Fix some typos.
 
 # 0.19.0
+## Breaking changes
 - Change mmh3 and mopti gem to non-runtime dependent library.
   - The mmh3 gem is used in [FeatureHasher](https://yoshoku.github.io/rumale/doc/Rumale/FeatureExtraction/FeatureHasher.html).
   You only need to require mmh3 gem when using FeatureHasher.

data/lib/rumale.rb

@@ -18,17 +18,10 @@ require 'rumale/base/cluster_analyzer'
 require 'rumale/base/transformer'
 require 'rumale/base/splitter'
 require 'rumale/base/evaluator'
-require 'rumale/optimizer/sgd'
-require 'rumale/optimizer/ada_grad'
-require 'rumale/optimizer/rmsprop'
-require 'rumale/optimizer/adam'
-require 'rumale/optimizer/nadam'
-require 'rumale/optimizer/yellow_fin'
 require 'rumale/pipeline/pipeline'
 require 'rumale/pipeline/feature_union'
 require 'rumale/kernel_approximation/rbf'
 require 'rumale/kernel_approximation/nystroem'
-require 'rumale/linear_model/base_linear_model'
 require 'rumale/linear_model/base_sgd'
 require 'rumale/linear_model/svc'
 require 'rumale/linear_model/svr'
@@ -41,9 +34,6 @@ require 'rumale/kernel_machine/kernel_svc'
 require 'rumale/kernel_machine/kernel_pca'
 require 'rumale/kernel_machine/kernel_fda'
 require 'rumale/kernel_machine/kernel_ridge'
-require 'rumale/polynomial_model/base_factorization_machine'
-require 'rumale/polynomial_model/factorization_machine_classifier'
-require 'rumale/polynomial_model/factorization_machine_regressor'
 require 'rumale/multiclass/one_vs_rest_classifier'
 require 'rumale/nearest_neighbors/vp_tree'
 require 'rumale/nearest_neighbors/k_neighbors_classifier'

data/lib/rumale/version.rb

@@ -3,5 +3,5 @@
 # Rumale is a machine learning library in Ruby.
 module Rumale
   # The version of Rumale you are using.
-  VERSION = '0.19.3'
+  VERSION = '0.20.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.19.3
+  version: 0.20.0
 platform: ruby
 authors:
 - yoshoku
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-07-23 00:00:00.000000000 Z
+date: 2020-08-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -120,7 +120,6 @@ files:
 - lib/rumale/kernel_machine/kernel_pca.rb
 - lib/rumale/kernel_machine/kernel_ridge.rb
 - lib/rumale/kernel_machine/kernel_svc.rb
-- lib/rumale/linear_model/base_linear_model.rb
 - lib/rumale/linear_model/base_sgd.rb
 - lib/rumale/linear_model/elastic_net.rb
 - lib/rumale/linear_model/lasso.rb
@@ -154,18 +153,9 @@ files:
 - lib/rumale/neural_network/base_mlp.rb
 - lib/rumale/neural_network/mlp_classifier.rb
 - lib/rumale/neural_network/mlp_regressor.rb
-- lib/rumale/optimizer/ada_grad.rb
-- lib/rumale/optimizer/adam.rb
-- lib/rumale/optimizer/nadam.rb
-- lib/rumale/optimizer/rmsprop.rb
-- lib/rumale/optimizer/sgd.rb
-- lib/rumale/optimizer/yellow_fin.rb
 - lib/rumale/pairwise_metric.rb
 - lib/rumale/pipeline/feature_union.rb
 - lib/rumale/pipeline/pipeline.rb
-- lib/rumale/polynomial_model/base_factorization_machine.rb
-- lib/rumale/polynomial_model/factorization_machine_classifier.rb
-- lib/rumale/polynomial_model/factorization_machine_regressor.rb
 - lib/rumale/preprocessing/bin_discretizer.rb
 - lib/rumale/preprocessing/binarizer.rb
 - lib/rumale/preprocessing/l1_normalizer.rb

data/lib/rumale/linear_model/base_linear_model.rb

@@ -1,102 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/optimizer/nadam'
-
-module Rumale
-  module LinearModel
-    # @note
-    #   In version 0.17.0, a new linear model abstract class called BaseSGD is introduced.
-    #   BaseLienarModel is deprecated and will be removed in the future.
-    # @deprecated Use BaseSGD class instead. This class will be deleted in version 0.20.0.
-    #
-    # BaseLinearModel is an abstract class for implementation of linear estimator
-    # with mini-batch stochastic gradient descent optimization.
-    # This class is used for internal process.
-    class BaseLinearModel
-      # :nocov:
-      include Base::BaseEstimator
-
-      # Initialize a linear estimator.
-      #
-      # @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 optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
-      #   If nil is given, Nadam is used.
-      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
-      #   If nil is given, the methods do not execute in parallel.
-      #   If zero or less is given, it becomes equal to the number of processors.
-      # @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: 1000, batch_size: 10, optimizer: nil, n_jobs: nil, random_seed: nil)
-        warn 'warning: BaseLinearModel is deprecated. Use BaseSGD instead.'
-        @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[:optimizer] = optimizer
-        @params[:optimizer] ||= Rumale::Optimizer::Nadam.new
-        @params[:n_jobs] = n_jobs
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @weight_vec = nil
-        @bias_term = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      private
-
-      def partial_fit(x, y)
-        # Expand feature vectors for bias term.
-        samples = @params[:fit_bias] ? expand_feature(x) : x
-        # Initialize some variables.
-        n_samples, n_features = samples.shape
-        rand_ids = Array(0...n_samples).shuffle(random: @rng.dup)
-        weight = Numo::DFloat.zeros(n_features)
-        optimizer = @params[:optimizer].dup
-        # Optimization.
-        @params[:max_iter].times do |_t|
-          # Random sampling
-          subset_ids = rand_ids.shift(@params[:batch_size])
-          rand_ids.concat(subset_ids)
-          sub_samples = samples[subset_ids, true]
-          sub_targets = y[subset_ids]
-          # Update weight.
-          loss_gradient = calc_loss_gradient(sub_samples, sub_targets, weight)
-          next if loss_gradient.ne(0.0).count.zero?
-
-          weight = calc_new_weight(optimizer, sub_samples, weight, loss_gradient)
-        end
-        split_weight(weight)
-      end
-
-      def calc_loss_gradient(_x, _y, _weight)
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      def calc_new_weight(optimizer, x, weight, loss_gradient)
-        weight_gradient = x.transpose.dot(loss_gradient) / @params[:batch_size] + @params[:reg_param] * weight
-        optimizer.call(weight, weight_gradient)
-      end
-
-      def expand_feature(x)
-        n_samples = x.shape[0]
-        Numo::NArray.hstack([x, Numo::DFloat.ones([n_samples, 1]) * @params[:bias_scale]])
-      end
-
-      def split_weight(weight)
-        if @params[:fit_bias]
-          [weight[0...-1].dup, weight[-1]]
-        else
-          [weight, 0.0]
-        end
-      end
-      # :nocov:
-    end
-  end
-end

data/lib/rumale/optimizer/ada_grad.rb

@@ -1,42 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Optimizer
-    # AdaGrad is a class that implements AdaGrad optimizer.
-    #
-    # @deprecated AdaGrad will be deleted in version 0.20.0.
-    #
-    # *Reference*
-    # - Duchi, J., Hazan, E., and Singer, Y., "Adaptive Subgradient Methods for Online Learning and Stochastic Optimization," J. Machine Learning Research, vol. 12, pp. 2121--2159, 2011.
-    class AdaGrad
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with AdaGrad.
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      def initialize(learning_rate: 0.01)
-        warn 'warning: AdaGrad is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate)
-        check_params_positive(learning_rate: learning_rate)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @moment = nil
-      end
-
-      # Calculate the updated weight with AdaGrad adaptive learning rate.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @moment ||= Numo::DFloat.zeros(weight.shape[0])
-        @moment += gradient**2
-        weight - (@params[:learning_rate] / (@moment**0.5 + 1.0e-8)) * gradient
-      end
-    end
-  end
-end

data/lib/rumale/optimizer/adam.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Optimizer
-    # Adam is a class that implements Adam optimizer.
-    #
-    # @deprecated Adam will be deleted in version 0.20.0.
-    #
-    # *Reference*
-    # - Kingma, D P., and Ba, J., "Adam: A Method for Stochastic Optimization," Proc. ICLR'15, 2015.
-    class Adam
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with Adam
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      # @param decay1 [Float] The smoothing parameter for the first moment.
-      # @param decay2 [Float] The smoothing parameter for the second moment.
-      def initialize(learning_rate: 0.001, decay1: 0.9, decay2: 0.999)
-        warn 'warning: Adam is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate, decay1: decay1, decay2: decay2)
-        check_params_positive(learning_rate: learning_rate, decay1: decay1, decay2: decay2)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @params[:decay1] = decay1
-        @params[:decay2] = decay2
-        @fst_moment = nil
-        @sec_moment = nil
-        @iter = 0
-      end
-
-      # Calculate the updated weight with Nadam adaptive learning rate.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @fst_moment ||= Numo::DFloat.zeros(weight.shape)
-        @sec_moment ||= Numo::DFloat.zeros(weight.shape)
-
-        @iter += 1
-
-        @fst_moment = @params[:decay1] * @fst_moment + (1.0 - @params[:decay1]) * gradient
-        @sec_moment = @params[:decay2] * @sec_moment + (1.0 - @params[:decay2]) * gradient**2
-        nm_fst_moment = @fst_moment / (1.0 - @params[:decay1]**@iter)
-        nm_sec_moment = @sec_moment / (1.0 - @params[:decay2]**@iter)
-
-        weight - @params[:learning_rate] * nm_fst_moment / (nm_sec_moment**0.5 + 1e-8)
-      end
-    end
-  end
-end

data/lib/rumale/optimizer/nadam.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  # This module consists of the classes that implement optimizers adaptively tuning hyperparameters.
-  #
-  # @deprecated Optimizer module will be deleted in version 0.20.0.
-  module Optimizer
-    # Nadam is a class that implements Nadam optimizer.
-    #
-    # @deprecated Nadam will be deleted in version 0.20.0.
-    #
-    # *Reference*
-    # - Dozat, T., "Incorporating Nesterov Momentum into Adam," Tech. Repo. Stanford University, 2015.
-    class Nadam
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with Nadam
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      # @param decay1 [Float] The smoothing parameter for the first moment.
-      # @param decay2 [Float] The smoothing parameter for the second moment.
-      def initialize(learning_rate: 0.01, decay1: 0.9, decay2: 0.999)
-        warn 'warning: Nadam is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate, decay1: decay1, decay2: decay2)
-        check_params_positive(learning_rate: learning_rate, decay1: decay1, decay2: decay2)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @params[:decay1] = decay1
-        @params[:decay2] = decay2
-        @fst_moment = nil
-        @sec_moment = nil
-        @decay1_prod = 1.0
-        @iter = 0
-      end
-
-      # Calculate the updated weight with Nadam adaptive learning rate.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @fst_moment ||= Numo::DFloat.zeros(weight.shape[0])
-        @sec_moment ||= Numo::DFloat.zeros(weight.shape[0])
-
-        @iter += 1
-
-        decay1_curr = @params[:decay1] * (1.0 - 0.5 * 0.96**(@iter * 0.004))
-        decay1_next = @params[:decay1] * (1.0 - 0.5 * 0.96**((@iter + 1) * 0.004))
-        decay1_prod_curr = @decay1_prod * decay1_curr
-        decay1_prod_next = @decay1_prod * decay1_curr * decay1_next
-        @decay1_prod = decay1_prod_curr
-
-        @fst_moment = @params[:decay1] * @fst_moment + (1.0 - @params[:decay1]) * gradient
-        @sec_moment = @params[:decay2] * @sec_moment + (1.0 - @params[:decay2]) * gradient**2
-        nm_gradient = gradient / (1.0 - decay1_prod_curr)
-        nm_fst_moment = @fst_moment / (1.0 - decay1_prod_next)
-        nm_sec_moment = @sec_moment / (1.0 - @params[:decay2]**@iter)
-
-        weight - (@params[:learning_rate] / (nm_sec_moment**0.5 + 1e-8)) * ((1 - decay1_curr) * nm_gradient + decay1_next * nm_fst_moment)
-      end
-    end
-  end
-end

data/lib/rumale/optimizer/rmsprop.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Optimizer
-    # RMSProp is a class that implements RMSProp optimizer.
-    #
-    # @deprecated RMSProp will be deleted in version 0.20.0.
-    #
-    # *Reference*
-    # - Sutskever, I., Martens, J., Dahl, G., and Hinton, G., "On the importance of initialization and momentum in deep learning," Proc. ICML' 13, pp. 1139--1147, 2013.
-    # - Hinton, G., Srivastava, N., and Swersky, K., "Lecture 6e rmsprop," Neural Networks for Machine Learning, 2012.
-    class RMSProp
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with RMSProp.
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      # @param momentum [Float] The initial value of momentum.
-      # @param decay [Float] The smooting parameter.
-      def initialize(learning_rate: 0.01, momentum: 0.9, decay: 0.9)
-        warn 'warning: RMSProp is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate, momentum: momentum, decay: decay)
-        check_params_positive(learning_rate: learning_rate, momentum: momentum, decay: decay)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @params[:momentum] = momentum
-        @params[:decay] = decay
-        @moment = nil
-        @update = nil
-      end
-
-      # Calculate the updated weight with RMSProp adaptive learning rate.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @moment ||= Numo::DFloat.zeros(weight.shape[0])
-        @update ||= Numo::DFloat.zeros(weight.shape[0])
-        @moment = @params[:decay] * @moment + (1.0 - @params[:decay]) * gradient**2
-        @update = @params[:momentum] * @update - (@params[:learning_rate] / (@moment**0.5 + 1.0e-8)) * gradient
-        weight + @update
-      end
-    end
-  end
-end

data/lib/rumale/optimizer/sgd.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Optimizer
-    # SGD is a class that implements SGD optimizer.
-    #
-    # @deprecated SGD will be deleted in version 0.20.0.
-    class SGD
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with SGD.
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      # @param momentum [Float] The initial value of momentum.
-      # @param decay [Float] The smooting parameter.
-      def initialize(learning_rate: 0.01, momentum: 0.0, decay: 0.0)
-        warn 'warning: SGD is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate, momentum: momentum, decay: decay)
-        check_params_positive(learning_rate: learning_rate, momentum: momentum, decay: decay)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @params[:momentum] = momentum
-        @params[:decay] = decay
-        @iter = 0
-        @update = nil
-      end
-
-      # Calculate the updated weight with SGD.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @update ||= Numo::DFloat.zeros(weight.shape[0])
-        current_learning_rate = @params[:learning_rate] / (1.0 + @params[:decay] * @iter)
-        @iter += 1
-        @update = @params[:momentum] * @update - current_learning_rate * gradient
-        weight + @update
-      end
-    end
-  end
-end

data/lib/rumale/optimizer/yellow_fin.rb

@@ -1,104 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/base/base_estimator'
-
-module Rumale
-  module Optimizer
-    # YellowFin is a class that implements YellowFin optimizer.
-    #
-    # @deprecated YellowFin will be deleted in version 0.20.0.
-    #
-    # *Reference*
-    # - Zhang, J., and Mitliagkas, I., "YellowFin and the Art of Momentum Tuning," CoRR abs/1706.03471, 2017.
-    class YellowFin
-      include Base::BaseEstimator
-      include Validation
-
-      # Create a new optimizer with YellowFin.
-      #
-      # @param learning_rate [Float] The initial value of learning rate.
-      # @param momentum [Float] The initial value of momentum.
-      # @param decay [Float] The smooting parameter.
-      # @param window_width [Integer] The sliding window width for searching curvature range.
-      def initialize(learning_rate: 0.01, momentum: 0.9, decay: 0.999, window_width: 20)
-        warn 'warning: YellowFin is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(learning_rate: learning_rate, momentum: momentum, decay: decay, window_width: window_width)
-        check_params_positive(learning_rate: learning_rate, momentum: momentum, decay: decay, window_width: window_width)
-        @params = {}
-        @params[:learning_rate] = learning_rate
-        @params[:momentum] = momentum
-        @params[:decay] = decay
-        @params[:window_width] = window_width
-        @smth_learning_rate = learning_rate
-        @smth_momentum = momentum
-        @grad_norms = nil
-        @grad_norm_min = 0.0
-        @grad_norm_max = 0.0
-        @grad_mean_sqr = 0.0
-        @grad_mean = 0.0
-        @grad_var = 0.0
-        @grad_norm_mean = 0.0
-        @curve_mean = 0.0
-        @distance_mean = 0.0
-        @update = nil
-      end
-
-      # Calculate the updated weight with adaptive momentum coefficient and learning rate.
-      #
-      # @param weight [Numo::DFloat] (shape: [n_features]) The weight to be updated.
-      # @param gradient [Numo::DFloat] (shape: [n_features]) The gradient for updating the weight.
-      # @return [Numo::DFloat] (shape: [n_feautres]) The updated weight.
-      def call(weight, gradient)
-        @update ||= Numo::DFloat.zeros(weight.shape[0])
-        curvature_range(gradient)
-        gradient_variance(gradient)
-        distance_to_optimum(gradient)
-        @smth_momentum = @params[:decay] * @smth_momentum + (1 - @params[:decay]) * current_momentum
-        @smth_learning_rate = @params[:decay] * @smth_learning_rate + (1 - @params[:decay]) * current_learning_rate
-        @update = @smth_momentum * @update - @smth_learning_rate * gradient
-        weight + @update
-      end
-
-      private
-
-      def current_momentum
-        dr = Math.sqrt(@grad_norm_max / @grad_norm_min + 1.0e-8)
-        [cubic_root**2, ((dr - 1) / (dr + 1))**2].max
-      end
-
-      def current_learning_rate
-        (1.0 - Math.sqrt(@params[:momentum]))**2 / (@grad_norm_min + 1.0e-8)
-      end
-
-      def cubic_root
-        p = (@distance_mean**2 * @grad_norm_min**2) / (2 * @grad_var + 1.0e-8)
-        w3 = (-Math.sqrt(p**2 + 4.fdiv(27) * p**3) - p).fdiv(2)
-        w = (w3 >= 0.0 ? 1 : -1) * w3.abs**1.fdiv(3)
-        y = w - p / (3 * w + 1.0e-8)
-        y + 1
-      end
-
-      def curvature_range(gradient)
-        @grad_norms ||= []
-        @grad_norms.push((gradient**2).sum)
-        @grad_norms.shift(@grad_norms.size - @params[:window_width]) if @grad_norms.size > @params[:window_width]
-        @grad_norm_min = @params[:decay] * @grad_norm_min + (1 - @params[:decay]) * @grad_norms.min
-        @grad_norm_max = @params[:decay] * @grad_norm_max + (1 - @params[:decay]) * @grad_norms.max
-      end
-
-      def gradient_variance(gradient)
-        @grad_mean_sqr = @params[:decay] * @grad_mean_sqr + (1 - @params[:decay]) * gradient**2
-        @grad_mean = @params[:decay] * @grad_mean + (1 - @params[:decay]) * gradient
-        @grad_var = (@grad_mean_sqr - @grad_mean**2).sum
-      end
-
-      def distance_to_optimum(gradient)
-        grad_sqr = (gradient**2).sum
-        @grad_norm_mean = @params[:decay] * @grad_norm_mean + (1 - @params[:decay]) * Math.sqrt(grad_sqr + 1.0e-8)
-        @curve_mean = @params[:decay] * @curve_mean + (1 - @params[:decay]) * grad_sqr
-        @distance_mean = @params[:decay] * @distance_mean + (1 - @params[:decay]) * (@grad_norm_mean / @curve_mean)
-      end
-    end
-  end
-end

data/lib/rumale/polynomial_model/base_factorization_machine.rb

@@ -1,125 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/optimizer/nadam'
-
-module Rumale
-  # This module consists of the classes that implement polynomial models.
-  #
-  # @deprecated PolynomialModel module will be deleted in version 0.20.0.
-  module PolynomialModel
-    # BaseFactorizationMachine is an abstract class for implementation of Factorization Machine-based estimators.
-    # This class is used internally.
-    #
-    # @deprecated BaseFactorizationMachine will be deleted in version 0.20.0.
-    class BaseFactorizationMachine
-      include Base::BaseEstimator
-
-      # Initialize a Factorization Machine-based estimator.
-      #
-      # @param n_factors [Integer] The maximum number of iterations.
-      # @param loss [String] The loss function ('hinge' or 'logistic' or nil).
-      # @param reg_param_linear [Float] The regularization parameter for linear model.
-      # @param reg_param_factor [Float] The regularization parameter for factor matrix.
-      # @param max_iter [Integer] The maximum number of epochs that indicates
-      #   how many times the whole data is given to the training process.
-      # @param batch_size [Integer] The size of the mini batches.
-      # @param tol [Float] The tolerance of loss for terminating optimization.
-      # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
-      #   If nil is given, Nadam is used.
-      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
-      #   If nil is given, the methods do not execute in parallel.
-      #   If zero or less is given, it becomes equal to the number of processors.
-      #   This parameter is ignored if the Parallel gem is not loaded.
-      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_factors: 2, loss: nil, reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 200, batch_size: 50, tol: 1e-4,
-                     optimizer: nil, n_jobs: nil, verbose: false, random_seed: nil)
-        @params = {}
-        @params[:n_factors] = n_factors
-        @params[:loss] = loss unless loss.nil?
-        @params[:reg_param_linear] = reg_param_linear
-        @params[:reg_param_factor] = reg_param_factor
-        @params[:max_iter] = max_iter
-        @params[:batch_size] = batch_size
-        @params[:tol] = tol
-        @params[:optimizer] = optimizer
-        @params[:optimizer] ||= Optimizer::Nadam.new
-        @params[:n_jobs] = n_jobs
-        @params[:verbose] = verbose
-        @params[:random_seed] = random_seed
-        @params[:random_seed] ||= srand
-        @factor_mat = nil
-        @weight_vec = nil
-        @bias_term = nil
-        @rng = Random.new(@params[:random_seed])
-      end
-
-      private
-
-      def partial_fit(x, y)
-        # Initialize some variables.
-        class_name = self.class.to_s.split('::').last if @params[:verbose]
-        n_samples, n_features = x.shape
-        sub_rng = @rng.dup
-        weight_vec = Numo::DFloat.zeros(n_features + 1)
-        factor_mat = Rumale::Utils.rand_normal([@params[:n_factors], n_features], sub_rng)
-        weight_optimizer = @params[:optimizer].dup
-        factor_optimizers = Array.new(@params[:n_factors]) { @params[:optimizer].dup }
-        # Start optimization.
-        @params[:max_iter].times do |t|
-          sample_ids = Array(0...n_samples)
-          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]
-            ex_sub_x = expand_feature(sub_x)
-            # Calculate gradients for loss function.
-            loss_grad = loss_gradient(sub_x, ex_sub_x, sub_y, factor_mat, weight_vec)
-            next if loss_grad.ne(0.0).count.zero?
-
-            # Update each parameter.
-            weight_vec = weight_optimizer.call(weight_vec, weight_gradient(loss_grad, ex_sub_x, weight_vec))
-            @params[:n_factors].times do |n|
-              factor_mat[n, true] = factor_optimizers[n].call(factor_mat[n, true],
-                                                              factor_gradient(loss_grad, sub_x, factor_mat[n, true]))
-            end
-          end
-          loss = loss_func(x, expand_feature(x), y, factor_mat, weight_vec)
-          puts "[#{class_name}] Loss after #{t + 1} epochs: #{loss}" if @params[:verbose]
-          break if loss < @params[:tol]
-        end
-        [factor_mat, *split_weight_vec_bias(weight_vec)]
-      end
-
-      def loss_func(_x, _expanded_x, _y, _factor, _weight)
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      def loss_gradient(_x, _expanded_x, _y, _factor, _weight)
-        raise NotImplementedError, "#{__method__} has to be implemented in #{self.class}."
-      end
-
-      def weight_gradient(loss_grad, data, weight)
-        (loss_grad.expand_dims(1) * data).mean(0) + @params[:reg_param_linear] * weight
-      end
-
-      def factor_gradient(loss_grad, data, factor)
-        (loss_grad.expand_dims(1) * (data * data.dot(factor).expand_dims(1) - factor * (data**2))).mean(0) +
-          @params[:reg_param_factor] * factor
-      end
-
-      def expand_feature(x)
-        Numo::NArray.hstack([x, Numo::DFloat.ones([x.shape[0], 1])])
-      end
-
-      def split_weight_vec_bias(weight_vec)
-        weights = weight_vec[0...-1].dup
-        bias = weight_vec[-1]
-        [weights, bias]
-      end
-    end
-  end
-end

data/lib/rumale/polynomial_model/factorization_machine_classifier.rb

@@ -1,220 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/classifier'
-require 'rumale/polynomial_model/base_factorization_machine'
-
-module Rumale
-  # This module consists of the classes that implement polynomial models.
-  module PolynomialModel
-    # FactorizationMachineClassifier is a class that implements Factorization Machine
-    # with stochastic gradient descent (SGD) optimization.
-    # For multiclass classification problem, it uses one-vs-the-rest strategy.
-    #
-    # @deprecated
-    #   FactorizationMachineClassifier will be deleted in version 0.20.0.
-    #   The Ruamle author recommends using the xlearn gem instead.
-    #
-    # @example
-    #   estimator =
-    #     Rumale::PolynomialModel::FactorizationMachineClassifier.new(
-    #      n_factors: 10, loss: 'hinge', reg_param_linear: 0.001, reg_param_factor: 0.001,
-    #      max_iter: 500, batch_size: 50, random_seed: 1)
-    #   estimator.fit(training_samples, traininig_labels)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Rendle, S., "Factorization Machines with libFM," ACM TIST, vol. 3 (3), pp. 57:1--57:22, 2012.
-    # - Rendle, S., "Factorization Machines," Proc. ICDM'10, pp. 995--1000, 2010.
-    class FactorizationMachineClassifier < BaseFactorizationMachine
-      include Base::Classifier
-
-      # Return the factor matrix for Factorization Machine.
-      # @return [Numo::DFloat] (shape: [n_classes, n_factors, n_features])
-      attr_reader :factor_mat
-
-      # Return the weight vector for Factorization Machine.
-      # @return [Numo::DFloat] (shape: [n_classes, n_features])
-      attr_reader :weight_vec
-
-      # Return the bias term for Factoriazation Machine.
-      # @return [Numo::DFloat] (shape: [n_classes])
-      attr_reader :bias_term
-
-      # Return the class labels.
-      # @return [Numo::Int32] (shape: [n_classes])
-      attr_reader :classes
-
-      # Return the random generator for random sampling.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new classifier with Factorization Machine.
-      #
-      # @param n_factors [Integer] The maximum number of iterations.
-      # @param loss [String] The loss function ('hinge' or 'logistic').
-      # @param reg_param_linear [Float] The regularization parameter for linear model.
-      # @param reg_param_factor [Float] The regularization parameter for factor matrix.
-      # @param max_iter [Integer] The maximum number of epochs that indicates
-      #   how many times the whole data is given to the training process.
-      # @param batch_size [Integer] The size of the mini batches.
-      # @param tol [Float] The tolerance of loss for terminating optimization.
-      # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
-      #   If nil is given, Nadam is used.
-      # @param n_jobs [Integer] The number of jobs for running the fit and predict methods in parallel.
-      #   If nil is given, the methods do not execute in parallel.
-      #   If zero or less is given, it becomes equal to the number of processors.
-      #   This parameter is ignored if the Parallel gem is not loaded.
-      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_factors: 2, loss: 'hinge', reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 200, batch_size: 50, tol: 1e-4,
-                     optimizer: nil, n_jobs: nil, verbose: false, random_seed: nil)
-        warn 'warning: FactorizationMachineClassifier is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
-                             n_factors: n_factors, max_iter: max_iter, batch_size: batch_size, tol: tol)
-        check_params_string(loss: loss)
-        check_params_boolean(verbose: verbose)
-        check_params_numeric_or_nil(n_jobs: n_jobs, random_seed: random_seed)
-        check_params_positive(n_factors: n_factors,
-                              reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
-                              max_iter: max_iter, batch_size: batch_size)
-        super
-        @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 [FactorizationMachineClassifier] The learned classifier itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-
-        @classes = Numo::Int32[*y.to_a.uniq.sort]
-
-        if multiclass_problem?
-          n_classes = @classes.size
-          n_features = x.shape[1]
-          @factor_mat = Numo::DFloat.zeros(n_classes, @params[:n_factors], n_features)
-          @weight_vec = Numo::DFloat.zeros(n_classes, n_features)
-          @bias_term = Numo::DFloat.zeros(n_classes)
-          if enable_parallel?
-            # :nocov:
-            models = parallel_map(n_classes) do |n|
-              bin_y = Numo::Int32.cast(y.eq(@classes[n])) * 2 - 1
-              partial_fit(x, bin_y)
-            end
-            # :nocov:
-            n_classes.times { |n| @factor_mat[n, true, true], @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
-              @factor_mat[n, true, true], @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
-          @factor_mat, @weight_vec, @bias_term = partial_fit(x, 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.
-      # @return [Numo::DFloat] (shape: [n_samples]) Confidence score per sample.
-      def decision_function(x)
-        x = check_convert_sample_array(x)
-        linear_term = @bias_term + x.dot(@weight_vec.transpose)
-        factor_term = if multiclass_problem?
-                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(1).transpose
-                      else
-                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)
-                      end
-        linear_term + factor_term
-      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)
-        x = check_convert_sample_array(x)
-
-        n_samples = x.shape[0]
-        predicted = if multiclass_problem?
-                      decision_values = decision_function(x)
-                      if enable_parallel?
-                        parallel_map(n_samples) { |n| @classes[decision_values[n, true].max_index] }
-                      else
-                        Array.new(n_samples) { |n| @classes[decision_values[n, true].max_index] }
-                      end
-                    else
-                      decision_values = decision_function(x).ge(0.0).to_a
-                      Array.new(n_samples) { |n| @classes[decision_values[n]] }
-                    end
-        Numo::Int32.asarray(predicted)
-      end
-
-      # Predict probability for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the probailities.
-      # @return [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted probability of each class per sample.
-      def predict_proba(x)
-        x = check_convert_sample_array(x)
-        proba = 1.0 / (Numo::NMath.exp(-decision_function(x)) + 1.0)
-        return (proba.transpose / proba.sum(axis: 1)).transpose.dup if multiclass_problem?
-
-        n_samples, = x.shape
-        probs = Numo::DFloat.zeros(n_samples, 2)
-        probs[true, 1] = proba
-        probs[true, 0] = 1.0 - proba
-        probs
-      end
-
-      private
-
-      def bin_decision_function(x, ex_x, factor, weight)
-        ex_x.dot(weight) + 0.5 * (factor.dot(x.transpose)**2 - (factor**2).dot(x.transpose**2)).sum(0)
-      end
-
-      def loss_func(x, ex_x, y, factor, weight)
-        z = bin_decision_function(x, ex_x, factor, weight)
-        if @params[:loss] == 'hinge'
-          z.class.maximum(0.0, 1 - y * z).sum.fdiv(y.shape[0])
-        else
-          Numo::NMath.log(1 + Numo::NMath.exp(-y * z)).sum.fdiv(y.shape[0])
-        end
-      end
-
-      def hinge_loss_gradient(x, ex_x, y, factor, weight)
-        evaluated = y * bin_decision_function(x, ex_x, factor, weight)
-        gradient = Numo::DFloat.zeros(evaluated.size)
-        gradient[evaluated < 1.0] = -y[evaluated < 1.0]
-        gradient
-      end
-
-      def logistic_loss_gradient(x, ex_x, y, factor, weight)
-        evaluated = y * bin_decision_function(x, ex_x, factor, weight)
-        sigmoid_func = 1.0 / (Numo::NMath.exp(-evaluated) + 1.0)
-        (sigmoid_func - 1.0) * y
-      end
-
-      def loss_gradient(x, ex_x, y, factor, weight)
-        if @params[:loss] == 'hinge'
-          hinge_loss_gradient(x, ex_x, y, factor, weight)
-        else
-          logistic_loss_gradient(x, ex_x, y, factor, weight)
-        end
-      end
-
-      def multiclass_problem?
-        @classes.size > 2
-      end
-    end
-  end
-end

data/lib/rumale/polynomial_model/factorization_machine_regressor.rb

@@ -1,134 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/regressor'
-require 'rumale/polynomial_model/base_factorization_machine'
-
-module Rumale
-  module PolynomialModel
-    # FactorizationMachineRegressor is a class that implements Factorization Machine
-    # with stochastic gradient descent (SGD) optimization.
-    #
-    # @deprecated
-    #   FactorizationMachineRegressor will be deleted in version 0.20.0.
-    #   The Ruamle author recommends using the xlearn gem instead.
-    #
-    # @example
-    #   estimator =
-    #     Rumale::PolynomialModel::FactorizationMachineRegressor.new(
-    #      n_factors: 10, reg_param_linear: 0.1, reg_param_factor: 0.1,
-    #      max_iter: 500, batch_size: 50, random_seed: 1)
-    #   estimator.fit(training_samples, traininig_values)
-    #   results = estimator.predict(testing_samples)
-    #
-    # *Reference*
-    # - Rendle, S., "Factorization Machines with libFM," ACM TIST, vol. 3 (3), pp. 57:1--57:22, 2012.
-    # - Rendle, S., "Factorization Machines," Proc. ICDM'10, pp. 995--1000, 2010.
-    class FactorizationMachineRegressor < BaseFactorizationMachine
-      include Base::Regressor
-
-      # Return the factor matrix for Factorization Machine.
-      # @return [Numo::DFloat] (shape: [n_outputs, n_factors, n_features])
-      attr_reader :factor_mat
-
-      # Return the weight vector for Factorization Machine.
-      # @return [Numo::DFloat] (shape: [n_outputs, n_features])
-      attr_reader :weight_vec
-
-      # Return the bias term for Factoriazation Machine.
-      # @return [Numo::DFloat] (shape: [n_outputs])
-      attr_reader :bias_term
-
-      # Return the random generator for random sampling.
-      # @return [Random]
-      attr_reader :rng
-
-      # Create a new regressor with Factorization Machine.
-      #
-      # @param n_factors [Integer] The maximum number of iterations.
-      # @param reg_param_linear [Float] The regularization parameter for linear model.
-      # @param reg_param_factor [Float] The regularization parameter for factor matrix.
-      # @param max_iter [Integer] The maximum number of epochs that indicates
-      #   how many times the whole data is given to the training process.
-      # @param batch_size [Integer] The size of the mini batches.
-      # @param tol [Float] The tolerance of loss for terminating optimization.
-      # @param optimizer [Optimizer] The optimizer to calculate adaptive learning rate.
-      #   If nil is given, Nadam is used.
-      # @param n_jobs [Integer] The number of jobs for running the fit method in parallel.
-      #   If nil is given, the method does not execute in parallel.
-      #   If zero or less is given, it becomes equal to the number of processors.
-      #   This parameter is ignored if the Parallel gem is not loaded.
-      # @param verbose [Boolean] The flag indicating whether to output loss during iteration.
-      # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_factors: 2, reg_param_linear: 1.0, reg_param_factor: 1.0,
-                     max_iter: 200, batch_size: 50, tol: 1e-4,
-                     optimizer: nil, n_jobs: nil, verbose: false, random_seed: nil)
-        warn 'warning: FactorizationMachineClassifier is deprecated. This class will be deleted in version 0.20.0.'
-        check_params_numeric(reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
-                             n_factors: n_factors, max_iter: max_iter, batch_size: batch_size, tol: tol)
-        check_params_boolean(verbose: verbose)
-        check_params_numeric_or_nil(n_jobs: n_jobs, random_seed: random_seed)
-        check_params_positive(n_factors: n_factors, reg_param_linear: reg_param_linear, reg_param_factor: reg_param_factor,
-                              max_iter: max_iter, batch_size: batch_size)
-        keywd_args = method(:initialize).parameters.map { |_t, arg| [arg, binding.local_variable_get(arg)] }.to_h.merge(loss: nil)
-        super(**keywd_args)
-      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, n_outputs]) The target values to be used for fitting the model.
-      # @return [FactorizationMachineRegressor] The learned regressor itself.
-      def fit(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_tvalue_array(y)
-        check_sample_tvalue_size(x, y)
-
-        n_outputs = y.shape[1].nil? ? 1 : y.shape[1]
-        _n_samples, n_features = x.shape
-
-        if n_outputs > 1
-          @factor_mat = Numo::DFloat.zeros(n_outputs, @params[:n_factors], n_features)
-          @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]) }
-            n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = models[n] }
-          else
-            n_outputs.times { |n| @factor_mat[n, true, true], @weight_vec[n, true], @bias_term[n] = partial_fit(x, y[true, n]) }
-          end
-        else
-          @factor_mat, @weight_vec, @bias_term = partial_fit(x, y)
-        end
-
-        self
-      end
-
-      # Predict values for samples.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to predict the values.
-      # @return [Numo::DFloat] (shape: [n_samples, n_outputs]) Predicted values per sample.
-      def predict(x)
-        x = check_convert_sample_array(x)
-        linear_term = @bias_term + x.dot(@weight_vec.transpose)
-        factor_term = if @weight_vec.shape[1].nil?
-                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(0)
-                      else
-                        0.5 * (@factor_mat.dot(x.transpose)**2 - (@factor_mat**2).dot(x.transpose**2)).sum(1).transpose
-                      end
-        linear_term + factor_term
-      end
-
-      private
-
-      def loss_func(x, ex_x, y, factor, weight)
-        z = ex_x.dot(weight) + 0.5 * (factor.dot(x.transpose)**2 - (factor**2).dot(x.transpose**2)).sum(0)
-        ((z - y)**2).sum.fdiv(y.shape[0])
-      end
-
-      def loss_gradient(x, ex_x, y, factor, weight)
-        z = ex_x.dot(weight) + 0.5 * (factor.dot(x.transpose)**2 - (factor**2).dot(x.transpose**2)).sum(0)
-        2.0 * (z - y)
-      end
-    end
-  end
-end