rumale 0.19.0 → 0.20.1

data/lib/rumale/multiclass/one_vs_rest_classifier.rb

@@ -1,7 +1,7 @@
 # frozen_string_literal: true
 
-require 'rumale/base/base_estimator.rb'
-require 'rumale/base/classifier.rb'
+require 'rumale/base/base_estimator'
+require 'rumale/base/classifier'
 
 module Rumale
   # This module consists of the classes that implement multi-class classification strategy.

data/lib/rumale/nearest_neighbors/vp_tree.rb

@@ -30,7 +30,7 @@ module Rumale
         @params = {}
         @params[:min_samples_leaf] = min_samples_leaf
         @data = x
-        @tree = build_tree(Numo::Int32.cast([*0...@data.shape[0]]))
+        @tree = build_tree(Numo::Int32.cast(Array(0...@data.shape[0])))
       end
 
       # Search k-nearest neighbors of given query point.

data/lib/rumale/neural_network/adam.rb

@@ -32,7 +32,7 @@ module Rumale
         end
 
         # @!visibility private
-        # Calculate the updated weight with Nadam adaptive learning rate.
+        # Calculate the updated weight with Adam 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.

data/lib/rumale/neural_network/base_mlp.rb

@@ -222,7 +222,7 @@ module Rumale
         n_samples = x.shape[0]
 
         @params[:max_iter].times do |t|
-          sample_ids = [*0...n_samples]
+          sample_ids = Array(0...n_samples)
           sample_ids.shuffle!(random: srng)
           until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
             # random sampling

data/lib/rumale/preprocessing/binarizer.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Binarize samples according to a threshold
+    #
+    # @example
+    #   binarizer = Rumale::Preprocessing::Binarizer.new
+    #   x = Numo::DFloat[[-1.2, 3.2], [2.4, -0.5], [4.5, 0.8]]
+    #   b = binarizer.transform(x)
+    #   p b
+    #
+    #   # Numo::DFloat#shape=[3, 2]
+    #   # [[0, 1],
+    #   #  [1, 0],
+    #   #  [1, 1]]
+    class Binarizer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Create a new transformer for binarization.
+      # @param threshold [Float] The threshold value for binarization.
+      def initialize(threshold: 0.0)
+        check_params_numeric(threshold: threshold)
+        @params = { threshold: threshold }
+      end
+
+      # This method does nothing and returns the object itself.
+      # For compatibility with other transformer, this method exists.
+      #
+      # @overload fit() -> Binarizer
+      #
+      # @return [Binarizer]
+      def fit(_x = nil, _y = nil)
+        self
+      end
+
+      # Binarize each sample.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
+      # @return [Numo::DFloat] The binarized samples.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        x.class.cast(x.gt(@params[:threshold]))
+      end
+
+      # The output of this method is the same as that of the transform method.
+      # For compatibility with other transformer, this method exists.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be binarized.
+      # @return [Numo::DFloat] The binarized samples.
+      def fit_transform(x, _y = nil)
+        fit(x).transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/l1_normalizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Normalize samples to unit L1-norm.
+    #
+    # @example
+    #   normalizer = Rumale::Preprocessing::L1Normalizer.new
+    #   new_samples = normalizer.fit_transform(samples)
+    class L1Normalizer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the vector consists of L1-norm for each sample.
+      # @return [Numo::DFloat] (shape: [n_samples])
+      attr_reader :norm_vec # :nodoc:
+
+      # Create a new normalizer for normaliing to L1-norm.
+      def initialize
+        @params = {}
+        @norm_vec = nil
+      end
+
+      # Calculate L1-norms of each sample.
+      #
+      # @overload fit(x) -> L1Normalizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [L1Normalizer]
+      def fit(x, _y = nil)
+        x = check_convert_sample_array(x)
+        @norm_vec = x.abs.sum(1)
+        @norm_vec[@norm_vec.eq(0)] = 1
+        self
+      end
+
+      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def fit_transform(x, _y = nil)
+        x = check_convert_sample_array(x)
+        fit(x)
+        x / @norm_vec.expand_dims(1)
+      end
+
+      # Calculate L1-norms of each sample, and then normalize samples to L1-norm.
+      # This method calls the fit_transform method. This method exists for the Pipeline class.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate L1-norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def transform(x)
+        fit_transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/preprocessing/l2_normalizer.rb

@@ -34,6 +34,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         @norm_vec = Numo::NMath.sqrt((x**2).sum(1))
+        @norm_vec[@norm_vec.eq(0)] = 1
         self
       end
 
@@ -46,7 +47,7 @@ module Rumale
       def fit_transform(x, _y = nil)
         x = check_convert_sample_array(x)
         fit(x)
-        x / @norm_vec.tile(x.shape[1], 1).transpose
+        x / @norm_vec.expand_dims(1)
       end
 
       # Calculate L2-norms of each sample, and then normalize samples to unit L2-norm.

data/lib/rumale/preprocessing/max_normalizer.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+
+module Rumale
+  module Preprocessing
+    # Normalize samples with the maximum of the absolute values.
+    #
+    # @example
+    #   normalizer = Rumale::Preprocessing::MaxNormalizer.new
+    #   new_samples = normalizer.fit_transform(samples)
+    class MaxNormalizer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the vector consists of the maximum norm for each sample.
+      # @return [Numo::DFloat] (shape: [n_samples])
+      attr_reader :norm_vec # :nodoc:
+
+      # Create a new normalizer for normaliing to max-norm.
+      def initialize
+        @params = {}
+        @norm_vec = nil
+      end
+
+      # Calculate the maximum norms of each sample.
+      #
+      # @overload fit(x) -> MaxNormalizer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the maximum norms.
+      # @return [MaxNormalizer]
+      def fit(x, _y = nil)
+        x = check_convert_sample_array(x)
+        @norm_vec = x.abs.max(1)
+        @norm_vec[@norm_vec.eq(0)] = 1
+        self
+      end
+
+      # Calculate the maximums norm of each sample, and then normalize samples with the norms.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def fit_transform(x, _y = nil)
+        x = check_convert_sample_array(x)
+        fit(x)
+        x / @norm_vec.expand_dims(1)
+      end
+
+      # Calculate the maximum norms of each sample, and then normalize samples with the norms.
+      # This method calls the fit_transform method. This method exists for the Pipeline class.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate maximum norms.
+      # @return [Numo::DFloat] The normalized samples.
+      def transform(x)
+        fit_transform(x)
+      end
+    end
+  end
+end

data/lib/rumale/probabilistic_output.rb

@@ -98,7 +98,7 @@ module Rumale
 
       def hessian_matrix(probs, df, sigma)
         sub = probs * (1 - probs)
-        h11 = (df * df * sub).sum + sigma
+        h11 = (df**2 * sub).sum + sigma
         h22 = sub.sum + sigma
         h21 = (df * sub).sum
         Numo::DFloat[[h11, h21], [h21, h22]]

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.0'
+  VERSION = '0.20.1'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.19.0
+  version: 0.20.1
 platform: ruby
 authors:
 - yoshoku
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-05-23 00:00:00.000000000 Z
+date: 2020-08-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -72,6 +72,7 @@ files:
 - lib/rumale/clustering/hdbscan.rb
 - lib/rumale/clustering/k_means.rb
 - lib/rumale/clustering/k_medoids.rb
+- lib/rumale/clustering/mini_batch_k_means.rb
 - lib/rumale/clustering/power_iteration.rb
 - lib/rumale/clustering/single_linkage.rb
 - lib/rumale/clustering/snn.rb
@@ -112,13 +113,13 @@ files:
 - lib/rumale/evaluation_measure/silhouette_score.rb
 - lib/rumale/feature_extraction/feature_hasher.rb
 - lib/rumale/feature_extraction/hash_vectorizer.rb
+- lib/rumale/feature_extraction/tfidf_transformer.rb
 - lib/rumale/kernel_approximation/nystroem.rb
 - lib/rumale/kernel_approximation/rbf.rb
 - lib/rumale/kernel_machine/kernel_fda.rb
 - 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
@@ -134,6 +135,8 @@ files:
 - lib/rumale/model_selection/cross_validation.rb
 - lib/rumale/model_selection/function.rb
 - lib/rumale/model_selection/grid_search_cv.rb
+- lib/rumale/model_selection/group_k_fold.rb
+- lib/rumale/model_selection/group_shuffle_split.rb
 - lib/rumale/model_selection/k_fold.rb
 - lib/rumale/model_selection/shuffle_split.rb
 - lib/rumale/model_selection/stratified_k_fold.rb
@@ -152,23 +155,17 @@ 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
 - lib/rumale/preprocessing/l2_normalizer.rb
 - lib/rumale/preprocessing/label_binarizer.rb
 - lib/rumale/preprocessing/label_encoder.rb
 - lib/rumale/preprocessing/max_abs_scaler.rb
+- lib/rumale/preprocessing/max_normalizer.rb
 - lib/rumale/preprocessing/min_max_scaler.rb
 - lib/rumale/preprocessing/one_hot_encoder.rb
 - lib/rumale/preprocessing/ordinal_encoder.rb
@@ -196,7 +193,7 @@ metadata:
   source_code_uri: https://github.com/yoshoku/rumale
   documentation_uri: https://yoshoku.github.io/rumale/doc/
   bug_tracker_uri: https://github.com/yoshoku/rumale/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -212,7 +209,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubygems_version: 3.1.2
-signing_key: 
+signing_key:
 specification_version: 4
 summary: Rumale is a machine learning library in Ruby. Rumale provides machine learning
   algorithms with interfaces similar to Scikit-Learn in Python.

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 = [*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