rumale 0.23.3 → 0.24.0

data/lib/rumale/evaluation_measure/calinski_harabasz_score.rb

@@ -1,56 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # CalinskiHarabaszScore is a class that calculates the Calinski and Harabasz score.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::CalinskiHarabaszScore.new
-    #   puts evaluator.score(x, predicted)
-    #
-    # *Reference*
-    # - Calinski, T., and Harabsz, J., "A dendrite method for cluster analysis," Communication in Statistics, Vol. 3 (1), pp. 1--27, 1972.
-    class CalinskiHarabaszScore
-      include Base::Evaluator
-
-      # Calculates the Calinski and Harabasz score.
-      #
-      # @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 Calinski and Harabasz score.
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-
-        labels = y.to_a.uniq.sort
-        n_clusters = labels.size
-        n_dimensions = x.shape[1]
-
-        centroids = Numo::DFloat.zeros(n_clusters, n_dimensions)
-
-        within_group = 0.0
-        n_clusters.times do |n|
-          cls_samples = x[y.eq(labels[n]), true]
-          cls_centroid = cls_samples.mean(0)
-          centroids[n, true] = cls_centroid
-          within_group += ((cls_samples - cls_centroid)**2).sum
-        end
-
-        return 1.0 if within_group.zero?
-
-        mean_vec = x.mean(0)
-        between_group = 0.0
-        n_clusters.times do |n|
-          sz_cluster = y.eq(labels[n]).count
-          between_group += sz_cluster * ((centroids[n, true] - mean_vec)**2).sum
-        end
-
-        n_samples = x.shape[0]
-        (between_group / (n_clusters - 1)) / (within_group / (n_samples - n_clusters))
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/davies_bouldin_score.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/pairwise_metric'
-
-module Rumale
-  module EvaluationMeasure
-    # DaviesBouldinScore is a class that calculates the Davies-Bouldin score.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::DaviesBouldinScore.new
-    #   puts evaluator.score(x, predicted)
-    #
-    # *Reference*
-    # - Davies, D L., and Bouldin, D W., "A Cluster Separation Measure," IEEE Trans. Pattern Analysis and Machine Intelligence, Vol. PAMI-1, No. 2, pp. 224--227, 1979.
-    class DaviesBouldinScore
-      include Base::Evaluator
-
-      # Calculates the Davies-Bouldin score.
-      #
-      # @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 Davies-Bouldin score.
-      def score(x, y)
-        x = check_convert_sample_array(x)
-        y = check_convert_label_array(y)
-        check_sample_label_size(x, y)
-
-        labels = y.to_a.uniq.sort
-        n_clusters = labels.size
-        n_dimensions = x.shape[1]
-
-        dist_cluster = Numo::DFloat.zeros(n_clusters)
-        centroids = Numo::DFloat.zeros(n_clusters, n_dimensions)
-
-        n_clusters.times do |n|
-          cls_samples = x[y.eq(labels[n]), true]
-          cls_centroid = cls_samples.mean(0)
-          centroids[n, true] = cls_centroid
-          dist_cluster[n] = Rumale::PairwiseMetric.euclidean_distance(cls_samples, cls_centroid.expand_dims(0)).mean
-        end
-
-        dist_centroid = Rumale::PairwiseMetric.euclidean_distance(centroids)
-        # p dist_cluster
-        # p dist_centroid
-        dist_centroid[dist_centroid.eq(0)] = Float::INFINITY
-        dist_mat = (dist_cluster.expand_dims(1) + dist_cluster) / dist_centroid
-        dist_mat[dist_mat.diag_indices] = -Float::INFINITY
-        dist_mat.max(0).mean
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/explained_variance_score.rb

@@ -1,39 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # ExplainedVarianceScore is a class that calculates the explained variance score.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::ExplainedVarianceScore.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class ExplainedVarianceScore
-      include Base::Evaluator
-
-      # Calculate explained variance score.
-      #
-      # @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 target values.
-      # @return [Float] Explained variance score.
-      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
-
-        diff = y_true - y_pred
-        numerator = ((diff - diff.mean(0))**2).mean(0)
-        denominator = ((y_true - y_true.mean(0))**2).mean(0)
-
-        n_outputs = y_true.shape[1]
-        if n_outputs.nil?
-          denominator.zero? ? 0 : 1.0 - numerator / denominator
-        else
-          valids = denominator.ne(0)
-          (1.0 - numerator[valids] / denominator[valids]).sum / n_outputs
-        end
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/f_score.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
-    # FScore is a class that calculates the F1-score of the predicted labels.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::FScore.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class FScore
-      include Base::Evaluator
-      include EvaluationMeasure::PrecisionRecall
-
-      # Return the average type for calculation of F1-score.
-      # @return [String] ('binary', 'micro', 'macro')
-      attr_reader :average
-
-      # Create a new evaluation measure calculater for F1-score.
-      #
-      # @param average [String] The average type ('binary', 'micro', 'macro')
-      def initialize(average: 'binary')
-        check_params_string(average: average)
-        @average = average
-      end
-
-      # Calculate average F1-score
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
-      # @return [Float] Average F1-score
-      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'
-          f_score_each_class(y_true, y_pred).last
-        when 'micro'
-          micro_average_f_score(y_true, y_pred)
-        when 'macro'
-          macro_average_f_score(y_true, y_pred)
-        end
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/function.rb

@@ -1,147 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/validation'
-require 'rumale/evaluation_measure/accuracy'
-require 'rumale/evaluation_measure/precision_recall'
-
-module Rumale
-  module EvaluationMeasure
-    module_function
-
-    # Calculate confusion matrix for evaluating classification performance.
-    #
-    # @example
-    #   y_true = Numo::Int32[2, 0, 2, 2, 0, 1]
-    #   y_pred = Numo::Int32[0, 0, 2, 2, 0, 2]
-    #   p Rumale::EvaluationMeasure.confusion_matrix(y_true, y_pred)
-    #
-    #   # Numo::Int32#shape=[3,3]
-    #   # [[2, 0, 0],
-    #   #  [0, 0, 1],
-    #   #  [1, 0, 2]]
-    #
-    # @param y_true [Numo::Int32] (shape: [n_samples]) The ground truth labels.
-    # @param y_pred [Numo::Int32] (shape: [n_samples]) The predicted labels.
-    # @return [Numo::Int32] (shape: [n_classes, n_classes]) The confusion matrix.
-    def confusion_matrix(y_true, y_pred)
-      y_true = Rumale::Validation.check_convert_label_array(y_true)
-      y_pred = Rumale::Validation.check_convert_label_array(y_pred)
-
-      labels = y_true.to_a.uniq.sort
-      n_labels = labels.size
-
-      conf_mat = Numo::Int32.zeros(n_labels, n_labels)
-
-      labels.each_with_index do |lbl_a, i|
-        y_p = y_pred[y_true.eq(lbl_a)]
-        labels.each_with_index do |lbl_b, j|
-          conf_mat[i, j] = y_p.eq(lbl_b).count
-        end
-      end
-
-      conf_mat
-    end
-
-    # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
-
-    # Output a summary of classification performance for each class.
-    #
-    # @example
-    #   y_true = Numo::Int32[0, 1, 1, 2, 2, 2, 0]
-    #   y_pred = Numo::Int32[1, 1, 1, 0, 0, 2, 0]
-    #   puts Rumale::EvaluationMeasure.classification_report(y_true, y_pred)
-    #
-    #   #               precision    recall  f1-score   support
-    #   #
-    #   #            0       0.33      0.50      0.40         2
-    #   #            1       0.67      1.00      0.80         2
-    #   #            2       1.00      0.33      0.50         3
-    #   #
-    #   #     accuracy                           0.57         7
-    #   #    macro avg       0.67      0.61      0.57         7
-    #   # weighted avg       0.71      0.57      0.56         7
-    #
-    # @param y_true [Numo::Int32] (shape: [n_samples]) The ground truth labels.
-    # @param y_pred [Numo::Int32] (shape: [n_samples]) The predicted labels.
-    # @param target_name [Nil/Array] The label names.
-    # @param output_hash [Boolean] The flag indicating whether to output with Ruby Hash.
-    # @return [String/Hash] The summary of classification performance.
-    #   If output_hash is true, it returns the summary with Ruby Hash.
-    def classification_report(y_true, y_pred, target_name: nil, output_hash: false)
-      y_true = Rumale::Validation.check_convert_label_array(y_true)
-      y_pred = Rumale::Validation.check_convert_label_array(y_pred)
-      # calculate each evaluation measure.
-      classes = y_true.to_a.uniq.sort
-      supports = Numo::Int32.asarray(classes.map { |label| y_true.eq(label).count })
-      precisions = Rumale::EvaluationMeasure::PrecisionRecall.precision_each_class(y_true, y_pred)
-      recalls = Rumale::EvaluationMeasure::PrecisionRecall.recall_each_class(y_true, y_pred)
-      fscores = Rumale::EvaluationMeasure::PrecisionRecall.f_score_each_class(y_true, y_pred)
-      macro_precision = Rumale::EvaluationMeasure::PrecisionRecall.macro_average_precision(y_true, y_pred)
-      macro_recall = Rumale::EvaluationMeasure::PrecisionRecall.macro_average_recall(y_true, y_pred)
-      macro_fscore = Rumale::EvaluationMeasure::PrecisionRecall.macro_average_f_score(y_true, y_pred)
-      accuracy = Rumale::EvaluationMeasure::Accuracy.new.score(y_true, y_pred)
-      sum_supports = supports.sum
-      weights = Numo::DFloat.cast(supports) / sum_supports
-      weighted_precision = (Numo::DFloat.cast(precisions) * weights).sum
-      weighted_recall = (Numo::DFloat.cast(recalls) * weights).sum
-      weighted_fscore = (Numo::DFloat.cast(fscores) * weights).sum
-      # output reults.
-      target_name ||= classes
-      target_name.map!(&:to_s)
-      if output_hash
-        res = {}
-        target_name.each_with_index do |label, n|
-          res[label] = {
-            precision: precisions[n],
-            recall: recalls[n],
-            fscore: fscores[n],
-            support: supports[n]
-          }
-        end
-        res[:accuracy] = accuracy
-        res[:macro_avg] = {
-          precision: macro_precision,
-          recall: macro_recall,
-          fscore: macro_fscore,
-          support: sum_supports
-        }
-        res[:weighted_avg] = {
-          precision: weighted_precision,
-          recall: weighted_recall,
-          fscore: weighted_fscore,
-          support: sum_supports
-        }
-      else
-        width = [12, target_name.map(&:size).max].max # 12 is 'weighted avg'.size
-        res = +''
-        res << "#{' ' * width}  precision    recall  f1-score   support\n"
-        res << "\n"
-        target_name.each_with_index do |label, n|
-          label_str = format("%##{width}s", label)
-          precision_str = format('%#10s', format('%.2f', precisions[n]))
-          recall_str = format('%#10s', format('%.2f', recalls[n]))
-          fscore_str = format('%#10s', format('%.2f', fscores[n]))
-          supports_str = format('%#10s', supports[n])
-          res << "#{label_str} #{precision_str}#{recall_str}#{fscore_str}#{supports_str}\n"
-        end
-        res << "\n"
-        supports_str = format('%#10s', sum_supports)
-        accuracy_str = format('%#30s', format('%.2f', accuracy))
-        res << format("%##{width}s ", 'accuracy')
-        res << "#{accuracy_str}#{supports_str}\n"
-        precision_str = format('%#10s', format('%.2f', macro_precision))
-        recall_str = format('%#10s', format('%.2f', macro_recall))
-        fscore_str = format('%#10s', format('%.2f', macro_fscore))
-        res << format("%##{width}s ", 'macro avg')
-        res << "#{precision_str}#{recall_str}#{fscore_str}#{supports_str}\n"
-        precision_str = format('%#10s', format('%.2f', weighted_precision))
-        recall_str = format('%#10s', format('%.2f', weighted_recall))
-        fscore_str = format('%#10s', format('%.2f', weighted_fscore))
-        res << format("%##{width}s ", 'weighted avg')
-        res << "#{precision_str}#{recall_str}#{fscore_str}#{supports_str}\n"
-      end
-      res
-    end
-    # rubocop:enable Metrics/MethodLength, Metrics/AbcSize
-  end
-end

data/lib/rumale/evaluation_measure/log_loss.rb

@@ -1,45 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/preprocessing/label_binarizer'
-
-module Rumale
-  module EvaluationMeasure
-    # LogLoss is a class that calculates the logarithmic loss of predicted class probability.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::LogLoss.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class LogLoss
-      include Base::Evaluator
-
-      # Calculate mean logarithmic loss.
-      # If both y_true and y_pred are array (both shapes are [n_samples]), this method calculates
-      # mean logarithmic loss for binary classification.
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::DFloat] (shape: [n_samples, n_classes]) Predicted class probability.
-      # @param eps [Float] A small value close to zero to avoid outputting infinity in logarithmic calcuation.
-      # @return [Float] mean logarithmic loss
-      def score(y_true, y_pred, eps = 1e-15)
-        y_true = check_convert_label_array(y_true)
-        y_pred = check_convert_tvalue_array(y_pred)
-
-        n_samples, n_classes = y_pred.shape
-        clipped_p = y_pred.clip(eps, 1 - eps)
-
-        log_loss = if n_classes.nil?
-                     negative_label = y_true.to_a.uniq.min
-                     bin_y_true = Numo::DFloat.cast(y_true.ne(negative_label))
-                     -(bin_y_true * Numo::NMath.log(clipped_p) + (1 - bin_y_true) * Numo::NMath.log(1 - clipped_p))
-                   else
-                     encoder = Rumale::Preprocessing::LabelBinarizer.new
-                     encoded_y_true = Numo::DFloat.cast(encoder.fit_transform(y_true))
-                     clipped_p /= clipped_p.sum(1).expand_dims(1)
-                     -(encoded_y_true * Numo::NMath.log(clipped_p)).sum(1)
-                   end
-        log_loss.sum / n_samples
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/mean_absolute_error.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # MeanAbsoluteError is a class that calculates the mean absolute error.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::MeanAbsoluteError.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class MeanAbsoluteError
-      include Base::Evaluator
-
-      # Calculate mean absolute error.
-      #
-      # @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 target values.
-      # @return [Float] Mean absolute error
-      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
-
-        (y_true - y_pred).abs.mean
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/mean_squared_error.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # MeanSquaredError is a class that calculates the mean squared error.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::MeanSquaredError.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class MeanSquaredError
-      include Base::Evaluator
-
-      # Calculate mean squared error.
-      #
-      # @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 target values.
-      # @return [Float] Mean squared error
-      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
-
-        ((y_true - y_pred)**2).mean
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/mean_squared_log_error.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # MeanSquaredLogError is a class that calculates the mean squared logarithmic error.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::MeanSquaredError.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class MeanSquaredLogError
-      include Base::Evaluator
-
-      # Calculate mean squared logarithmic error.
-      #
-      # @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 target values.
-      # @return [Float] Mean squared logarithmic error.
-      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
-
-        ((Numo::NMath.log(y_true + 1) - Numo::NMath.log(y_pred + 1))**2).mean
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/median_absolute_error.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # MedianAbsoluteError is a class that calculates the median absolute error.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::MedianAbsoluteError.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class MedianAbsoluteError
-      include Base::Evaluator
-
-      # Calculate median absolute error.
-      #
-      # @param y_true [Numo::DFloat] (shape: [n_samples]) Ground truth target values.
-      # @param y_pred [Numo::DFloat] (shape: [n_samples]) Estimated target values.
-      # @return [Float] Median absolute error.
-      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
-        raise ArgumentError, 'Expect target values to be 1-D arrray' if [y_true.shape.size, y_pred.shape.size].max > 1
-
-        (y_true - y_pred).abs.median
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/mutual_information.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-
-module Rumale
-  module EvaluationMeasure
-    # MutualInformation is a class that calculates the mutual information.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::MutualInformation.new
-    #   puts evaluator.score(ground_truth, predicted)
-    #
-    # *Reference*
-    # - Vinh, N X., Epps, J., and Bailey, J., "Information Theoretic Measures for Clusterings Comparison: Variants, Properties, Normalization and Correction for Chance," J. Machine Learning Research, vol. 11, pp. 2837--1854, 2010.
-    class MutualInformation
-      include Base::Evaluator
-
-      # Calculate mutual information
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
-      # @return [Float] Mutual information.
-      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.
-        mutual_information = 0.0
-        n_samples = y_pred.size
-        class_ids = y_true.to_a.uniq
-        cluster_ids = y_pred.to_a.uniq
-        # calculate mutual information.
-        cluster_ids.map do |k|
-          pr_sample_ids = y_pred.eq(k).where.to_a
-          n_pr_samples = pr_sample_ids.size
-          class_ids.map do |j|
-            tr_sample_ids = y_true.eq(j).where.to_a
-            n_tr_samples = tr_sample_ids.size
-            n_intr_samples = (pr_sample_ids & tr_sample_ids).size
-            if n_intr_samples.positive?
-              mutual_information +=
-                n_intr_samples.fdiv(n_samples) * Math.log((n_samples * n_intr_samples).fdiv(n_pr_samples * n_tr_samples))
-            end
-          end
-        end
-        mutual_information
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/normalized_mutual_information.rb

@@ -1,53 +0,0 @@
-# frozen_string_literal: true
-
-require 'rumale/base/evaluator'
-require 'rumale/evaluation_measure/mutual_information'
-
-module Rumale
-  module EvaluationMeasure
-    # NormalizedMutualInformation is a class that calculates the normalized mutual information.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::NormalizedMutualInformation.new
-    #   puts evaluator.score(ground_truth, predicted)
-    #
-    # *Reference*
-    # - Manning, C D., Raghavan, P., and Schutze, H., "Introduction to Information Retrieval," Cambridge University Press., 2008.
-    # - Vinh, N X., Epps, J., and Bailey, J., "Information Theoretic Measures for Clusterings Comparison: Variants, Properties, Normalization and Correction for Chance," J. Machine Learning Research, vol. 11, pp. 2837--1854, 2010.
-    class NormalizedMutualInformation
-      include Base::Evaluator
-
-      # Calculate noramlzied mutual information
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted cluster labels.
-      # @return [Float] Normalized mutual information
-      def score(y_true, y_pred)
-        y_true = check_convert_label_array(y_true)
-        y_pred = check_convert_label_array(y_pred)
-        # 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)
-      end
-
-      private
-
-      def entropy(y)
-        n_samples = y.size
-        indices = y.to_a.uniq
-        sum_log = indices.map do |k|
-          ratio = y.eq(k).count.fdiv(n_samples)
-          ratio * Math.log(ratio)
-        end.reduce(:+)
-        -sum_log
-      end
-    end
-  end
-end

data/lib/rumale/evaluation_measure/precision.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
-    # Precision is a class that calculates the preicision of the predicted labels.
-    #
-    # @example
-    #   evaluator = Rumale::EvaluationMeasure::Precision.new
-    #   puts evaluator.score(ground_truth, predicted)
-    class Precision
-      include Base::Evaluator
-      include EvaluationMeasure::PrecisionRecall
-
-      # Return the average type for calculation of precision.
-      # @return [String] ('binary', 'micro', 'macro')
-      attr_reader :average
-
-      # Create a new evaluation measure calculater for precision score.
-      #
-      # @param average [String] The average type ('binary', 'micro', 'macro')
-      def initialize(average: 'binary')
-        check_params_string(average: average)
-        @average = average
-      end
-
-      # Calculate average precision.
-      #
-      # @param y_true [Numo::Int32] (shape: [n_samples]) Ground truth labels.
-      # @param y_pred [Numo::Int32] (shape: [n_samples]) Predicted labels.
-      # @return [Float] Average precision
-      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'
-          precision_each_class(y_true, y_pred).last
-        when 'micro'
-          micro_average_precision(y_true, y_pred)
-        when 'macro'
-          macro_average_precision(y_true, y_pred)
-        end
-      end
-    end
-  end
-end