rumale 0.18.6 → 0.19.3

data/lib/rumale/polynomial_model/factorization_machine_classifier.rb

@@ -10,6 +10,10 @@ module Rumale
     # 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(
@@ -65,6 +69,7 @@ module Rumale
       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)

data/lib/rumale/polynomial_model/factorization_machine_regressor.rb

@@ -8,6 +8,10 @@ module Rumale
     # 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(
@@ -58,6 +62,7 @@ module Rumale
       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)

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/preprocessing/one_hot_encoder.rb

@@ -51,6 +51,7 @@ module Rumale
       def fit(x, _y = nil)
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         @n_values = x.max(0) + 1
         @feature_indices = Numo::Int32.hstack([[0], @n_values]).cumsum
         @active_features = encode(x, @feature_indices).sum(0).ne(0).where
@@ -67,6 +68,7 @@ module Rumale
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         fit(x).transform(x)
       end
 
@@ -77,6 +79,7 @@ module Rumale
       def transform(x)
         x = Numo::Int32.cast(x) unless x.is_a?(Numo::Int32)
         raise ArgumentError, 'Expected the input samples only consists of non-negative integer values.' if x.lt(0).any?
+
         codes = encode(x, @feature_indices)
         codes[true, @active_features].dup
       end

data/lib/rumale/preprocessing/ordinal_encoder.rb

@@ -51,6 +51,7 @@ module Rumale
       def fit(x, _y = nil)
         raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
         n_features = x.shape[1]
         @categories = Array.new(n_features) { |n| x[true, n].to_a.uniq.sort }
         self
@@ -65,6 +66,7 @@ module Rumale
       def fit_transform(x, _y = nil)
         raise TypeError, 'Expect class of sample matrix to be Numo::NArray' unless x.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.shape.size == 2
+
         fit(x).transform(x)
       end
 

data/lib/rumale/preprocessing/polynomial_features.rb

@@ -41,6 +41,7 @@ module Rumale
       def initialize(degree: 2)
         check_params_numeric(degree: degree)
         raise ArgumentError, 'Expect the value of degree parameter greater than or eqaul to 1.' if degree < 1
+
         @params = {}
         @params[:degree] = degree
         @n_output_features = nil

data/lib/rumale/probabilistic_output.rb

@@ -47,6 +47,7 @@ module Rumale
           hess_mat = hessian_matrix(probs, df, sigma)
           break if grad_vec.abs.lt(1e-5).count == 2
           break if (old_grad_vec - grad_vec).abs.sum < 1e-5
+
           old_grad_vec = grad_vec
           # Calculate Newton directions.
           dirs_vec = directions(grad_vec, hess_mat)
@@ -58,6 +59,7 @@ module Rumale
             new_beta = beta + stepsize * dirs_vec[1]
             new_err = error_function(target_probs, df, new_alpha, new_beta)
             next unless new_err < err + 0.0001 * stepsize * grad_dir
+
             alpha = new_alpha
             beta = new_beta
             err = new_err

data/lib/rumale/tree/base_decision_tree.rb

@@ -53,6 +53,7 @@ module Rumale
         return node.leaf_id if node.leaf
         return apply_at_node(node.left, sample) if node.right.nil?
         return apply_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           apply_at_node(node.left, sample)
         else
@@ -138,6 +139,7 @@ module Rumale
       def eval_importance_at_node(node)
         return nil if node.leaf
         return nil if node.left.nil? || node.right.nil?
+
         gain = node.n_samples * node.impurity -
                node.left.n_samples * node.left.impurity -
                node.right.n_samples * node.right.impurity

data/lib/rumale/tree/decision_tree_classifier.rb

@@ -110,6 +110,7 @@ module Rumale
         return node.probs if node.leaf
         return predict_proba_at_node(node.left, sample) if node.right.nil?
         return predict_proba_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           predict_proba_at_node(node.left, sample)
         else

data/lib/rumale/tree/gradient_tree_regressor.rb

@@ -123,6 +123,7 @@ module Rumale
         return node.leaf_id if node.leaf
         return apply_at_node(node.left, sample) if node.right.nil?
         return apply_at_node(node.right, sample) if node.left.nil?
+
         if sample[node.feature_id] <= node.threshold
           apply_at_node(node.left, sample)
         else

data/lib/rumale/utils.rb

@@ -13,6 +13,7 @@ module Rumale
         chosen = 0
         probs.each_with_index do |p, idx|
           break (chosen = idx) if target <= p
+
           target -= p
         end
         chosen

data/lib/rumale/validation.rb

@@ -9,6 +9,7 @@ module Rumale
     def check_convert_sample_array(x)
       x = Numo::DFloat.cast(x) unless x.is_a?(Numo::DFloat)
       raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 2
+
       x
     end
 
@@ -16,6 +17,7 @@ module Rumale
     def check_convert_label_array(y)
       y = Numo::Int32.cast(y) unless y.is_a?(Numo::Int32)
       raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
+
       y
     end
 
@@ -29,6 +31,7 @@ module Rumale
     def check_sample_array(x)
       raise TypeError, 'Expect class of sample matrix to be Numo::DFloat' unless x.is_a?(Numo::DFloat)
       raise ArgumentError, 'Expect sample matrix to be 2-D array' unless x.ndim == 2
+
       nil
     end
 
@@ -36,24 +39,28 @@ module Rumale
     def check_label_array(y)
       raise TypeError, 'Expect class of label vector to be Numo::Int32' unless y.is_a?(Numo::Int32)
       raise ArgumentError, 'Expect label vector to be 1-D arrray' unless y.ndim == 1
+
       nil
     end
 
     # @!visibility private
     def check_tvalue_array(y)
       raise TypeError, 'Expect class of target value vector to be Numo::DFloat' unless y.is_a?(Numo::DFloat)
+
       nil
     end
 
     # @!visibility private
     def check_sample_label_size(x, y)
       raise ArgumentError, 'Expect to have the same number of samples for sample matrix and label vector' unless x.shape[0] == y.shape[0]
+
       nil
     end
 
     # @!visibility private
     def check_sample_tvalue_size(x, y)
       raise ArgumentError, 'Expect to have the same number of samples for sample matrix and target value vector' unless x.shape[0] == y.shape[0]
+
       nil
     end
 

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.18.6'
+  VERSION = '0.19.3'
 end

data/rumale.gemspec

@@ -16,7 +16,7 @@ Gem::Specification.new do |spec|
     Rumale is a machine learning library in Ruby.
     Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
     Rumale supports Support Vector Machine,
-    Logistic Regression, Ridge, Lasso, Factorization Machine,
+    Logistic Regression, Ridge, Lasso,
     Multi-layer Perceptron,
     Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
     K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
@@ -45,6 +45,4 @@ Gem::Specification.new do |spec|
   }
 
   spec.add_runtime_dependency 'numo-narray', '>= 0.9.1'
-  spec.add_runtime_dependency 'mopti', '>= 0.1.0'
-  spec.add_runtime_dependency 'mmh3', '>= 0.1.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rumale
 version: !ruby/object:Gem::Version
-  version: 0.18.6
+  version: 0.19.3
 platform: ruby
 authors:
 - yoshoku
-autorequire: 
+autorequire:
 bindir: exe
 cert_chain: []
-date: 2020-05-02 00:00:00.000000000 Z
+date: 2020-07-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: numo-narray
@@ -24,39 +24,11 @@ dependencies:
     - - ">="
       - !ruby/object:Gem::Version
         version: 0.9.1
-- !ruby/object:Gem::Dependency
-  name: mopti
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-- !ruby/object:Gem::Dependency
-  name: mmh3
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - ">="
-      - !ruby/object:Gem::Version
-        version: 0.1.0
 description: |
   Rumale is a machine learning library in Ruby.
   Rumale provides machine learning algorithms with interfaces similar to Scikit-Learn in Python.
   Rumale supports Support Vector Machine,
-  Logistic Regression, Ridge, Lasso, Factorization Machine,
+  Logistic Regression, Ridge, Lasso,
   Multi-layer Perceptron,
   Naive Bayes, Decision Tree, Gradient Tree Boosting, Random Forest,
   K-Means, Gaussian Mixture Model, DBSCAN, Spectral Clustering,
@@ -100,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
@@ -140,6 +113,7 @@ 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
@@ -193,10 +167,13 @@ files:
 - 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
@@ -224,7 +201,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
@@ -240,7 +217,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.