rumale 0.18.7 → 0.20.0

data/lib/rumale/dataset.rb

@@ -81,7 +81,7 @@ module Rumale
         y = Numo::Int32.hstack([Numo::Int32.zeros(n_samples_out), Numo::Int32.ones(n_samples_in)])
         # shuffle data indices.
         if shuffle
-          rand_ids = [*0...n_samples].shuffle(random: rng.dup)
+          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
           x = x[rand_ids, true].dup
           y = y[rand_ids].dup
         end
@@ -118,7 +118,7 @@ module Rumale
         y = Numo::Int32.hstack([Numo::Int32.zeros(n_samples_out), Numo::Int32.ones(n_samples_in)])
         # shuffle data indices.
         if shuffle
-          rand_ids = [*0...n_samples].shuffle(random: rng.dup)
+          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
           x = x[rand_ids, true].dup
           y = y[rand_ids].dup
         end
@@ -173,7 +173,7 @@ module Rumale
         end
         # shuffle data.
         if shuffle
-          rand_ids = [*0...n_samples].shuffle(random: rng.dup)
+          rand_ids = Array(0...n_samples).shuffle(random: rng.dup)
           x = x[rand_ids, true].dup
           y = y[rand_ids].dup
         end

data/lib/rumale/decomposition/pca.rb

@@ -9,7 +9,7 @@ module Rumale
     # PCA is a class that implements Principal Component Analysis.
     #
     # @example
-    #   decomposer = Rumale::Decomposition::PCA.new(n_components: 2)
+    #   decomposer = Rumale::Decomposition::PCA.new(n_components: 2, solver: 'fpt')
     #   representaion = decomposer.fit_transform(samples)
     #
     #   # If Numo::Linalg is installed, you can specify 'evd' for the solver option.
@@ -17,6 +17,11 @@ module Rumale
     #   decomposer = Rumale::Decomposition::PCA.new(n_components: 2, solver: 'evd')
     #   representaion = decomposer.fit_transform(samples)
     #
+    #   # If Numo::Linalg is loaded and the solver option is not given,
+    #   # the solver option is choosen 'evd' automatically.
+    #   decomposer = Rumale::Decomposition::PCA.new(n_components: 2)
+    #   representaion = decomposer.fit_transform(samples)
+    #
     # *Reference*
     # - Sharma, A., and Paliwal, K K., "Fast principal component analysis using fixed-point algorithm," Pattern Recognition Letters, 28, pp. 1151--1155, 2007.
     class PCA
@@ -38,18 +43,24 @@ module Rumale
       # Create a new transformer with PCA.
       #
       # @param n_components [Integer] The number of principal components.
-      # @param solver [String] The algorithm for the optimization ('fpt' or 'evd').
-      #   'fpt' uses the fixed-point algorithm. 'evd' performs eigen value decomposition of the covariance matrix of samples.
+      # @param solver [String] The algorithm for the optimization ('auto', 'fpt' or 'evd').
+      #   'auto' chooses the 'evd' solver if Numo::Linalg is loaded. Otherwise, it chooses the 'fpt' solver.
+      #   'fpt' uses the fixed-point algorithm.
+      #   'evd' performs eigen value decomposition of the covariance matrix of samples.
       # @param max_iter [Integer] The maximum number of iterations. If solver = 'evd', this parameter is ignored.
       # @param tol [Float] The tolerance of termination criterion. If solver = 'evd', this parameter is ignored.
       # @param random_seed [Integer] The seed value using to initialize the random generator.
-      def initialize(n_components: 2, solver: 'fpt', max_iter: 100, tol: 1.0e-4, random_seed: nil)
+      def initialize(n_components: 2, solver: 'auto', max_iter: 100, tol: 1.0e-4, random_seed: nil)
         check_params_numeric(n_components: n_components, max_iter: max_iter, tol: tol)
         check_params_string(solver: solver)
         check_params_numeric_or_nil(random_seed: random_seed)
         check_params_positive(n_components: n_components, max_iter: max_iter, tol: tol)
         @params = {}
-        @params[:solver] = solver != 'evd' ? 'fpt' : 'evd'
+        @params[:solver] = if solver == 'auto'
+                             load_linalg? ? 'evd' : 'fpt'
+                           else
+                             solver != 'evd' ? 'fpt' : 'evd'
+                           end
         @params[:n_components] = n_components
         @params[:max_iter] = max_iter
         @params[:tol] = tol
@@ -128,6 +139,13 @@ module Rumale
 
       private
 
+      def load_linalg?
+        return false if defined?(Numo::Linalg).nil?
+        return false if Numo::Linalg::VERSION < '0.1.4'
+
+        true
+      end
+
       def orthogonalize(pcvec)
         unless @components.nil?
           delta = @components.dot(pcvec) * @components.transpose

data/lib/rumale/feature_extraction/feature_hasher.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'mmh3'
 require 'rumale/base/base_estimator'
 require 'rumale/base/transformer'
 
@@ -11,11 +10,15 @@ module Rumale
     # This encoder employs signed 32-bit Murmurhash3 as the hash function.
     #
     # @example
+    #   require 'mmh3'
+    #   require 'rumale'
+    #
     #   encoder = Rumale::FeatureExtraction::FeatureHasher.new(n_features: 10)
     #   x = encoder.transform([
     #     { dog: 1, cat: 2, elephant: 4 },
     #     { dog: 2, run: 5 }
     #   ])
+    #
     #   # > pp x
     #   # Numo::DFloat#shape=[2,10]
     #   # [[0, 0, -4, -1, 0, 0, 0, 0, 0, 2],
@@ -62,6 +65,8 @@ module Rumale
       # @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
       # @return [Numo::DFloat] (shape: [n_samples, n_features]) The encoded sample array.
       def transform(x)
+        raise 'FeatureHasher#transform requires Mmh3 but that is not loaded.' unless enable_mmh3?
+
         x = [x] unless x.is_a?(Array)
         n_samples = x.size
 
@@ -85,6 +90,14 @@ module Rumale
 
       private
 
+      def enable_mmh3?
+        if defined?(Mmh3).nil?
+          warn('FeatureHasher#transform requires Mmh3 but that is not loaded. You should intall and load mmh3 gem in advance.')
+          return false
+        end
+        true
+      end
+
       def n_features
         @params[:n_features]
       end

data/lib/rumale/feature_extraction/tfidf_transformer.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require 'rumale/base/base_estimator'
+require 'rumale/base/transformer'
+require 'rumale/preprocessing/l1_normalizer'
+require 'rumale/preprocessing/l2_normalizer'
+
+module Rumale
+  module FeatureExtraction
+    # Transform sample matrix with term frequecy (tf) to a normalized tf-idf (inverse document frequency) reprensentation.
+    #
+    # @example
+    #   encoder = Rumale::FeatureExtraction::HashVectorizer.new
+    #   x = encoder.fit_transform([
+    #     { foo: 1, bar: 2 },
+    #     { foo: 3, baz: 1 }
+    #   ])
+    #
+    #   # > pp x
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[2, 0, 1],
+    #   #  [0, 1, 3]]
+    #
+    #   transformer = Rumale::FeatureExtraction::TfidfTransformer.new
+    #   x_tfidf = transformer.fit_transform(x)
+    #
+    #   # > pp x_tfidf
+    #   # Numo::DFloat#shape=[2,3]
+    #   # [[0.959056, 0, 0.283217],
+    #   #  [0, 0.491506, 0.870874]]
+    #
+    # *Reference*
+    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
+    class TfidfTransformer
+      include Base::BaseEstimator
+      include Base::Transformer
+
+      # Return the vector consists of inverse document frequency.
+      # @return [Numo::DFloat] (shape: [n_features])
+      attr_reader :idf
+
+      # Create a new transfomer for converting tf vectors to tf-idf vectors.
+      #
+      # @param norm [String] The normalization method to be used ('l1', 'l2' and 'none').
+      # @param use_idf [Boolean] The flag indicating whether to use inverse document frequency weighting.
+      # @param smooth_idf [Boolean] The flag indicating whether to apply idf smoothing by log((n_samples + 1) / (df + 1)) + 1.
+      # @param sublinear_tf [Boolean] The flag indicating whether to perform subliner tf scaling by 1 + log(tf).
+      def initialize(norm: 'l2', use_idf: true, smooth_idf: false, sublinear_tf: false)
+        check_params_string(norm: norm)
+        check_params_boolean(use_idf: use_idf, smooth_idf: smooth_idf, sublinear_tf: sublinear_tf)
+        @params = {}
+        @params[:norm] = norm
+        @params[:use_idf] = use_idf
+        @params[:smooth_idf] = smooth_idf
+        @params[:sublinear_tf] = sublinear_tf
+        @idf = nil
+      end
+
+      # Calculate the inverse document frequency for weighting.
+      #
+      # @overload fit(x) -> TfidfTransformer
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate the idf values.
+      # @return [TfidfTransformer]
+      def fit(x, _y = nil)
+        return self unless @params[:use_idf]
+
+        x = check_convert_sample_array(x)
+
+        n_samples = x.shape[0]
+        df = x.class.cast(x.gt(0.0).count(0))
+
+        if @params[:smooth_idf]
+          df += 1
+          n_samples += 1
+        end
+
+        @idf = Numo::NMath.log(n_samples / df) + 1
+
+        self
+      end
+
+      # Calculate the idf values, and then transfrom samples to the tf-idf representation.
+      #
+      # @overload fit_transform(x) -> Numo::DFloat
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to calculate idf and be transformed to tf-idf representation.
+      # @return [Numo::DFloat] The transformed samples.
+      def fit_transform(x, _y = nil)
+        fit(x).transform(x)
+      end
+
+      # Perform transforming the given samples to the tf-idf representation.
+      #
+      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be transformed.
+      # @return [Numo::DFloat] The transformed samples.
+      def transform(x)
+        x = check_convert_sample_array(x)
+        z = x.dup
+
+        z[z.ne(0)] = Numo::NMath.log(z[z.ne(0)]) + 1 if @params[:sublinear_tf]
+        z *= @idf if @params[:use_idf]
+        case @params[:norm]
+        when 'l2'
+          z = Rumale::Preprocessing::L2Normalizer.new.fit_transform(z)
+        when 'l1'
+          z = Rumale::Preprocessing::L1Normalizer.new.fit_transform(z)
+        end
+        z
+      end
+    end
+  end
+end

data/lib/rumale/kernel_approximation/nystroem.rb

@@ -69,7 +69,7 @@ module Rumale
         n_components = [1, [@params[:n_components], n_samples].min].max
 
         # random sampling.
-        @component_indices = Numo::Int32.cast([*0...n_samples].shuffle(random: sub_rng)[0...n_components])
+        @component_indices = Numo::Int32.cast(Array(0...n_samples).shuffle(random: sub_rng)[0...n_components])
         @components = x[@component_indices, true]
 
         # calculate normalizing factor.

data/lib/rumale/kernel_machine/kernel_svc.rb

@@ -172,7 +172,7 @@ module Rumale
         # Start optimization.
         @params[:max_iter].times do |t|
           # random sampling
-          rand_ids = [*0...n_training_samples].shuffle(random: sub_rng) if rand_ids.empty?
+          rand_ids = Array(0...n_training_samples).shuffle(random: sub_rng) if rand_ids.empty?
           target_id = rand_ids.shift
           # update the weight vector
           func = (weight_vec * bin_y).dot(x[target_id, true].transpose).to_f

data/lib/rumale/linear_model/base_sgd.rb

@@ -209,7 +209,7 @@ module Rumale
         l1_penalty = LinearModel::Penalty::L1Penalty.new(reg_param: l1_reg_param) if apply_l1_penalty?
         # Optimization.
         @params[:max_iter].times do |t|
-          sample_ids = [*0...n_samples]
+          sample_ids = Array(0...n_samples)
           sample_ids.shuffle!(random: sub_rng)
           until (subset_ids = sample_ids.shift(@params[:batch_size])).empty?
             # sampling

data/lib/rumale/metric_learning/neighbourhood_component_analysis.rb

@@ -2,13 +2,15 @@
 
 require 'rumale/base/base_estimator'
 require 'rumale/base/transformer'
-require 'mopti/scaled_conjugate_gradient'
 
 module Rumale
   module MetricLearning
     # NeighbourhoodComponentAnalysis is a class that implements Neighbourhood Component Analysis.
     #
     # @example
+    #   require 'mopti'
+    #   require 'rumale'
+    #
     #   transformer = Rumale::MetricLearning::NeighbourhoodComponentAnalysis.new
     #   transformer.fit(training_samples, traininig_labels)
     #   low_samples = transformer.transform(testing_samples)
@@ -63,6 +65,8 @@ module Rumale
       # @param y [Numo::Int32] (shape: [n_samples]) The labels to be used for fitting the model.
       # @return [NeighbourhoodComponentAnalysis] The learned classifier itself.
       def fit(x, y)
+        raise 'NeighbourhoodComponentAnalysis#fit requires Mopti but that is not loaded.' unless enable_mopti?
+
         x = check_convert_sample_array(x)
         y = check_convert_label_array(y)
         check_sample_label_size(x, y)
@@ -98,6 +102,14 @@ module Rumale
 
       private
 
+      def enable_mopti?
+        if defined?(Mopti).nil?
+          warn('NeighbourhoodComponentAnalysis#fit requires Mopti but that is not loaded. You should intall and load mopti gem in advance.')
+          return false
+        end
+        true
+      end
+
       def init_components(x, n_features, n_components)
         if @params[:init] == 'pca'
           pca = Rumale::Decomposition::PCA.new(n_components: n_components, solver: 'evd')

data/lib/rumale/model_selection/cross_validation.rb

@@ -69,10 +69,11 @@ module Rumale
       #     the return_train_score is false.
       def perform(x, y)
         x = check_convert_sample_array(x)
-        if @estimator.is_a?(Rumale::Base::Classifier)
+        case @estimator
+        when Rumale::Base::Classifier
           y = check_convert_label_array(y)
           check_sample_label_size(x, y)
-        elsif @estimator.is_a?(Rumale::Base::Regressor)
+        when Rumale::Base::Regressor
           y = check_convert_tvalue_array(y)
           check_sample_tvalue_size(x, y)
         else

data/lib/rumale/model_selection/k_fold.rb

@@ -62,7 +62,7 @@ module Rumale
         end
         sub_rng = @rng.dup
         # Splits dataset ids to each fold.
-        dataset_ids = [*0...n_samples]
+        dataset_ids = Array(0...n_samples)
         dataset_ids.shuffle!(random: sub_rng) if @shuffle
         fold_sets = Array.new(@n_splits) do |n|
           n_fold_samples = n_samples / @n_splits

data/lib/rumale/model_selection/shuffle_split.rb

@@ -74,7 +74,7 @@ module Rumale
         end
         sub_rng = @rng.dup
         # Returns array consisting of the training and testing ids for each fold.
-        dataset_ids = [*0...n_samples]
+        dataset_ids = Array(0...n_samples)
         Array.new(@n_splits) do
           test_ids = dataset_ids.sample(n_test_samples, random: sub_rng)
           train_ids = if @train_size.nil?

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