rumale 0.18.6 → 0.19.3

data/lib/rumale/clustering/power_iteration.rb

@@ -71,6 +71,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input affinity matrix to be square.' if @params[:affinity] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -107,6 +108,7 @@ module Rumale
           new_embedded_line /= new_embedded_line.abs.sum
           new_error = (new_embedded_line - embedded_line).abs
           break if (new_error - error).abs.max <= tol
+
           embedded_line = new_embedded_line
           error = new_error
         end

data/lib/rumale/clustering/single_linkage.rb

@@ -54,6 +54,7 @@ module Rumale
       def fit(x, _y = nil)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         fit_predict(x)
         self
       end
@@ -66,6 +67,7 @@ module Rumale
       def fit_predict(x)
         x = check_convert_sample_array(x)
         raise ArgumentError, 'Expect the input distance matrix to be square.' if @params[:metric] == 'precomputed' && x.shape[0] != x.shape[1]
+
         distance_mat = @params[:metric] == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
         @labels = partial_fit(distance_mat)
       end

data/lib/rumale/dataset.rb

@@ -65,6 +65,7 @@ module Rumale
         Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
         raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
         raise RangeError, 'The interval of factor is (0, 1).' if factor <= 0 || factor >= 1
+
         # initialize some variables.
         rs = random_seed
         rs ||= srand
@@ -80,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
@@ -101,6 +102,7 @@ module Rumale
         Rumale::Validation.check_params_boolean(shuffle: shuffle)
         Rumale::Validation.check_params_numeric_or_nil(noise: noise, random_seed: random_seed)
         raise ArgumentError, 'The number of samples must be more than 2.' if n_samples <= 1
+
         # initialize some variables.
         rs = random_seed
         rs ||= srand
@@ -116,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
@@ -171,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/factor_analysis.rb

@@ -90,9 +90,11 @@ module Rumale
           @components = (sqrt_noise_variance.diag.dot(u) * scaler).transpose.dup
           @noise_variance = Numo::DFloat.maximum(sample_vars - @components.transpose.dot(@components).diagonal, 1e-12)
           next if @params[:tol].nil?
+
           new_loglike = log_likelihood(cov_mat, @components, @noise_variance)
           @loglike.push(new_loglike)
           break if (old_loglike - new_loglike).abs <= @params[:tol]
+
           old_loglike = new_loglike
         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
@@ -87,6 +98,7 @@ module Rumale
             @params[:max_iter].times do
               updated = orthogonalize(covariance_mat.dot(comp_vec))
               break if (updated.dot(comp_vec) - 1).abs < @params[:tol]
+
               comp_vec = updated
             end
             @components = @components.nil? ? comp_vec : Numo::NArray.vstack([@components, comp_vec])
@@ -127,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/ensemble/ada_boost_classifier.rb

@@ -105,6 +105,7 @@ module Rumale
           # Fit classfier.
           ids = Rumale::Utils.choice_ids(n_samples, observation_weights, sub_rng)
           break if y[ids].to_a.uniq.size != n_classes
+
           tree = Tree::DecisionTreeClassifier.new(
             criterion: @params[:criterion], max_depth: @params[:max_depth],
             max_leaf_nodes: @params[:max_leaf_nodes], min_samples_leaf: @params[:min_samples_leaf],
@@ -120,12 +121,14 @@ module Rumale
           @estimators.push(tree)
           @feature_importances += tree.feature_importances
           break if error.zero?
+
           # Update observation weights.
           log_proba = Numo::NMath.log(proba)
           observation_weights *= Numo::NMath.exp(-1.0 * (n_classes - 1).fdiv(n_classes) * (y_codes * log_proba).sum(1))
           observation_weights = observation_weights.clip(1.0e-15, nil)
           sum_observation_weights = observation_weights.sum
           break if sum_observation_weights.zero?
+
           observation_weights /= sum_observation_weights
         end
         @feature_importances /= @feature_importances.sum

data/lib/rumale/ensemble/ada_boost_regressor.rb

@@ -93,6 +93,7 @@ module Rumale
         check_sample_tvalue_size(x, y)
         # Check target values
         raise ArgumentError, 'Expect target value vector to be 1-D arrray' unless y.shape.size == 1
+
         # Initialize some variables.
         n_samples, n_features = x.shape
         @params[:max_features] = n_features unless @params[:max_features].is_a?(Integer)
@@ -117,6 +118,7 @@ module Rumale
           abs_err = ((p - y) / y).abs
           err = observation_weights[abs_err.gt(@params[:threshold])].sum
           break if err <= 0.0
+
           # Calculate weight.
           beta = err**@params[:exponent]
           weight = Math.log(1.fdiv(beta))
@@ -131,6 +133,7 @@ module Rumale
           observation_weights = observation_weights.clip(1.0e-15, nil)
           sum_observation_weights = observation_weights.sum
           break if sum_observation_weights.zero?
+
           observation_weights /= sum_observation_weights
         end
         @estimator_weights = Numo::DFloat.asarray(@estimator_weights)

data/lib/rumale/evaluation_measure/function.rb

@@ -86,7 +86,8 @@ module Rumale
       weighted_recall = (Numo::DFloat.cast(recalls) * weights).sum
       weighted_fscore = (Numo::DFloat.cast(fscores) * weights).sum
       # output reults.
-      target_name ||= classes.map(&:to_s)
+      target_name ||= classes
+      target_name.map!(&:to_s)
       if output_hash
         res = {}
         target_name.each_with_index do |label, n|

data/lib/rumale/evaluation_measure/normalized_mutual_information.rb

@@ -28,8 +28,10 @@ module Rumale
         # calculate entropies.
         class_entropy = entropy(y_true)
         return 0.0 if class_entropy.zero?
+
         cluster_entropy = entropy(y_pred)
         return 0.0 if cluster_entropy.zero?
+
         # calculate mutual information.
         mi = MutualInformation.new
         mi.score(y_true, y_pred) / Math.sqrt(class_entropy * cluster_entropy)

data/lib/rumale/evaluation_measure/precision_recall.rb

@@ -14,6 +14,7 @@ module Rumale
         y_true.sort.to_a.uniq.map do |label|
           target_positions = y_pred.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_positives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           n_true_positives / (n_true_positives + n_false_positives)
@@ -25,6 +26,7 @@ module Rumale
         y_true.sort.to_a.uniq.map do |label|
           target_positions = y_true.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_negatives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           n_true_positives / (n_true_positives + n_false_negatives)
@@ -35,6 +37,7 @@ module Rumale
       def f_score_each_class(y_true, y_pred)
         precision_each_class(y_true, y_pred).zip(recall_each_class(y_true, y_pred)).map do |p, r|
           next 0.0 if p.zero? && r.zero?
+
           (2.0 * p * r) / (p + r)
         end
       end
@@ -44,6 +47,7 @@ module Rumale
         evaluated_values = y_true.sort.to_a.uniq.map do |label|
           target_positions = y_pred.eq(label)
           next [0.0, 0.0] if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_positives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           [n_true_positives, n_true_positives + n_false_positives]
@@ -57,6 +61,7 @@ module Rumale
         evaluated_values = y_true.sort.to_a.uniq.map do |label|
           target_positions = y_true.eq(label)
           next 0.0 if y_pred[target_positions].empty?
+
           n_true_positives = Numo::Int32.cast(y_true[target_positions].eq(y_pred[target_positions])).sum.to_f
           n_false_negatives = Numo::Int32.cast(y_true[target_positions].ne(y_pred[target_positions])).sum.to_f
           [n_true_positives, n_true_positives + n_false_negatives]

data/lib/rumale/evaluation_measure/roc_auc.rb

@@ -64,6 +64,7 @@ module Rumale
         y_score = Numo::DFloat.cast(y_score) unless y_score.is_a?(Numo::DFloat)
         raise ArgumentError, 'Expect y_true to be 1-D arrray.' unless y_true.shape[1].nil?
         raise ArgumentError, 'Expect y_score to be 1-D arrray.' unless y_score.shape[1].nil?
+
         labels = y_true.to_a.uniq
         if pos_label.nil?
           raise ArgumentError, 'y_true must be binary labels or pos_label must be specified if y_true is multi-label' unless labels.size == 2
@@ -96,8 +97,10 @@ module Rumale
         y = Numo::NArray.asarray(y) unless y.is_a?(Numo::NArray)
         raise ArgumentError, 'Expect x to be 1-D arrray.' unless x.shape[1].nil?
         raise ArgumentError, 'Expect y to be 1-D arrray.' unless y.shape[1].nil?
+
         n_samples = [x.shape[0], y.shape[0]].min
         raise ArgumentError, 'At least two points are required to calculate area under curve.' if n_samples < 2
+
         (0...n_samples).to_a.each_cons(2).map { |i, j| 0.5 * (x[i] - x[j]).abs * (y[i] + y[j]) }.reduce(&:+)
       end
 

data/lib/rumale/evaluation_measure/silhouette_score.rb

@@ -47,6 +47,7 @@ module Rumale
           cls_pos = y.eq(labels[n])
           sz_cluster = cls_pos.count
           next unless sz_cluster > 1
+
           cls_dist_mat = dist_mat[cls_pos, cls_pos].dup
           cls_dist_mat[cls_dist_mat.diag_indices] = 0.0
           intra_dists[cls_pos] = cls_dist_mat.sum(0) / (sz_cluster - 1)
@@ -57,6 +58,7 @@ module Rumale
           cls_pos = y.eq(labels[m])
           n_clusters.times do |n|
             next if m == n
+
             not_cls_pos = y.eq(labels[n])
             inter_dists[cls_pos] = Numo::DFloat.minimum(
               inter_dists[cls_pos], dist_mat[cls_pos, not_cls_pos].mean(1)

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/hash_vectorizer.rb

@@ -71,6 +71,7 @@ module Rumale
           f.each do |k, v|
             k = "#{k}#{separator}#{v}".to_sym if v.is_a?(String)
             next if @vocabulary.key?(k)
+
             @feature_names.push(k)
             @vocabulary[k] = @vocabulary.size
           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