rumale 0.23.3 → 0.24.0

data/lib/rumale/evaluation_measure/precision_recall.rb

@@ -1,96 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  # This module consists of the classes for model evaluation.
-  module EvaluationMeasure
-    # @!visibility private
-    module PrecisionRecall
-      module_function
-
-      # @!visibility private
-      def precision_each_class(y_true, y_pred)
-        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)
-        end
-      end
-
-      # @!visibility private
-      def recall_each_class(y_true, y_pred)
-        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)
-        end
-      end
-
-      # @!visibility private
-      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
-
-      # @!visibility private
-      def micro_average_precision(y_true, y_pred)
-        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]
-        end
-        res = evaluated_values.transpose.map { |v| v.inject(:+) }
-        res.first / res.last
-      end
-
-      # @!visibility private
-      def micro_average_recall(y_true, y_pred)
-        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]
-        end
-        res = evaluated_values.transpose.map { |v| v.inject(:+) }
-        res.first / res.last
-      end
-
-      # @!visibility private
-      def micro_average_f_score(y_true, y_pred)
-        p = micro_average_precision(y_true, y_pred)
-        r = micro_average_recall(y_true, y_pred)
-        (2.0 * p * r) / (p + r)
-      end
-
-      # @!visibility private
-      def macro_average_precision(y_true, y_pred)
-        precision_each_class(y_true, y_pred).inject(:+) / y_true.to_a.uniq.size
-      end
-
-      # @!visibility private
-      def macro_average_recall(y_true, y_pred)
-        recall_each_class(y_true, y_pred).inject(:+) / y_true.to_a.uniq.size
-      end
-
-      # @!visibility private
-      def macro_average_f_score(y_true, y_pred)
-        f_score_each_class(y_true, y_pred).inject(:+) / y_true.to_a.uniq.size
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/purity.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # Purity is a class that calculates the purity of cluatering results.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::Purity.new
-    #   puts evaluator.score(ground_truth, predicted)
-    #
-    # *Reference*
-    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
-    class Purity
-      include Base::Evaluator
-
-      # Calculate purity
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
-      # @return [Float] Purity
-      def score(y_true, y_pred)
-        y_true = check_convert_label_array(y_true)
-        y_pred = check_convert_label_array(y_pred)
-        # initiazlie some variables.
-        purity = 0
-        n_samples = y_pred.size
-        class_ids = y_true.to_a.uniq
-        cluster_ids = y_pred.to_a.uniq
-        # calculate purity.
-        cluster_ids.each do |k|
-          pr_sample_ids = y_pred.eq(k).where.to_a
-          purity += class_ids.map { |j| (pr_sample_ids & y_true.eq(j).where.to_a).size }.max
-        end
-        purity.fdiv(n_samples)
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/r2_score.rb

@@ -1,43 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/evaluation_measure/precision_recall'
-
-module Rumale
-  module EvaluationMeasure
-    # R2Score is a class that calculates the coefficient of determination for the predicted values.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::R2Score.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class R2Score
-      include Base::Evaluator
-
-      # Create a new evaluation measure calculater for coefficient of determination.
-      def initialize; end
-
-      # Calculate the coefficient of determination.
-      #
-      # @param y_true [Numo::DFloat] (shape: [n_samples, n_outputs]) Ground truth target values.
-      # @param y_pred [Numo::DFloat] (shape: [n_samples, n_outputs]) Estimated taget values.
-      # @return [Float] Coefficient of determination
-      def score(y_true, y_pred)
-        y_true = check_convert_tvalue_array(y_true)
-        y_pred = check_convert_tvalue_array(y_pred)
-        raise ArgumentError, 'Expect to have the same size both y_true and y_pred.' unless y_true.shape == y_pred.shape
-
-        n_samples, n_outputs = y_true.shape
-        numerator = ((y_true - y_pred)**2).sum(0)
-        yt_mean = y_true.sum(0) / n_samples
-        denominator = ((y_true - yt_mean)**2).sum(0)
-        if n_outputs.nil?
-          denominator.zero? ? 0.0 : 1.0 - numerator / denominator
-        else
-          scores = 1 - numerator / denominator
-          scores[denominator.eq(0)] = 0.0
-          scores.sum / scores.size
-        end
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/recall.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/evaluation_measure/precision_recall'
-
-module Rumale
-  # This module consists of the classes for model evaluation.
-  module EvaluationMeasure
-    # Recall is a class that calculates the recall of the predicted labels.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::Recall.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class Recall
-      include Base::Evaluator
-      include EvaluationMeasure::PrecisionRecall
-
-      # Return the average type for calculation of recall.
-      # @return [String] ('binary', 'micro', 'macro')
-      attr_reader :average
-
-      # Create a new evaluation measure calculater for recall score.
-      #
-      # @param average [String] The average type ('binary', 'micro', 'macro')
-      def initialize(average: 'binary')
-        check_params_string(average: average)
-        @average = average
-      end
-
-      # Calculate average recall
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
-      # @return [Float] Average recall
-      def score(y_true, y_pred)
-        y_true = check_convert_label_array(y_true)
-        y_pred = check_convert_label_array(y_pred)
-
-        case @average
-        when 'binary'
-          recall_each_class(y_true, y_pred).last
-        when 'micro'
-          micro_average_recall(y_true, y_pred)
-        when 'macro'
-          macro_average_recall(y_true, y_pred)
-        end
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/roc_auc.rb

@@ -1,130 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # ROCAUC is a class that calculate area under the receiver operation characteristic curve from predicted scores.
-    #
-    # @example
-    #   # Encode labels to integer array.
-    #   labels = %w[A B B C A A C C C A]
-    #   label_encoder = Rumale::Preprocessing::LabelEncoder.new
-    #   y = label_encoder.fit_transform(labels)
-    #   # Fit classifier.
-    #   classifier = Rumale::LinearModel::LogisticRegression.new
-    #   classifier.fit(x, y)
-    #   # Predict class probabilities.
-    #   y_score = classifier.predict_proba(x)
-    #   # Encode labels to one-hot vectors.
-    #   one_hot_encoder = Rumale::Preprocessing::OneHotEncoder.new
-    #   y_onehot = one_hot_encoder.fit_transform(y)
-    #   # Calculate ROC AUC.
-    #   evaluator = Rumale::EvaluationMeasure::ROCAUC.new
-    #   puts evaluator.score(y_onehot, y_score)
-    class ROCAUC
-      include Base::Evaluator
-
-      # Calculate area under the receiver operation characteristic curve (ROC AUC).
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples] or [n_samples, n_classes])
-      #   Ground truth binary labels or one-hot encoded multi-labels.
-      # @param y_score [Numo::DFloat] (shape: [n_samples] or [n_samples, n_classes])
-      #   Predicted class probabilities or confidence scores.
-      # @return [Float] (macro-averaged) ROC AUC.
-      def score(y_true, y_score)
-        y_true = Numo::Int32.cast(y_true) unless y_true.is_a?(Numo::Int32)
-        y_score = Numo::DFloat.cast(y_score) unless y_score.is_a?(Numo::DFloat)
-        raise ArgumentError, 'Expect to have the same shape for y_true and y_score.' unless y_true.shape == y_score.shape
-
-        n_classes = y_score.shape[1]
-        if n_classes.nil?
-          fpr, tpr, = roc_curve(y_true, y_score)
-          return auc(fpr, tpr)
-        end
-
-        scores = Array.new(n_classes) do |c|
-          fpr, tpr, = roc_curve(y_true[true, c], y_score[true, c])
-          auc(fpr, tpr)
-        end
-
-        scores.reduce(&:+).fdiv(n_classes)
-      end
-
-      # Calculate receiver operation characteristic curve.
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth binary labels.
-      # @param y_score [Numo::DFloat] (shape: [n_samples]) Predicted class probabilities or confidence scores.
-      # @param pos_label [Integer] Label to be a positive label when binarizing the given labels.
-      #   If nil is given, the method considers the maximum value of the label as a positive label.
-      # @return [Array] fpr (Numo::DFloat): false positive rates. tpr (Numo::DFloat): true positive rates.
-      #   thresholds (Numo::DFloat): thresholds on the decision function used to calculate fpr and tpr.
-      def roc_curve(y_true, y_score, pos_label = nil)
-        y_true = Numo::Int32.cast(y_true) unless y_true.is_a?(Numo::Int32)
-        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
-        else
-          raise ArgumentError, 'y_true must have elements whose values are pos_label.' unless y_true.to_a.uniq.include?(pos_label)
-        end
-
-        false_pos, true_pos, thresholds = binary_roc_curve(y_true, y_score, pos_label)
-
-        if true_pos.size.zero? || false_pos[0] != 0 || true_pos[0] != 0
-          # NOTE: Numo::NArray#insert is not a destructive method.
-          # rubocop:disable Style/RedundantSelfAssignment
-          true_pos = true_pos.insert(0, 0)
-          false_pos = false_pos.insert(0, 0)
-          thresholds = thresholds.insert(0, thresholds[0] + 1)
-          # rubocop:enable Style/RedundantSelfAssignment
-        end
-
-        tpr = true_pos / true_pos[-1].to_f
-        fpr = false_pos / false_pos[-1].to_f
-
-        [fpr, tpr, thresholds]
-      end
-
-      # Calculate area under the curve using the trapezoidal rule.
-      #
-      # @param x [Numo::Int32/Numo::DFloat] (shape: [n_elements])
-      #   x coordinates. These are expected to monotonously increase or decrease.
-      # @param y [Numo::Int32/Numo::DFloat] (shape: [n_elements]) y coordinates.
-      # @return [Float] area under the curve.
-      def auc(x, y)
-        x = Numo::NArray.asarray(x) unless x.is_a?(Numo::NArray)
-        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
-
-      private
-
-      def binary_roc_curve(y_true, y_score, pos_label = nil)
-        pos_label = y_true.to_a.uniq.max if pos_label.nil?
-
-        bin_y_true = y_true.eq(pos_label)
-        desc_pred_ids = y_score.sort_index.reverse
-
-        desc_y_true = Numo::Int32.cast(bin_y_true[desc_pred_ids])
-        desc_y_score = y_score[desc_pred_ids]
-
-        threshold_ids = Numo::Int32.cast(desc_y_score.diff.ne(0).where.to_a.append(desc_y_true.size - 1))
-
-        true_pos = desc_y_true.cumsum[threshold_ids]
-        false_pos = 1 + threshold_ids - true_pos
-
-        [false_pos, true_pos, desc_y_score[threshold_ids]]
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/silhouette_score.rb

@@ -1,82 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/pairwise_metric'
-
-module Rumale
-  module EvaluationMeasure
-    # SilhouetteScore is a class that calculates the Silhouette Coefficient.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::SilhouetteScore.new
-    #   puts evaluator.score(x, predicted)
-    #
-    # *Reference*
-    # - Rousseuw, P J., "Silhouettes: A graphical aid to the interpretation and validation of cluster analysis," Journal of Computational and Applied Mathematics, Vol. 20, pp. 53--65, 1987.
-    class SilhouetteScore
-      include Base::Evaluator
-
-      # Create a new evaluator that calculates the silhouette coefficient.
-      #
-      # @param metric [String] The metric to calculate the sihouette coefficient.
-      #   If metric is 'euclidean', Euclidean distance is used for dissimilarity between sample points.
-      #   If metric is 'precomputed', the score method expects to be given a distance matrix.
-      def initialize(metric: 'euclidean')
-        check_params_string(metric: metric)
-        @metric = metric
-      end
-
-      # Calculates the silhouette coefficient.
-      #
-      # @param x [Numo::DFloat] (shape: [n_samples, n_features]) The samples to be used for calculating score.
-      # @param y [Numo::Int32] (shape: [n_samples]) The predicted labels for each sample.
-      # @return [Float] The mean of silhouette coefficient.
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-
-        dist_mat = @metric == 'precomputed' ? x : Rumale::PairwiseMetric.euclidean_distance(x)
-
-        labels = y.to_a.uniq.sort
-        n_clusters = labels.size
-        n_samples = dist_mat.shape[0]
-
-        intra_dists = Numo::DFloat.zeros(n_samples)
-        n_clusters.times do |n|
-          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)
-        end
-
-        inter_dists = Numo::DFloat.zeros(n_samples) + Float::INFINITY
-        n_clusters.times do |m|
-          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)
-            )
-          end
-        end
-
-        mask = Numo::DFloat.ones(n_samples)
-        n_clusters.times do |n|
-          cls_pos = y.eq(labels[n])
-          mask[cls_pos] = 0 unless cls_pos.count > 1
-        end
-
-        silhouettes = mask * ((inter_dists - intra_dists) / Numo::DFloat.maximum(inter_dists, intra_dists))
-        silhouettes[silhouettes.isnan] = 0.0
-
-        silhouettes.mean
-      end
-    end
-  end
-end

data/lib/rumale/feature_extraction/feature_hasher.rb

@@ -1,110 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/base_estimator'
-require 'rumale/base/transformer'
-
-module Rumale
-  module FeatureExtraction
-    # Encode array of feature-value hash to vectors with feature hashing (hashing trick).
-    # This encoder turns array of mappings (Array<Hash>) with pairs of feature names and values into Numo::NArray.
-    # 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],
-    #   #  [0, 0, 0, -2, -5, 0, 0, 0, 0, 0]]
-    class FeatureHasher
-      include Base::BaseEstimator
-      include Base::Transformer
-
-      # Create a new encoder for converting array of hash consisting of feature names and values to vectors
-      # with feature hashing algorith.
-      #
-      # @param n_features [Integer] The number of features of encoded samples.
-      # @param alternate_sign [Boolean] The flag indicating whether to reflect the sign of the hash value to the feature value.
-      def initialize(n_features: 1024, alternate_sign: true)
-        check_params_numeric(n_features: n_features)
-        check_params_boolean(alternate_sign: alternate_sign)
-        @params = {}
-        @params[:n_features] = n_features
-        @params[:alternate_sign] = alternate_sign
-      end
-
-      # This method does not do anything. The encoder does not require training.
-      #
-      # @overload fit(x) -> FeatureHasher
-      #   @param x [Array<Hash>] (shape: [n_samples]) The array of hash consisting of feature names and values.
-      #   @return [FeatureHasher]
-      def fit(_x = nil, _y = nil)
-        self
-      end
-
-      # Encode given the array of feature-value hash.
-      # This method has the same output as the transform method
-      # because the encoder does not require training.
-      #
-      # @overload fit_transform(x) -> Numo::DFloat
-      #   @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 fit_transform(x, _y = nil)
-        fit(x).transform(x)
-      end
-
-      # Encode given the array of feature-value hash.
-      #
-      # @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
-
-        z = Numo::DFloat.zeros(n_samples, n_features)
-
-        x.each_with_index do |f, i|
-          f.each do |k, v|
-            k = "#{k}=#{v}" if v.is_a?(String)
-            val = v.is_a?(String) ? 1 : v
-            next if val.zero?
-
-            h = Mmh3.hash32(k)
-            fid = h.abs % n_features
-            val *= h >= 0 ? 1 : -1 if alternate_sign?
-            z[i, fid] = val
-          end
-        end
-
-        z
-      end
-
-      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
-
-      def alternate_sign?
-        @params[:alternate_sign]
-      end
-    end
-  end
-end